diff --git a/.forgejo/workflows/check.yml b/.forgejo/workflows/check.yml new file mode 100644 index 0000000..b547c34 --- /dev/null +++ b/.forgejo/workflows/check.yml @@ -0,0 +1,24 @@ +name: check + +# Fast-fail lint/test on short-lived work branches, before it ever reaches +# main and triggers a dev-track release build. +on: + push: + branches: ['feature/**', 'fix/**'] + +jobs: + check: + runs-on: [self-hosted, hestia] + steps: + - name: checkout + run: | + set -euo pipefail + rm -rf src && mkdir src + git clone --branch "${GITHUB_REF_NAME}" --depth 1 \ + "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" src + + - name: clippy + run: cd src && bash ci/build.sh cargo clippy --workspace --all-targets --locked -- -D warnings + + - name: test + run: cd src && bash ci/build.sh cargo test --workspace --locked diff --git a/.forgejo/workflows/dev-release.yml b/.forgejo/workflows/dev-release.yml new file mode 100644 index 0000000..9ef75cc --- /dev/null +++ b/.forgejo/workflows/dev-release.yml @@ -0,0 +1,93 @@ +name: dev release + +# Publishes a dev-track build on every push to `main` (the trunk +# branch — there is no separate `dev` branch). See bread-ecosystem's +# docs/release-channels.md for the release-track policy this is part of. +on: + push: + branches: ['main'] + +jobs: + build: + runs-on: [self-hosted, hestia] + steps: + - name: checkout + run: | + set -euo pipefail + rm -rf src && mkdir src + git clone --branch main --depth 1 \ + "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" src + + # Fails fast, before the expensive release build/test below, on any + # drift between api-schema.toml, the actual bread.*/IPC/CLI surface, + # Documentation.md, and README.md — see api-schema.toml's header and + # CONTRIBUTING.md's "Keeping the API docs honest" section. + - name: check-docs + run: cd src && cargo run -p xtask --locked -- check-docs + + - name: build + run: cd src && bash ci/build.sh cargo build --release --locked + + - name: test + run: cd src && bash ci/build.sh cargo test --release --locked --workspace + + # breadd/Cargo.toml is the canonical version source (this workspace has + # no shared workspace.package.version — breadd and bread-cli are kept + # in lockstep manually). + - name: compute dev version + run: | + set -euo pipefail + cd src + # Base the dev version off the latest published stable tag, + # not Cargo.toml — Cargo.toml can go stale relative to the last + # real release (seen in practice: breadbox/breadpad/breadcrumbs/ + # breadpaper), which would make a dev build sort as OLDER than + # what's already installed and bakery would correctly refuse it. + LATEST_TAG="$(git ls-remote --tags --refs \ + "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" 'v*' \ + | awk -F/ '{print $NF}' | sed 's/^v//' | (grep -v -- '-' || true) | sort -V | tail -1)" + if [ -n "${LATEST_TAG}" ]; then + CUR="${LATEST_TAG}" + else + CUR="$(grep -m1 '^version' breadd/Cargo.toml | sed -E 's/.*"(.*)".*/\1/')" + fi + IFS='.' read -r MA MI PA <<< "${CUR}" + SHA="$(git rev-parse --short HEAD)" + TS="$(date -u +%Y%m%d%H%M%S)" + echo "VERSION=${MA}.${MI}.$((PA + 1))-dev.${TS}+${SHA}" >> "$GITHUB_ENV" + + - name: prepare artifacts + run: | + set -euo pipefail + PKG_DIR="/srv/breadway-dl/dev/bread/${VERSION}" + mkdir -p "${PKG_DIR}" + for bin in breadd bread bread-emit bread-module-host; do + cp "src/target/release/${bin}" "${PKG_DIR}/${bin}-x86_64" + strip "${PKG_DIR}/${bin}-x86_64" + sha256sum "${PKG_DIR}/${bin}-x86_64" | awk '{print $1}' \ + > "${PKG_DIR}/${bin}-x86_64.sha256" + done + cp src/packaging/systemd/breadd.service "${PKG_DIR}/" + cp src/LICENSE "${PKG_DIR}/" + cp src/bakery.toml "${PKG_DIR}/bakery.toml" + ln -sfn "${VERSION}" "/srv/breadway-dl/dev/bread/latest" + + # No GitHub Release upload — dev builds happen on every push and would + # spam a release per commit, so dl.breadway.dev/dev/ is the only + # distribution point for this track. + - name: regenerate dev index.json + env: + MINISIGN_SEC_KEY: ${{ secrets.BAKERY_MINISIGN_SEC_KEY_PATH }} + run: | + set -euo pipefail + if [ -z "${MINISIGN_SEC_KEY:-}" ]; then + echo "::error::BAKERY_MINISIGN_SEC_KEY_PATH secret not set — refusing to regenerate dev index.json unsigned (would leave a stale signature mismatched against fresh content and break bakery for everyone on the dev track)" + exit 1 + fi + rm -rf /tmp/bread-ecosystem-ci-* 2>/dev/null || true + # mktemp: a fixed clone path races when multiple repos' dev/beta + # workflows run close together on the same self-hosted runner. + ECOSYSTEM_CI_DIR="$(mktemp -d /tmp/bread-ecosystem-ci-XXXXXX)" + git clone --branch main https://git.breadway.dev/Breadway/bread-ecosystem.git "${ECOSYSTEM_CI_DIR}" + TRACK=dev bash "${ECOSYSTEM_CI_DIR}/scripts/gen-index.sh" + rm -rf "${ECOSYSTEM_CI_DIR}" diff --git a/.forgejo/workflows/mirror.yml b/.forgejo/workflows/mirror.yml deleted file mode 100644 index f2a8566..0000000 --- a/.forgejo/workflows/mirror.yml +++ /dev/null @@ -1,19 +0,0 @@ -name: Mirror to GitHub - -on: - push: - branches: ['**'] - tags: ['**'] - -jobs: - mirror: - runs-on: [self-hosted, hestia] - steps: - - name: Mirror to GitHub - run: | - set -euo pipefail - git clone --mirror "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" repo.git - cd repo.git - git push --prune \ - "https://x-access-token:${{ secrets.MIRROR_TOKEN }}@github.com/Breadway/bread.git" \ - '+refs/heads/*:refs/heads/*' '+refs/tags/*:refs/tags/*' diff --git a/.forgejo/workflows/package.yml b/.forgejo/workflows/package.yml deleted file mode 100644 index f48f9d8..0000000 --- a/.forgejo/workflows/package.yml +++ /dev/null @@ -1,40 +0,0 @@ -name: Build and publish package - -on: - push: - tags: ['v*'] - -jobs: - package: - runs-on: [self-hosted, hestia] - container: - image: archlinux:latest - steps: - # Note: no actions/checkout — the archlinux image has no Node, which JS - # actions require. Everything runs as shell steps and clones manually. - - name: Build and publish - env: - PUBLISH_TOKEN: ${{ secrets.REGISTRY_TOKEN }} - run: | - set -euo pipefail - VERSION="${GITHUB_REF_NAME#v}" - pacman -Syu --noconfirm base-devel git rust cargo libgit2 openssl - useradd -m builder - git config --global --add safe.directory '*' - git clone --branch "${GITHUB_REF_NAME}" --depth 1 \ - "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" /home/builder/src - cd /home/builder/src - git archive --format=tar.gz --prefix="bread-${VERSION}/" HEAD \ - > packaging/arch/bread-${VERSION}.tar.gz - SHA=$(sha256sum packaging/arch/bread-${VERSION}.tar.gz | awk '{print $1}') - sed -i "s/^pkgver=.*/pkgver=${VERSION}/" packaging/arch/PKGBUILD - sed -i "s/^sha256sums=.*/sha256sums=('${SHA}')/" packaging/arch/PKGBUILD - chown -R builder:builder /home/builder/src - # --nocheck: packaging builds the artifact; tests belong in a CI job. - su builder -c "cd /home/builder/src/packaging/arch && makepkg -f --noconfirm --nocheck" - PKG=$(find /home/builder/src/packaging/arch -name '*.pkg.tar.zst' | head -1) - curl -fsS -X PUT \ - -H "Authorization: token ${PUBLISH_TOKEN}" \ - -H "Content-Type: application/octet-stream" \ - --data-binary "@${PKG}" \ - "https://git.breadway.dev/api/packages/Breadway/arch/os" diff --git a/.forgejo/workflows/rc-release.yml b/.forgejo/workflows/rc-release.yml new file mode 100644 index 0000000..6adcf3b --- /dev/null +++ b/.forgejo/workflows/rc-release.yml @@ -0,0 +1,64 @@ +name: beta (rc) release + +# Publishes a beta-track build for any `vX.Y.Z-rc.N` prerelease tag +# pushed to `main` — there is no separate `beta` branch; "freezing" is +# just pausing pushes to main while an RC gets tested. See +# bread-ecosystem's docs/release-channels.md for the release-track policy. +on: + push: + tags: ['v*'] + +jobs: + build: + if: ${{ contains(github.ref_name, '-rc.') }} + runs-on: [self-hosted, hestia] + steps: + - name: checkout + run: | + set -euo pipefail + rm -rf src && mkdir src + git clone --branch "${GITHUB_REF_NAME}" --depth 1 \ + "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" src + + - name: build + run: cd src && bash ci/build.sh cargo build --release --locked + + - name: test + run: cd src && bash ci/build.sh cargo test --release --locked --workspace + + - name: prepare artifacts + run: | + set -euo pipefail + VERSION="${GITHUB_REF_NAME#v}" + PKG_DIR="/srv/breadway-dl/beta/bread/${VERSION}" + mkdir -p "${PKG_DIR}" + for bin in breadd bread bread-emit bread-module-host; do + cp "src/target/release/${bin}" "${PKG_DIR}/${bin}-x86_64" + strip "${PKG_DIR}/${bin}-x86_64" + sha256sum "${PKG_DIR}/${bin}-x86_64" | awk '{print $1}' \ + > "${PKG_DIR}/${bin}-x86_64.sha256" + done + cp src/packaging/systemd/breadd.service "${PKG_DIR}/" + cp src/LICENSE "${PKG_DIR}/" + cp src/bakery.toml "${PKG_DIR}/bakery.toml" + ln -sfn "${VERSION}" "/srv/breadway-dl/beta/bread/latest" + + # No GitHub Release upload — beta builds happen on every push while + # the branch is frozen for testing, so dl.breadway.dev/beta/ is the + # only distribution point for this track. + - name: regenerate beta index.json + env: + MINISIGN_SEC_KEY: ${{ secrets.BAKERY_MINISIGN_SEC_KEY_PATH }} + run: | + set -euo pipefail + if [ -z "${MINISIGN_SEC_KEY:-}" ]; then + echo "::error::BAKERY_MINISIGN_SEC_KEY_PATH secret not set — refusing to regenerate beta index.json unsigned (would leave a stale signature mismatched against fresh content and break bakery for everyone on the beta track)" + exit 1 + fi + rm -rf /tmp/bread-ecosystem-ci-* 2>/dev/null || true + # mktemp: a fixed clone path races when multiple repos' dev/beta + # workflows run close together on the same self-hosted runner. + ECOSYSTEM_CI_DIR="$(mktemp -d /tmp/bread-ecosystem-ci-XXXXXX)" + git clone https://git.breadway.dev/Breadway/bread-ecosystem.git "${ECOSYSTEM_CI_DIR}" + TRACK=beta bash "${ECOSYSTEM_CI_DIR}/scripts/gen-index.sh" + rm -rf "${ECOSYSTEM_CI_DIR}" diff --git a/.forgejo/workflows/release.yml b/.forgejo/workflows/release.yml index fd4669c..36ab1ae 100644 --- a/.forgejo/workflows/release.yml +++ b/.forgejo/workflows/release.yml @@ -6,6 +6,7 @@ on: jobs: build: + if: ${{ !contains(github.ref_name, '-rc.') }} runs-on: [self-hosted, hestia] steps: - name: checkout @@ -16,10 +17,10 @@ jobs: "https://git.breadway.dev/${GITHUB_REPOSITORY}.git" src - name: build - run: cd src && cargo build --release --locked + run: cd src && bash ci/build.sh cargo build --release --locked - name: test - run: cd src && cargo test --release --locked --workspace + run: cd src && bash ci/build.sh cargo test --release --locked --workspace - name: prepare artifacts run: | @@ -27,22 +28,33 @@ jobs: VERSION="${GITHUB_REF_NAME#v}" PKG_DIR="/srv/breadway-dl/bread/${VERSION}" mkdir -p "${PKG_DIR}" - for bin in breadd bread; do + for bin in breadd bread bread-emit bread-module-host; do cp "src/target/release/${bin}" "${PKG_DIR}/${bin}-x86_64" strip "${PKG_DIR}/${bin}-x86_64" sha256sum "${PKG_DIR}/${bin}-x86_64" | awk '{print $1}' \ > "${PKG_DIR}/${bin}-x86_64.sha256" done cp src/packaging/systemd/breadd.service "${PKG_DIR}/" + cp src/LICENSE "${PKG_DIR}/" cp src/bakery.toml "${PKG_DIR}/bakery.toml" ln -sfn "${VERSION}" "/srv/breadway-dl/bread/latest" - name: regenerate index.json + env: + MINISIGN_SEC_KEY: ${{ secrets.BAKERY_MINISIGN_SEC_KEY_PATH }} run: | set -euo pipefail - rm -rf /tmp/bread-ecosystem-ci - git clone https://git.breadway.dev/Breadway/bread-ecosystem.git /tmp/bread-ecosystem-ci - bash /tmp/bread-ecosystem-ci/scripts/gen-index.sh + if [ -z "${MINISIGN_SEC_KEY:-}" ]; then + echo "::error::BAKERY_MINISIGN_SEC_KEY_PATH secret not set — refusing to regenerate index.json unsigned (would leave a stale signature mismatched against fresh content and break bakery for everyone)" + exit 1 + fi + rm -rf /tmp/bread-ecosystem-ci-* 2>/dev/null || true + # mktemp: a fixed clone path races when multiple repos' release + # workflows run close together on the same self-hosted runner. + ECOSYSTEM_CI_DIR="$(mktemp -d /tmp/bread-ecosystem-ci-XXXXXX)" + git clone https://git.breadway.dev/Breadway/bread-ecosystem.git "${ECOSYSTEM_CI_DIR}" + bash "${ECOSYSTEM_CI_DIR}/scripts/gen-index.sh" + rm -rf "${ECOSYSTEM_CI_DIR}" - name: upload to GitHub Release env: @@ -56,6 +68,10 @@ jobs: gh release upload "${GITHUB_REF_NAME}" --repo Breadway/bread \ "${PKG_DIR}/breadd-x86_64" \ "${PKG_DIR}/bread-x86_64" \ + "${PKG_DIR}/bread-emit-x86_64" \ + "${PKG_DIR}/bread-module-host-x86_64" \ "${PKG_DIR}/breadd-x86_64.sha256" \ "${PKG_DIR}/bread-x86_64.sha256" \ + "${PKG_DIR}/bread-emit-x86_64.sha256" \ + "${PKG_DIR}/bread-module-host-x86_64.sha256" \ --clobber diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml deleted file mode 100644 index e1efa1d..0000000 --- a/.github/workflows/ci.yml +++ /dev/null @@ -1,44 +0,0 @@ -name: CI - -on: - push: - branches: [ master, main, dev ] - pull_request: - branches: [ master, main, dev ] - -jobs: - build-and-test: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - name: Install Rust - uses: dtolnay/rust-toolchain@v1 - with: - toolchain: stable - components: clippy, rustfmt - - name: Install system dependencies - run: sudo apt-get update && sudo apt-get install -y libudev-dev pkg-config - - name: Cargo cache - uses: Swatinem/rust-cache@v2 - with: - workspaces: | - . -> target - - name: Format check - run: cargo fmt --all --check - - name: Clippy - run: cargo clippy --workspace --all-targets -- -D warnings - - name: Build - run: cargo build --workspace --verbose - - name: Run tests - run: cargo test --workspace --verbose - - name: Build release - run: cargo build --workspace --release - - name: Package artifacts - run: | - mkdir -p dist - tar -czf dist/bread-ubuntu-latest.tgz target/release/breadd target/release/bread - - name: Upload artifacts - uses: actions/upload-artifact@v4 - with: - name: bread-ubuntu-latest - path: dist/*.tgz diff --git a/.gitignore b/.gitignore index acf737f..c244516 100644 --- a/.gitignore +++ b/.gitignore @@ -36,4 +36,3 @@ DAEMON.md LUA_RUNTIME.md CLAUDE_SPEC.md .claude -CLAUDE.md diff --git a/.grok/config.toml b/.grok/config.toml new file mode 100644 index 0000000..381bf4f --- /dev/null +++ b/.grok/config.toml @@ -0,0 +1,12 @@ +# Copied from .claude/settings.local.json +[permission] +allow = [ + "Bash(cargo test *)", + "Bash(/home/breadway/Projects/bread/target/debug/bread health *)", + "Bash(/home/breadway/Projects/bread/target/debug/bread sync *)", + "Bash(python3 *)", + "Bash(/home/breadway/Projects/bread/target/debug/bread modules *)", + "Bash(/home/breadway/Projects/bread/target/debug/bread doctor *)", + "Bash(/home/breadway/Projects/bread/target/debug/bread reload *)", + "Bash(cargo build *)", +] diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..7f5f181 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,42 @@ +# AGENTS.md — Repo hygiene + +This repo follows the branch/release workflow in `CONTRIBUTING.md`. +Read that before any git, branch, or release work. Do not invent a +different workflow. + +Day-to-day: one long-lived branch (`main`). New work goes on +`feature/` or `fix/`, then back into `main`. There is no +`dev` or `beta` branch — those names are **bakery tracks**, published +from `main` (dev) and from tags (`vX.Y.Z-rc.N` = beta, `vX.Y.Z` = stable). + +API surface, event names, and IPC contracts live in `Documentation.md` +(kept honest by `api-schema.toml` + `cargo run -p xtask -- check-docs`). +Treat that file, not this one, as the source of truth. + +## Remotes + +- `origin` — Forgejo (`git.breadway.dev`) — authoritative. +- `github` — mirror. Push tags/releases per `CONTRIBUTING.md`; day-to-day + work pushes to `origin` only. + +## CI + +- `dev-release.yml` — push to `main` (includes `check-docs`). +- `rc-release.yml` — `vX.Y.Z-rc.N` tag. +- `release.yml` — other `v*` tags. + +All three run on the self-hosted hestia runner. Nothing else runs on +plain commits or PRs. Distribution is `bakery`, not a PKGBUILD. + +## Local architecture (still true) + +- `breadd` — daemon (adapters → normalizer → state engine → Lua / IPC). +- `bread` — CLI over `$XDG_RUNTIME_DIR/bread/breadd.sock`. +- `bread-emit` — fire-and-forget IPC emit (hooks + command bus). +- `bread-module-host` — sandboxed out-of-process module runtime. +- Known-app registry and reserved domains: `bread-shared/src/apps.rs`. + +## Don't + +- Don't embed credentials in remote URLs — SSH or a credential helper only. +- Don't commit straight to `main`. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..58d0cb8 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,20 @@ +# CLAUDE.md — Repo hygiene + +This repo follows the branch/release workflow documented in `CONTRIBUTING.md` +— read and follow it for any git, branch, or release work here (the +dev/beta/main lifecycle, `feature/x`/`fix/x` branch naming, when to cut or +reset `beta`, etc). Don't improvise a different workflow. +When starting work on a new feature, create branch "feature/" \ +When working on a bug or issue, create branch "fix/" + +## Remotes +- `origin` — Forgejo (`git.breadway.dev` via Hestia, SSH) — authoritative. +- `github` — GitHub mirror. Push both when publishing. + +## CI +- `dev-release.yml` triggers on `push: branches: ['dev']`; `beta-release.yml` + on `push: branches: ['beta']`; `release.yml` on a `v*` tag push. `package.yml` triggers the same way for the pacman-channel package. + None of these run on plain commits or PRs beyond what's listed. + +## Don't +- Don't embed credentials in remote URLs — SSH or a credential helper only. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..4d7c202 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,108 @@ +# Contributing + +`bread` — Reactive automation daemon (breadd) and CLI for Linux desktops. + +Part of the bread ecosystem; this repo follows the same branch/release +workflow as every other ecosystem product. + +## Branches + +There is one long-lived branch: **`main`**. All day-to-day work lands here. +Every push to `main` automatically builds and publishes a **dev-track** +build (see Tracks below) — a real install you can test before cutting +anything more formal. + +New work — features and bug fixes alike — goes on a short-lived branch: + +``` +feature/ +fix/ +``` + +Branch off `main`, open a PR/push back into `main` when ready. Short-lived +branches get deleted on merge — they never accumulate the kind of drift a +second long-lived branch does. + +## The release cycle + +There's no separate `beta` or release branch — "stable" and "beta" are both +just **tags** on `main`, not branches that need to be kept in sync: + +1. Work accumulates on `main` via `feature/x` / `fix/x` branches. Each push + auto-publishes a dev build — install it with `bakery track set dev` and + `bakery update --all`, then fix anything broken with another push. +2. When you want to stabilize before a real release, tag a release + candidate: `git tag vX.Y.Z-rc.1 && git push origin vX.Y.Z-rc.1` (push to + both remotes). That tag alone triggers a beta-track build — + "freezing" is just pausing pushes to `main` while you test it, not a + branch operation. Cut `-rc.2`, `-rc.3`, etc. for further fixes. +3. Once an RC has gone without issues, tag the real release: + `git tag vX.Y.Z && git push origin vX.Y.Z` — that's what triggers the + signed stable release build. + +## Tracks, from a user's perspective + +``` +bakery track show # what you're currently on (defaults to stable) +bakery track set dev # or beta, or stable +bakery update --all # pull the latest build on your current track +``` + +| Track | What it is | Published from | +|--------|-----------|-----------------| +| `stable` | The last tagged release | a `vX.Y.Z` tag | +| `beta` | Latest release candidate | a `vX.Y.Z-rc.N` tag | +| `dev` | Bleeding edge | `main`, on every push | + +Dev versions are auto-computed (`X.Y.Z-dev.+`) from the +latest published stable tag, so they always sort as newer than what you +have installed — no manual version bumping needed. Beta versions are just +the RC tag itself (already valid semver, already sorts below the real +release it's a candidate for). + +## Local development + +```sh +cargo build --release --workspace +cargo test --release --workspace +``` + +### Keeping the API docs honest + +`Documentation.md`'s Lua API/IPC protocol sections and README's CLI +reference are hand-written and have drifted from the actual code before — +there's a checked-in registry, `api-schema.toml`, plus an `xtask` checker +(`cargo run -p xtask -- check-docs`) that catches it happening again, and +it's enforced in CI (`dev-release.yml` fails the build on any drift). + +Whenever you add, rename, or remove a `bread.*` Lua binding +(`breadd/src/lua/mod.rs`), an IPC method (`breadd/src/ipc/mod.rs`), or a +`bread` CLI command (`bread-cli/src/main.rs`): + +1. Add/update/remove its entry in `api-schema.toml` to match. +2. Add/update the corresponding section — a `#### bread.` heading in + `Documentation.md` for a Lua binding, a row in `Documentation.md`'s IPC + Methods table for an IPC method, or a `bread ` line in `README.md`'s + "CLI reference" section for a CLI command. +3. Run `cargo run -p xtask -- check-docs` before committing. It fails with + a non-zero exit and a list of exactly what's out of sync — added but + undocumented, stale in the schema, or missing a doc line — if + `api-schema.toml`, the code, `Documentation.md`, and `README.md` don't + all agree. CI runs this too, so anything that slips past a local run + still fails the build rather than landing on `main`. + +## CI + +- `dev-release.yml` — triggered on push to `main`. +- `rc-release.yml` — triggered on any `vX.Y.Z-rc.N` tag push. +- `release.yml` — triggered on any other `v*` tag push, cuts the actual + stable release. + +All CI runs on a self-hosted runner; nothing runs automatically on plain +commits or PRs beyond the track builds above. See +[bread-ecosystem's docs/release-channels.md](https://git.breadway.dev/Breadway/bread-ecosystem/src/branch/main/docs/release-channels.md) +for the full policy, including how a new product gets wired onto these tracks. + +## Questions + +Open an issue on this repo's Forgejo tracker. diff --git a/Cargo.lock b/Cargo.lock index 9655ed6..43c999e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -293,7 +293,7 @@ dependencies = [ [[package]] name = "bread-cli" -version = "0.7.0" +version = "0.8.0" dependencies = [ "anyhow", "bread-shared", @@ -311,30 +311,48 @@ dependencies = [ [[package]] name = "bread-emit" -version = "0.7.0" +version = "0.8.0" dependencies = [ "bread-shared", "serde_json", ] +[[package]] +name = "bread-module-host" +version = "0.8.0" +dependencies = [ + "anyhow", + "bread-shared", + "mlua", + "serde", + "serde_json", + "tempfile", + "tokio", + "tracing", + "tracing-subscriber", + "uuid", +] + [[package]] name = "bread-shared" -version = "0.7.0" +version = "0.8.0" dependencies = [ "dirs", "serde", "serde_json", "toml", + "uuid", ] [[package]] name = "breadd" -version = "0.7.0" +version = "0.8.0" dependencies = [ "anyhow", "async-trait", "bread-shared", "futures-util", + "landlock", "libc", "mlua", "netlink-packet-core", @@ -349,6 +367,7 @@ dependencies = [ "tracing", "tracing-subscriber", "udev", + "uuid", "zbus", ] @@ -528,23 +547,23 @@ dependencies = [ [[package]] name = "dirs" -version = "5.0.1" +version = "6.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225" +checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" dependencies = [ "dirs-sys", ] [[package]] name = "dirs-sys" -version = "0.4.1" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" dependencies = [ "libc", "option-ext", "redox_users", - "windows-sys 0.48.0", + "windows-sys 0.61.2", ] [[package]] @@ -980,6 +999,17 @@ dependencies = [ "libc", ] +[[package]] +name = "landlock" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cca98e95f35b29d469dade6724c6f96cec9236640f745a0e99b0334ec320ab1" +dependencies = [ + "enumflags2", + "libc", + "thiserror 2.0.19", +] + [[package]] name = "lazy_static" version = "1.5.0" @@ -1193,7 +1223,7 @@ dependencies = [ "anyhow", "byteorder", "paste", - "thiserror", + "thiserror 1.0.69", ] [[package]] @@ -1494,13 +1524,13 @@ dependencies = [ [[package]] name = "redox_users" -version = "0.4.6" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" dependencies = [ "getrandom 0.2.17", "libredox", - "thiserror", + "thiserror 2.0.19", ] [[package]] @@ -1543,7 +1573,7 @@ dependencies = [ "netlink-packet-route", "netlink-proto", "nix 0.22.3", - "thiserror", + "thiserror 1.0.69", "tokio", ] @@ -1789,6 +1819,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "tempfile" version = "3.27.0" @@ -1808,7 +1849,16 @@ version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" dependencies = [ - "thiserror-impl", + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9" +dependencies = [ + "thiserror-impl 2.0.19", ] [[package]] @@ -1822,6 +1872,17 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "thiserror-impl" +version = "2.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43cbfe0cf76104d42a574802844187e84a305e531ed54455f11fbde0f10541cd" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.3", +] + [[package]] name = "thread_local" version = "1.1.10" @@ -2020,6 +2081,17 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" +[[package]] +name = "uuid" +version = "1.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf3923a6f5c4c6382e0b653c4117f48d631ea17f38ed86e2a828e6f7412f5239" +dependencies = [ + "getrandom 0.4.3", + "js-sys", + "wasm-bindgen", +] + [[package]] name = "valuable" version = "0.1.1" @@ -2383,6 +2455,15 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "xtask" +version = "0.1.0" +dependencies = [ + "anyhow", + "serde", + "toml", +] + [[package]] name = "zbus" version = "3.15.2" diff --git a/Cargo.toml b/Cargo.toml index 1190489..ed704e8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,8 @@ members = [ "breadd", "bread-cli", "bread-emit", + "bread-module-host", + "xtask", ] resolver = "2" @@ -14,6 +16,17 @@ tokio = { version = "1.40", features = ["full"] } anyhow = "1.0" tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } -dirs = "5.0" +dirs = "6.0" chrono = { version = "0.4", features = ["serde"] } tempfile = "3" +# Pure-Rust bindings to the Linux Landlock LSM syscalls (landlock_create_ruleset/ +# landlock_restrict_self) — kernel 5.13+, no external bwrap/firejail binary +# dependency. See Workstream G (bread-module-host / breadd's module_host +# spawner) — the actual OS-level sandboxing mechanism for out-of-process +# module execution. Verified against this repo's dev kernel (6.18) with a +# real pre_exec()-restricted child process before adoption: filesystem reads +# outside the granted rule set are denied at the kernel level +# (RulesetStatus::FullyEnforced / PartiallyEnforced, EACCES on the denied +# path), not merely a Lua-level check. +landlock = "0.4" +uuid = { version = "1", features = ["v4"] } diff --git a/DEPRECATIONS.md b/DEPRECATIONS.md new file mode 100644 index 0000000..bea97d9 --- /dev/null +++ b/DEPRECATIONS.md @@ -0,0 +1,42 @@ +# Deprecations + +Tracks API surface currently in its deprecation window per +[`Documentation.md`'s API Stability & Versioning](Documentation.md#api-stability--versioning) +policy — marked `Deprecated` and still functioning, pending removal in a +future major version. + +## Hyprland legacy flat event names (since v1.5) + +**What's deprecated:** the 10 pre-namespace Hyprland event names emitted by +`normalize_hyprland()` in `breadd/src/core/normalizer.rs`: + +- `bread.workspace.changed`, `bread.workspace.created`, `bread.workspace.destroyed` +- `bread.monitor.connected`, `bread.monitor.disconnected` +- `bread.window.focus.changed`, `bread.window.focused`, `bread.window.opened`, + `bread.window.closed`, `bread.window.moved` + +**Recommended form going forward:** their `bread.hyprland.` equivalents +(e.g. `bread.hyprland.workspace.changed`), which make explicit that these +events are Hyprland-specific rather than portable across a future second +compositor backend — see `Documentation.md`'s +[Hyprland event reference](Documentation.md#hyprland) for the full mapping. + +**Current behavior:** both names fire by default (`[compat] +legacy_hyprland_event_names = true`). Setting that flag to `false` suppresses +the legacy names; only `bread.hyprland.*` fires. The state engine applies +*both* names (since v1.7.1), so disabling the legacy emit no longer freezes +`bread.state` monitors / active workspace / active window. + +**Deferred follow-up (not yet scheduled):** + +1. Flip `[compat] legacy_hyprland_event_names`'s *default* to `false` in a + later minor release, once downstream modules have had a full deprecation + window to migrate. +2. Remove the legacy flat names and the `[compat]` flag entirely in the next + major version (v2) — at that point `normalize_hyprland()` only ever + produces `bread.hyprland.*` names and the dual-emit machinery + (`emit_hyprland_dual` in `normalizer.rs`) can be deleted. + +Neither step is scheduled yet; this file exists so the removal isn't +forgotten once the window closes. No issue tracker is wired up to this repo, +so this note is the tracking mechanism until one exists. diff --git a/Documentation.md b/Documentation.md index 36fa768..33053dc 100644 --- a/Documentation.md +++ b/Documentation.md @@ -8,9 +8,12 @@ - [Your first module](#your-first-module) - [Run, reload, and watch](#run-reload-and-watch) - [Modules: install and manage](#modules-install-and-manage) +- [Capability-scoped modules](#capability-scoped-modules-since-v15) +- [Out-of-process module sandboxing](#out-of-process-module-sandboxing-since-v16) - [Debugging tips](#debugging-tips) - [Dictionary: Lua API](#dictionary-lua-api) - [Workflows](#workflows-since-v12) + - [Widgets](#widgets-since-v13) - [Bluetooth](#bluetooth) - [Dictionary: Built-in modules](#dictionary-built-in-modules) - [Dictionary: Event reference](#dictionary-event-reference) @@ -40,17 +43,63 @@ The Lua API surface, the IPC method set, the event-name vocabulary, and the runt - **Since markers.** Additions made after the v1.0 baseline are marked inline with `*Since: vX.Y*`. Anything documented in this file without a marker is part of the v1.0 baseline. - **Version discovery.** The current API version is returned as `api_version` in the `health` IPC response (see [Dictionary: IPC protocol](#dictionary-ipc-protocol)), so a client — the CLI, a Lua module, or a sibling `bread*` app — can assert compatibility at connect time rather than discovering a mismatch mid-session. -This matters because the moment sibling apps and community modules depend on this vocabulary, it becomes a contract that can break people. Treat this file, not `README.md` or `CLAUDE.md`, as the single source of truth — those files intentionally point back here rather than keeping their own copies, after a duplicated Lua API section in `README.md` was found to have already drifted from reality. +This matters because the moment sibling apps and community modules depend on this vocabulary, it becomes a contract that can break people. Treat this file, not `README.md` or `AGENTS.md`, as the single source of truth — those files intentionally point back here rather than keeping their own copies, after a duplicated Lua API section in `README.md` was found to have already drifted from reality. ## Getting started ### 1) Create a minimal config - Daemon config: `~/.config/bread/breadd.toml` (all values optional) +- Declarative rules (optional, no Lua required): `~/.config/bread/rules.toml` - Lua entry point: `~/.config/bread/init.lua` - Lua modules: `~/.config/bread/modules/` -### 2) Minimal `init.lua` +### 2) The fast path: `rules.toml` *(Since: v1.5)* + +For the common "when event X happens, do Y" case, you don't need Lua at +all. Create `~/.config/bread/rules.toml`: + +```toml +[[rule]] +on = "device.dock.connected" +run = "~/.config/bread/scripts/dock-connected.sh" + +[[rule]] +on = "power.ac.disconnected" +notify = "Unplugged" + +[[rule]] +on = "device.keyboard.connected" +exec = "xset r rate 200 40" +``` + +Each `[[rule]]` needs exactly two things: an `on` (an event-name suffix — +`bread.` is implied, so `"device.dock.connected"` matches the real event +`bread.device.dock.connected`; wildcards `*`/`**`/`?` work the same way they +do in `bread.on()`) and exactly one action: + +| Action | Meaning | +|--------|---------| +| `run = ""` | Run exactly one script/program at that path. The path is tilde-expanded and quoted as a single unit for you, so spaces in it are safe — it will *not* be word-split into a command plus arguments. | +| `exec = ""` | Run a full shell command line via `bread.exec()`, exactly as if you'd typed it in a shell — quote/escape arguments yourself. | +| `notify = ""` | Show a desktop notification with this text via `bread.notify()`. | + +`rules.toml` is entirely optional and purely additive alongside +`init.lua` — both can coexist, rules load before user-defined modules, and +an absent file is not an error. A malformed rule (missing/empty `on`, or +zero/multiple action keys set) doesn't stop the rest of the file from +working: the other rules in the file still register, and the specific bad +rule shows up via `bread doctor` (see [Debugging tips](#debugging-tips)) +the same way a broken Lua module's error would. + +This covers the common cases directly. For fuzzier matching (substring +device-name matching, filtering by a list of monitors, etc.) or any logic +beyond "run this one action," reach for `bread.devices` / +`bread.monitors` or hand-written Lua in `init.lua` — see +[Dictionary: Built-in modules](#dictionary-built-in-modules) and the next +section. + +### 3) Minimal `init.lua` ```lua bread.on("bread.system.startup", function(event) @@ -59,7 +108,7 @@ bread.on("bread.system.startup", function(event) end) ``` -### 3) Start the daemon +### 4) Start the daemon ```bash systemctl --user start breadd @@ -68,7 +117,7 @@ systemctl --user start breadd breadd ``` -### 4) Check that it's running +### 5) Check that it's running ```bash bread ping @@ -99,6 +148,12 @@ Key rules: - Register subscriptions inside `M.on_load` so they are cleaned up properly on hot reload. - Use `bread.log` early to verify handlers are firing. +A flat file like `modules/hello.lua` with no manifest gets full, unscoped +`bread.*` access — exactly what you see above, unchanged. That's fine for a +personal one-off. Once you install a module properly (`bread modules +install`), it's worth declaring what it actually uses — see +[Capability-scoped modules](#capability-scoped-modules-since-v15). + ## Run, reload, and watch ```bash @@ -129,9 +184,13 @@ bread modules install ~/src/bread-wifi # List installed modules and their daemon status bread modules list -# Show full manifest for one module +# Show full manifest for one module (including its declared permissions) bread modules info bread-wifi +# Get a suggested [[permissions]] block from a static scan of the module's +# Lua source — see "Capability-scoped modules" below +bread modules audit bread-wifi + # Remove a module bread modules remove bread-wifi bread modules remove bread-wifi --yes # skip confirmation @@ -146,13 +205,444 @@ description = "WiFi management for Bread" author = "someuser" source = "/home/you/src/bread-wifi" installed_at = "2026-01-01T00:00:00Z" + +[[permissions]] +type = "exec" +bin = "nmcli" + +[[permissions]] +type = "notify" ``` +`permissions` is optional *(Since: v1.5)*. Omitting it entirely — every +manifest written before v1.5, and any manifest an author just hasn't gotten +around to annotating — means the module runs exactly like it always has: +full, unscoped `bread.*` access. See the next section for what declaring it +actually buys you and the full permission taxonomy. + +## Capability-scoped modules *(Since: v1.5)* + +By default every third-party module gets the full `bread` table — the same +one built-in modules and `init.lua` see. `[[permissions]]` in +`bread.module.toml` narrows that: a module only sees the `bread.*` bindings +it was granted, plus a fixed **baseline** every module gets regardless. +Anything not granted is genuinely **absent** — `bread.fs == nil`, not +`bread.fs.read()` throwing a permission error — so a module written +defensively (`if bread.fs then ... end`) degrades exactly the way it would +if, say, Bluetooth hardware weren't present. + +*Since: v1.6* — declaring `[[permissions]]` at all (even an empty list) +also determines **where** the module runs: see [Out-of-process module +sandboxing](#out-of-process-module-sandboxing-since-v16) below. The +`bread` table shape described in this section is what such a module sees +either way; what changed is what backs it and what happens if the module +ignores it entirely and reaches for `os`/`io` directly. + +### Baseline (always available, no manifest entry needed) + +Event subscription and timers are how a module does anything at all, so +they're never gated: `bread.on`/`once`/`filter`/`off`/`emit`, +`bread.after`/`every`/`cancel`. Also baseline: `bread.json` (pure decode, +no I/O), `bread.module` (required just to register), `bread.log`/`warn`/ +`error` (diagnostics), and the pure-Lua sugar built entirely on top of the +above — `bread.debounce`, `bread.spawn`/`wait`/`wait_any`/`wait_all`, +`bread.workflow.*`. + +### Gated — requires a matching `[[permissions]]` entry + +| `type` | Grants | Notes | +|--------|--------|-------| +| `state.read` | `bread.state.get`/`.monitors`/`.active_workspace`/`.active_window`/`.devices`/`.power`/`.network`/`.profile` | Read-only snapshots of daemon state. `path` is an advisory scoping hint (e.g. `"monitors"`), not yet enforced per-call — see the note below. | +| `state.watch` | `bread.state.watch` | Split from `state.read`: a standing subscription is a more persistent capability than a one-off read. | +| `profile.activate` | `bread.profile.activate` | Switches the daemon's system-wide active profile — a real cross-module side effect. | +| `exec` | `bread.exec`, `bread.exec_capture` | Spawns an arbitrary shell command. `bin` is an advisory hint (e.g. `"hyprpaper"`). | +| `notify` | `bread.notify` | Desktop notifications. | +| `machine` | `bread.machine.name`/`.tags`/`.has_tag` | Reads hostname/tags, including an optional on-disk `sync.toml`. | +| `hyprland` | `bread.hyprland.*` | Compositor IPC — `dispatch`/`keyword`/`eval` control the session, `monitors`/`workspaces`/`clients`/`active_window`/`on_raw` observe it. Not split further; grant it for either. | +| `widget` | `bread.widget.register`/`.update`/`.remove`/`.list` | Registers UI in a sibling `bread*` app (breadbar). | +| `fs.read` | `bread.fs.read`/`.exists`/`.readlink`/`.expand` | Read-only filesystem access. `path` is an advisory scoping hint. | +| `fs.write` | `bread.fs.write` | Filesystem writes. Split from `fs.read` — a module that only reads shouldn't need to declare write access. | +| `bluetooth` | `bread.bluetooth.*` | BlueZ control — power/connect/disconnect/scan/devices. | + +Example — a module that switches wallpaper via `hyprpaper` based on the +current monitor layout, and reads images from one directory: + +```toml +[[permissions]] +type = "exec" +bin = "hyprpaper" + +[[permissions]] +type = "state.read" +path = "monitors" + +[[permissions]] +type = "fs.read" +path = "~/Wallpapers" +``` + +That module's `bread` table has `bread.exec`, `bread.state` (read +functions only — no `bread.state.watch`), and `bread.fs` (read functions +only — no `bread.fs.write`), plus the full baseline. `bread.hyprland`, +`bread.bluetooth`, `bread.notify`, `bread.machine`, and `bread.widget` are +all `nil`. + +An explicit empty list (`permissions = []`) is a deliberate "baseline only" +declaration — different from omitting the key entirely. It scopes the +module down for real but is *not* flagged by `bread doctor`, since the +author made a conscious choice rather than just not knowing about this +feature yet. + +### `path`/`bin` enforcement depends on where the module runs + +This section describes the **in-process** scoping mechanism +(`build_scoped_env` in `breadd/src/lua/mod.rs`), which only ever gated +*presence* of a `bread.*` binding — the `path`/`bin` fields on each +permission were recorded in the manifest but never checked against the +actual arguments a module passed at runtime, and `os.execute`/`io.open`/ +`debug.*` remained fully reachable from Lua's standard library regardless +of what a module's `bread` table contained. That's still exactly true for +a module with **no manifest at all** (the legacy/backward-compat path, +`ungated: true` in `modules.list`) — see [Out-of-process module +sandboxing](#out-of-process-module-sandboxing-since-v16) below. + +*Since: v1.6* — a module that declares `[[permissions]]` (any, including +an explicit empty list) no longer runs in-process at all. It's spawned as +a separate, OS-sandboxed `bread-module-host` process instead, and for that +process `path`/`bin` *are* enforced for real, at the kernel level, via a +Landlock ruleset — independent of whether the module even uses the +documented `bread.*` API or goes straight for `os.execute`/`io.open`. See +the linked section for exactly what's covered and what's still deferred. + +### `require("bread.devices")` still works from a scoped module + +Builtin library modules (`bread.devices`, `bread.monitors`, `bread.workspaces`, +`bread.binds`) always load with the full ambient `bread` table — they're +never subject to manifest-based scoping, regardless of what any third-party +module that `require`s them declares. `require("bread.devices")` resolves +via Lua's real `package.loaded` table (already populated by the time any +third-party module loads, since builtins load first) — a real global, +reachable from a scoped module through a metatable fallback to the true +globals for everything that isn't `bread` itself (`pairs`, `string`, +`table`, `require`, `package`, ...). The returned module's own functions +(`devices.on()` etc.) were defined while `bread.devices` loaded unscoped, +so they close over the *real* `bread` table as a Lua upvalue — closures +capture their defining environment lexically, not the caller's — which is +exactly why calling `devices.on(...)` from inside a scoped module works +with no special-casing needed. + +### `bread modules audit ` + +Best-effort static scan of an installed module's `.lua` files (its entry +file plus any others in the same directory) for `bread.*` call-site +patterns, printing a suggested `[[permissions]]` block to review and paste +into `bread.module.toml`: + +```bash +bread modules audit bread-wifi +``` + +This is a text scan, not a Lua parser — false positives (suggesting a +permission the module doesn't strictly need) are expected and fine; false +negatives on a plain `bread.exec("...")`-style call site should be rare, +but dynamic/computed call sites (`bread[method_name](...)`) won't be +detected. + +## Out-of-process module sandboxing *(Since: v1.6)* + +### The gap this closes + +Capability-scoped modules (above) gate the *documented* `bread.*` API +surface — a module without `fs.read` sees `bread.fs == nil`. They never +gated Lua's own standard library: `os.execute`, `io.open`, `debug.*` +remained fully reachable from a scoped module's chunk regardless of what +its `bread` table contained, because that chunk still ran as ordinary Lua +code inside `breadd`'s own OS process, sharing its real filesystem/exec +access at the kernel level. A well-behaved module degrades correctly when +a permission is missing; a deliberately adversarial one just calls +`os.execute("cat /etc/shadow")` directly and the in-process mechanism has +nothing left to say about it. + +This workstream closes that gap for any module that declares +`[[permissions]]` in `bread.module.toml` — including an explicit empty +list — by running it in a **separate OS process**, sandboxed at the kernel +level via [Landlock](https://docs.kernel.org/userspace-api/landlock.html), +instead of inside `breadd`'s own process. + +### What still runs in-process + +A module with **no manifest at all** (no `bread.module.toml`, or one with +no `permissions` key) keeps today's pre-v1.6 behavior unchanged: loaded +in-process, full ungated `bread` table, `os`/`io`/`debug` reachable — +surfaced as `"ungated": true` in `modules.list`/`state.get "modules"`, +which is exactly what `bread doctor` reads to warn about it. This is a +deliberate scope decision, not an oversight: Landlock needs concrete rules +to build a ruleset from, and "no manifest at all" carries no information +to build one. A module author who wants real OS-level isolation writes a +manifest — that's the whole point of the capability system this reuses. +Built-in modules (`bread.devices`/`monitors`/`workspaces`/`binds`) are +completely unaffected either way; they never go through manifest-based +scoping. + +### Architecture + +``` +breadd (trusted) bread-module-host (sandboxed, per module) + │ │ + ├─ spawns child, applies a Landlock ──► │ (restriction applied by the + │ ruleset via Command::pre_exec │ PARENT before the child's + │ BEFORE execve() │ own main() ever runs) + │ │ + ├─ hands it a one-time token via │ + │ $BREAD_MODULE_TOKEN (env, not argv) │ + │ │ + │◄── connects to breadd's existing ──────┤ + │ IPC socket, presents the token │ + │ via module_host.hello │ + │ │ + ├─ looks up which module/permissions ──► │ learns its own identity + + │ the token was issued for, replies │ granted permissions from + │ │ breadd's answer (never + │ │ trusted from self-assertion) + │ │ + │◄── module_host.on/off/emit/after/ ─────┤ loads init.lua into a fresh + │ every/cancel/fs_read/fs_write/ │ Lua VM; bread.* functions + │ exec/exec_capture/state_get/status │ are RPC-backed proxies, not + │ (RPC bridge, belt) │ direct bindings + │ │ + │ Landlock ruleset (suspenders, │ os.execute/io.open/debug.* + │ enforced by the kernel independent │ still exist in this Lua VM + │ of whether the RPC bridge is used) ──►│ but are bounded by the + │ kernel regardless +``` + +One `bread-module-host` process per out-of-process module. Its own +dependency footprint is deliberately minimal (`mlua`, `tokio`, +`serde_json`, `bread-shared`) — it's reviewable attack surface in its own +right, running one module's untrusted Lua. + +### The token/identity handshake + +Workstream A deliberately did not build a generic IPC connection-identity +system — it closed a narrower spoofing gap instead — so there was no +`module:` identity concept to reuse. `breadd` generates a random +one-time token (a v4 UUID) when spawning a module-host child and passes it +via the `$BREAD_MODULE_TOKEN` **environment variable**, not argv — argv is +visible to any process on the system via `/proc//cmdline`, env vars +are not without `/proc//environ` and matching privileges. The child's +first message on the IPC socket, `module_host.hello {token}`, presents +that token; `breadd` looks up which module name/permission set the token +was issued for (`ModuleHostRegistry::take_pending`, a one-time, +consume-on-read lookup) and replies with that identity. The child never +asserts its own name and has that trusted — an adversarial process holding +a *stolen or guessed* token still can't claim to be a different module +than the one `breadd` actually spawned that token for, and a token is +consumed on first use so it can't be replayed. + +Other env vars passed to the child: `$BREAD_MODULE_ENTRY` (absolute path +to the module's `init.lua`) and `$BREAD_MODULE_SOCKET` (breadd's socket +path, for test harnesses that override it — production defaults to the +same `bread_shared::resolve_socket_path()` every other client uses). +`$BREAD_MODULE_NAME` is also passed, but purely informational (early log +lines before the hello handshake completes) — never trusted for identity +or permission lookup. + +### The Landlock sandbox + +[Landlock](https://docs.kernel.org/userspace-api/landlock.html) (Linux +5.13+) was chosen over wrapping every spawn in `bubblewrap`/`firejail`: +it's a pure-Rust crate calling the LSM's syscalls directly +(`landlock_create_ruleset`/`landlock_restrict_self`), unprivileged (no +setuid helper, no `CAP_SYS_ADMIN`), and fits this workspace's existing +preference for native Rust crates over shelling out to external tools +(same reasoning as `udev`/`zbus`/`rtnetlink` instead of CLI wrappers). +`bubblewrap`-wrapping remains a documented fallback for a target kernel +that lacks Landlock (pre-5.13, or compiled out) — not implemented, since +Landlock covers this project's actual target. + +The ruleset is built in `breadd` (the parent) and applied via +`Command::pre_exec` — the closure runs in the forked child, after +`fork()` but before `execve()`, so the restriction covers the module-host +binary's own startup, not just the Lua that runs after. Because of that, +`bread-module-host` itself needs **zero** Landlock-related code or +dependency — by the time its `main()` runs, the restriction is already +active and inherited across the `execve()` that started it. + +What the ruleset grants, from `breadd/src/module_host.rs`'s +`apply_sandbox`: + +| Grant | Access | Why | +|-------|--------|-----| +| System library directories (`/usr/lib`, `/lib`, ...) + `/etc/ld.so.cache`/`.preload` | Read + **Execute** | The dynamic linker needs this to start *any* dynamically-linked binary at all — see the note below on why `Execute` is required here, not just `Read`. | +| The `bread-module-host` binary's own resolved path | Read + Execute | The one `execve()` this process is expected to have already performed. | +| The module's own directory (`init.lua`'s parent) | Read | So the bootstrap process can load the module's Lua at all — distinct from any `fs.read` grant, which governs the module's *own* runtime file I/O, not breadd's ability to hand it its own source. | +| `fs.read` with a `path` hint | Read, scoped to that (`~`-expanded) path prefix | Direct mapping from the manifest. | +| `fs.write` with a `path` hint | Read + Write + create, scoped to that path prefix | Matches `bread.fs.write`'s own `create_dir_all` + `write` behavior. | +| `exec` with a `bin` hint | Read + Execute, scoped to that binary's resolved path | Absolute paths used as-is; bare names resolved via a `$PATH` search, `which`-style. | + +**No `fs.read`/`fs.write`/`exec` granted at all means no corresponding +Landlock rule exists, full stop** — the sandboxed process cannot read, +write, or execute anything outside the fixed baseline above, regardless +of what it tries via `os`/`io` directly. + +**A note on `Execute` and shared libraries**: an earlier version of this +mechanism assumed Landlock's `Execute` right only gates `execve()`, and +that plain `Read` would be enough for the dynamic linker's `mmap(..., +PROT_EXEC, ...)` of `.so` files. That assumption was wrong — verified +empirically (not just reasoned about) by spawning a real sandboxed child: +with library directories restricted to `Read`-only, even `/bin/sh -c +"true"` failed to start at all (`EACCES` on `execve` before a single line +of script ran); granting `Execute` on those directories too fixed it. The +practical consequence: a module-host child's direct `os.execute`/`io.open` +escape hatch, if it names a path under a system library directory +specifically, is not denied the way an arbitrary path elsewhere is — the +baseline necessarily grants real `Execute` there. This is a materially +smaller exposure than no sandbox at all (bounded to files already shipped +in the system's own library directories, not the whole filesystem), but +it's a real, known trade-off, not swept under the rug. See +`breadd/src/module_host.rs`'s `apply_sandbox` doc comment for the full +reasoning, including why a fully static (`x86_64-unknown-linux-musl`) +build of `bread-module-host` — confirmed available on this project's dev +machine — would remove the need for this baseline entirely, and why that +wasn't attempted in this pass (a build/packaging change, not a sandbox +logic change). + +**fs.read/fs.write with no `path` hint**: the RPC bridge's own +belt-and-suspenders permission check still applies, but no Landlock rule +is added — Landlock scoping needs a concrete path, and a hint-less grant +carries none. A module author who wants the direct `os`/`io` escape hatch +mediated at the kernel level too needs to declare a `path`. + +**Network access is explicitly out of scope for this pass** (P2). Landlock +gained TCP bind/connect mediation in ABI v4+ (kernel 6.7+), but wiring a +`network` permission kind through the manifest schema and the sandbox +builder wasn't attempted here. + +### RPC bridge coverage + +`bread-module-host`'s `bread` table is built entirely from RPC-backed +proxies to `breadd` (`breadd/src/ipc/module_host_bridge.rs`), not direct +in-process bindings. Covered: + +- **Baseline**, always present: `bread.on`/`.once`/`.off`/`.emit`, + `bread.after`/`.every`/`.cancel`, `bread.json.decode`, `bread.module` + (with a process-local `.store` — see the note below), `bread.log`/ + `.warn`/`.error`. Also `bread.spawn`/`bread.wait` — the same pure-Lua + coroutine sugar `breadd`'s own `install_wait_helper` uses, since it's + built entirely on top of `on`/`once`/`after`/`cancel`, all of which are + bridged; the source is currently duplicated between `breadd` and + `bread-module-host` rather than extracted to `bread-shared` (flagged as + follow-up below). +- **Gated**, mirroring the permission table above: `bread.fs.read`/ + `.write` (`fs.read`/`fs.write`), `bread.exec`/`.exec_capture` (`exec`), + `bread.state.get` (`state.read`). + +Events/timers are delivered as unsolicited, tagged push messages +interleaved with ordinary request/response lines on the same connection +(`bread_shared::module_host_ipc::ModuleHostPush`) — a subscription +registered via `module_host.on`/`.once` is matched server-side against the +same event broadcast every other IPC subscriber reads from. + +**Not yet bridged** (P1/P2 — see below): `bread.state.monitors`/ +`.active_workspace`/`.active_window`/`.devices`/`.power`/`.network`/ +`.profile` shorthands, `bread.state.watch`, `bread.fs.exists`/`.readlink`/ +`.expand`, `bread.profile.activate`, `bread.notify`, `bread.machine.*`, +`bread.hyprland.*`, `bread.widget.*`, `bread.bluetooth.*`, +`bread.wait_any`/`.wait_all`/`bread.workflow.*`. These namespaces are +simply absent (`nil`) from an out-of-process module's `bread` table +regardless of what the manifest grants — a real coverage gap versus the +in-process mechanism, not a permission-check bug. + +**`bread.module().store` is process-local**, not synced back to `breadd`'s +`RuntimeState` — a real, known limitation versus the in-process mechanism +(where `M.store.set`/`.get` persists in daemon state and is visible to +`bread modules info`/other tooling). Fine for a module's own private +scratch state; not fine yet for anything expecting cross-process +visibility. Modules that need to report results/state externally should +use `bread.emit(...)` instead, which does cross the process boundary. + +### Crash isolation + +Each spawned `bread-module-host` child is reaped by a dedicated thread in +`breadd` (`std::process::Child::wait()`, blocking on that thread only — +never blocking the IPC server or the Lua engine). On exit for any reason — +clean shutdown, a Lua panic, `kill -9` — `breadd` emits +`bread.module.crashed` with `{ module, pid, reason, exit_code, signal }` +and updates that module's status. Verified end-to-end +(`breadd/tests/module_host_sandbox.rs`): killing a module-host child with +`SIGKILL` leaves `breadd` itself and every other module (in-process or +out-of-process) fully responsive, and the crash event fires with the +correct module name and `signal: 9`. + +This is deliberately **detection and reporting**, not a restart/backoff +policy — a crashed module-host stays down until the next `bread reload` +(or daemon restart) respawns it. Richer supervision (auto-restart, +backoff, a circuit breaker) is flagged as follow-up work, not attempted +here. + +### New IPC methods + +*Since: v1.6 — `API_VERSION` bumped from `1.5.0` to `1.6.0` in +`breadd/src/ipc/mod.rs` for this addition.* All new methods live under the +`module_host.*` prefix and are only meaningful on a connection that has +completed the `module_host.hello` handshake (see the token/identity +section above) — see [Dictionary: IPC protocol](#dictionary-ipc-protocol) +for the full list alongside the pre-existing methods. + +### What's implemented vs. deferred + +**Landed (P0)**: +- The `bread-module-host` binary, spawn + token-based identity handshake. +- Real Landlock sandboxing built from a module's `ModulePermission` list, + independently verified at the OS level (`breadd/src/module_host.rs`'s + `landlock_denies_reads_outside_granted_path`/ + `no_exec_permission_means_binary_cannot_be_executed_at_all` unit tests + against a real spawned child; `breadd/tests/module_host_sandbox.rs`'s + `os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope` + end-to-end, going through a real IPC handshake and real Lua calling + `os.execute`/`io.open` directly). +- RPC bridge for the baseline set plus `fs.read`/`fs.write`/`exec`/ + `exec_capture`/`state.read` (`state.get` only). +- Crash isolation: kill-9 of a module-host child doesn't take `breadd` or + any other module down, and is reported via `bread.module.crashed` + (`breadd/tests/module_host_sandbox.rs`'s + `killing_a_module_host_child_does_not_take_down_breadd_or_other_modules`). + +**Landed beyond the minimum (still P0-adjacent)**: +- `bread.spawn`/`bread.wait` (pure-Lua coroutine sugar) work out-of-process + too, since they're built entirely on already-bridged primitives. +- `bread.state.get` (not originally required for the P0 minimum, added + because a pre-existing capability-manifest test exercised it). + +**Deferred (P1 — do next if this workstream continues)**: +- `trust = "in-process"` manifest escape hatch for latency-sensitive + modules that want to opt back into today's D-mechanism deliberately. +- Extracting `bread.spawn`/`bread.wait`'s embedded Lua source (currently + duplicated between `breadd` and `bread-module-host`) into a shared + `bread-shared` module so the two copies can't drift. +- The remaining `bread.*` namespaces over RPC: `bread.state.watch` and the + `.monitors`/`.active_workspace`/etc. shorthands, `bread.fs.exists`/ + `.readlink`/`.expand`, `bread.profile.activate`, `bread.notify`, + `bread.machine.*`, `bread.hyprland.*`, `bread.widget.*`, + `bread.bluetooth.*`, `bread.wait_any`/`.wait_all`/`bread.workflow.*` — + mechanically the same pattern as the ones already bridged. + +**Deferred (P2 — explicitly out of scope for this pass)**: +- Network sandboxing / a `network` permission kind. +- `bread modules info` showing the resolved sandbox profile. +- Full restart/backoff supervision policy for crashed module-hosts. +- A fully static (musl) build of `bread-module-host`, which would remove + the library-directory `Execute` baseline grant entirely. +- 100% RPC coverage of every remaining namespace. + ## Debugging tips - Run `bread events` to see live normalized events. +- Run `bread events --tree` *(Since: v1.5)* to render events as a causality tree instead of a flat stream — events that a Lua handler emitted via `bread.emit()` in reaction to another event are nested underneath it, following the `caused_by` chain (see [Dictionary: Event reference](#dictionary-event-reference)). Useful for untangling "why did this event fire" when several modules chain-react to each other. - Run `bread state` to see full runtime state as JSON. -- Run `bread doctor` to check adapter and module health. +- Run `bread doctor` to check adapter and module health, including modules + running with full, ungated `bread.*` access because they have no + `permissions` declared. - Log event payloads with `bread.log(tostring(event.data))`. - Use `RUST_LOG=debug breadd` for verbose daemon output. @@ -212,7 +702,7 @@ end, { Unsubscribe an event handler or state watch by ID. #### `bread.emit(event, data)` -Emit a custom event into the system pipeline. Useful for cross-module communication. +Emit a custom event into the system pipeline. Useful for cross-module communication. If called synchronously from inside a `bread.on` subscriber callback (i.e. in reaction to a matched event), the emitted event's `caused_by` *(Since: v1.5)* is set to the id of the event that triggered the callback, threading causality across chains of modules that react to each other — see [Dictionary: Event reference](#dictionary-event-reference). #### `bread.wait(pattern, opts) -> event | nil` Coroutine-only helper that suspends until a matching event arrives. @@ -286,6 +776,105 @@ Returns the current status for `name`, or `nil` if no workflow with that name ha #### `bread.workflow.list() -> table` Returns an array of every workflow's current status, in the same shape as `bread.workflow.status`. +### Widgets *(Since: v1.3)* + +Declarative, live-updating widgets rendered by sibling `bread*` apps (breadbar) in their own bar/popover free space. A widget is a small tree of typed nodes — `box`, `label`, `icon`, `progress` — not raw markup: this keeps rendering generic across every consuming app and keeps a node's appearance confined to a bounded, typed `style` vocabulary the renderer already knows about (see `style` below), with no style/CSS injection surface from Lua. + +Widgets are registered per-module and are re-registered fresh on every hot reload (the whole registry is cleared right before the Lua VM resets, same as `bread.module`'s per-reload re-execution) — call `bread.widget.register` at module top level or in `on_load`, not somewhere that only runs once ever. + +#### `bread.widget.register(spec) -> ok, err` +Registers (or replaces, if `spec.id` already exists for this module) a widget. `spec`: + +| Key | Type | Description | +|-----|------|-------------| +| `id` | string | Local id, unique within your module. Stored/addressed elsewhere as `"."`. | +| `placement` | string | One of `tray`, `left_of_clock`, `right_of_clock`, `right_of_workspaces`, `left_of_stats` — which fixed slot in the consuming app's layout this widget renders into. | +| `order` | number | Optional, default `0`. Sort priority within a placement; lower sorts first. | +| `visible` | bool | Optional, default `true`. | +| `tooltip` | string | Optional. | +| `root` | node | The render tree (see Node types below). | + +Returns `true` on success, or `false, err` if `root` fails validation (tree too deep, too many nodes, or an invalid `class`), `root` contains a `style` field with a value outside its enum (a deserialization error, reported the same way), or `bread.widget.register` was called outside a module. + +##### Node types + +Every node accepts an optional `style` (a bounded, typed vocabulary — see below; this is the primary way to control a node's appearance), an optional `class` (a small freeform escape hatch, see [Style vs. class](#style-vs-class) below), and an optional `on_click` (any Lua value, passed through opaquely — see Click events below). + +| `type` | Fields | +|--------|--------| +| `box` | `orientation` (`"horizontal"` \| `"vertical"`, default horizontal), `spacing`, `children` (array of nodes) | +| `label` | `text` | +| `icon` | `name` (bundled icon) or `path` (arbitrary SVG file) — exactly one; `size` | +| `progress` | `value` (0.0–1.0) | + +A tree is capped at depth 4 (root counts as depth 1) and 50 total nodes — comfortably enough for a status readout, not enough to build a full custom UI. + +```lua +bread.widget.register({ + id = "weather", + placement = "left_of_stats", + tooltip = "Sydney: Partly cloudy", + root = { + type = "box", + children = { + { type = "icon", name = "cloud" }, + { type = "label", text = "22°C", style = { color = "dim" }, on_click = "refresh" }, + }, + }, +}) +``` + +##### `style` *(Since: v1.4)* + +`style` is a bounded, typed vocabulary for a node's appearance — every field is a small closed enum, not a string, so a typo is a `bread.widget.register` validation failure at registration time, not a silently-ignored CSS class. There is deliberately **no raw CSS/style-string field** anywhere in this API: a module can only ever pick from the fixed set below, never inject arbitrary style. + +| Field | Type | Values | +|-------|------|--------| +| `color` | string | `fg`, `dim` (muted foreground), `accent`, `red`, `green`, `yellow`, `blue`, `pink`, `teal` | +| `weight` | string | `normal`, `bold` | +| `size` | string | `xs`, `sm`, `md`, `lg`, `xl` — text size in px (10/12/14/16/20); `sm`/`md` match the bread design system's own secondary/base font sizes | +| `align` | string | `start`, `center`, `end` | +| `background` | string | `none`, `surface`, `card` (surface + rounded corners + padding) | +| `radius` | string | `none`, `sm`, `md`, `full` (pill) | +| `padding` | string | `none`, `xs`, `sm`, `md` | + +Every field is optional and independent — set only what you need. Colors, font sizes, radii, and padding all reuse the exact same palette, font, and spacing scale every other `bread*` GUI (breadbar, bos-settings, breadpad, ...) is themed from, so a widget recolors with the rest of the desktop when pywal's palette changes instead of drifting out of sync. + +```lua +{ type = "label", text = "LOW BATTERY", style = { color = "yellow", weight = "bold" } } +``` + +##### Style vs. `class` + +`class` still exists as an escape hatch for a CSS class the *consuming app's own stylesheet* happens to define (restricted to `^[a-zA-Z][a-zA-Z0-9_-]{0,63}$`) — useful if you're targeting a specific app you know the internals of, but undiscoverable and app-specific otherwise. As of this writing, breadbar's stylesheet only gives real meaning to `dim` this way (fades a node to 60% opacity) — everything else a module needs (color, weight, size, alignment, background, radius, padding) should go through `style` instead, which every renderer is expected to understand identically. + +#### `bread.widget.update(id, patch) -> ok, err` +Patches an already-registered widget (local `id`, not the fully-qualified form). Any of `root`, `tooltip`, `visible`, `order` may be given; omitted fields are left as-is. `root`, when given, replaces the whole tree — there is no node-level patching. Returns `false, "no such widget"` if `id` isn't registered. + +```lua +bread.widget.update("weather", { + root = { type = "box", children = { { type = "label", text = "23°C" } } }, +}) +``` + +#### `bread.widget.remove(id) -> bool` +Removes a widget registered by the calling module. Returns whether anything was removed. + +#### `bread.widget.list() -> table` +Returns an array of every widget the calling module currently has registered. + +##### Click events + +A clicked node's `on_click` value doesn't travel back through `breadd` directly — the rendering app (breadbar) emits `bread.bar.widget_clicked` with `{ widget_id, action }` (`action` being whatever you put in `on_click`), because a rendering app may only publish inside its own `bread..*` namespace (see [Namespaces](#namespaces)). React to it like any other event, filtering on `widget_id`: + +```lua +bread.on("bread.bar.widget_clicked", function(e) + if e.data.widget_id == "weather.weather" then + -- e.data.action == "refresh" + end +end) +``` + ### State #### `bread.state.get(path)` @@ -329,6 +918,29 @@ Activate a named profile. Emits `bread.profile.activated` over IPC. #### `bread.exec(cmd)` Run a shell command. Fire-and-forget (async, does not block Lua). +#### `bread.exec_capture(cmd, opts) -> ok, stdout` +Run a shell command and return its result: `ok` is whether it exited zero, +`stdout` is its captured standard output. Unlike `bread.exec`, this blocks +the calling Lua callback until the command exits (or the timeout below +elapses), so it's only appropriate for fast, local commands — e.g. +`git -C rev-parse --abbrev-ref HEAD`, not anything that hits the +network or waits on user input. + +```lua +local ok, branch = bread.exec_capture("git -C " .. dir .. " rev-parse --abbrev-ref HEAD") +if ok then + branch = branch:gsub("%s+$", "") -- trailing newline +end +``` + +Options: + +| Key | Type | Default | +|-----|------|---------| +| `timeout_ms` | number | `2000` | + +On timeout or spawn failure, returns `false, ""`. + ### Notifications #### `bread.notify(message, opts)` @@ -394,9 +1006,20 @@ Read a file. Returns `nil` if the file does not exist. `~` is expanded. #### `bread.fs.exists(path) -> bool` Returns true if the path exists. `~` is expanded. +#### `bread.fs.readlink(path) -> string | nil` +Read a symlink's target. Returns `nil` if the path doesn't exist or isn't a +symlink. Distinct from `bread.fs.read`, which opens and reads file +*contents* — for something like `/proc//cwd`, the payload is the link +target itself, not a file to read. + #### `bread.fs.expand(path) -> string` Expand `~` to the home directory. +#### `bread.json.decode(str) -> table | nil` +Parse a JSON string into a Lua table. Returns `nil` on malformed input. +Pairs naturally with `bread.exec_capture` for consuming JSON output from a +CLI (e.g. `kitty @ ls`). + ### Hyprland The `bread.hyprland` namespace provides compositor bindings. @@ -409,6 +1032,10 @@ bread.hyprland.dispatch("exec", "kitty") -- Set a keyword bread.hyprland.keyword("monitor", "HDMI-A-1, 2560x1440, 0x0, 1") +-- Send a raw request to the Hyprland socket, e.g. to evaluate a config-file +-- expression the way `hyprctl eval ` does; returns the raw response string +local result = bread.hyprland.eval("some expression") + -- Query compositor state (returns deserialized Lua tables) local win = bread.hyprland.active_window() local monitors = bread.hyprland.monitors() @@ -539,6 +1166,37 @@ Storage is scoped per module and is not shared across modules. Built-ins are loaded before user modules. Disable them via `[modules].disable` in the daemon config. +### `bread.rules` *(Since: v1.5)* + +The Lua side of the `rules.toml` declarative automation layer described in +[Getting started](#getting-started) — there is no separate API to call +here, it's driven entirely by `~/.config/bread/rules.toml`. Listed here (and +disable-able via `[modules].disable = ["bread.rules"]` like every other +built-in) because it's a real module the same way `bread.devices` is, just +one whose configuration lives in TOML instead of Lua. + +```toml +# ~/.config/bread/rules.toml +[[rule]] +on = "device.dock.connected" +run = "~/.config/bread/scripts/dock-connected.sh" + +[[rule]] +on = "power.ac.disconnected" +notify = "Unplugged" + +[[rule]] +on = "device.keyboard.connected" +exec = "xset r rate 200 40" +``` + +Each rule's `on` becomes a `bread.on("bread." .. on, ...)` subscription — +see [Getting started](#getting-started) for the full `run`/`exec`/`notify` +semantics and validation rules. `rules.toml`'s absence is not an error; +parse/validation problems are reported the same way a broken hand-written +module's `on_load` error would be — via `bread doctor` / `modules.list`, +against the `bread.rules` module name. + ### `bread.monitors` High-level declarative monitor event handlers. @@ -721,10 +1379,15 @@ Events are delivered as a `BreadEvent`: "event": "bread.device.dock.connected", "timestamp": 1710000000000, "source": "Udev", - "data": {} + "data": {}, + "id": "b3f2c9a0-4e6d-4b8a-9c1e-7a2f5d8e0c11", + "caused_by": null } ``` +- **`id`** *(Since: v1.5)* — a unique id assigned to this specific event instance at construction. Every `BreadEvent`, regardless of origin (adapter-normalized, IPC `emit`, Lua `bread.emit()`, or a daemon-internal send like `bread.system.startup`), gets one. +- **`caused_by`** *(Since: v1.5)* — the `id` of the event whose Lua subscriber handler emitted this event via `bread.emit()`, or `null` if this event did not originate from inside a running handler (adapter events, IPC `emit`, daemon-internal sends). This lets you reconstruct causality chains across modules that react to each other's events: if module A's handler for event X calls `bread.emit("Y", ...)`, then Y's `caused_by` is X's `id`. See `bread events --tree` below for a rendering of these chains. + ### Pattern matching | Pattern | Matches | @@ -741,6 +1404,7 @@ Events are delivered as a `BreadEvent`: | Event | Data | |-------|------| | `bread.system.startup` | `{}` | +| `bread.module.crashed` *(Since: v1.6)* | `{ module, pid, reason, exit_code, signal }` — an out-of-process `bread-module-host` child exited (crash, panic, `kill -9`, ...). `exit_code`/`signal` are mutually exclusive (whichever applies); see [Out-of-process module sandboxing](#out-of-process-module-sandboxing-since-v16). | #### Devices (udev / Bluetooth) @@ -775,19 +1439,43 @@ Both USB/udev devices and Bluetooth devices emit `bread.device.connected` / `bre #### Hyprland +*Since: v1.5 — the `bread.hyprland.*` namespaced forms below. Bread's event vocabulary is meant to be portable across a future second compositor backend; a flat `bread.workspace.*`/`bread.monitor.*`/`bread.window.*` name gave no way to tell a genuinely cross-backend event (like `bread.power.*`) apart from one that is Hyprland-specific. The 10 rows marked `Deprecated: v1.5` are unaffected functionally — they keep firing — but new automation should subscribe to their `bread.hyprland.*` sibling instead.* + +Every Hyprland-sourced event below is dual-emitted: the daemon fires both the legacy flat name and its `bread.hyprland.` equivalent with identical `data`/`timestamp`/`source`, unless `[compat] legacy_hyprland_event_names = false` is set (see below), in which case only the namespaced name fires. A module that subscribes only to `bread.hyprland.*` always gets full workspace/monitor/window coverage regardless of that setting. + | Event | Data | |-------|------| -| `bread.workspace.changed` | raw payload | -| `bread.workspace.created` | `{ workspace }` | -| `bread.workspace.destroyed` | `{ workspace }` | -| `bread.monitor.connected` | raw payload | -| `bread.monitor.disconnected` | raw payload | -| `bread.window.focus.changed` | raw payload | -| `bread.window.focused` | `{ address }` | -| `bread.window.opened` | `{ address, workspace, class, title }` | -| `bread.window.closed` | `{ address }` | -| `bread.window.moved` | `{ address, workspace }` | -| `bread.hyprland.event` | `{ kind, raw, data }` (unhandled kinds) | +| `bread.workspace.changed` *(Deprecated: v1.5 — use `bread.hyprland.workspace.changed`)* | raw payload | +| `bread.hyprland.workspace.changed` *(Since: v1.5)* | raw payload | +| `bread.workspace.created` *(Deprecated: v1.5 — use `bread.hyprland.workspace.created`)* | `{ workspace }` | +| `bread.hyprland.workspace.created` *(Since: v1.5)* | `{ workspace }` | +| `bread.workspace.destroyed` *(Deprecated: v1.5 — use `bread.hyprland.workspace.destroyed`)* | `{ workspace }` | +| `bread.hyprland.workspace.destroyed` *(Since: v1.5)* | `{ workspace }` | +| `bread.monitor.connected` *(Deprecated: v1.5 — use `bread.hyprland.monitor.connected`)* | raw payload | +| `bread.hyprland.monitor.connected` *(Since: v1.5)* | raw payload | +| `bread.monitor.disconnected` *(Deprecated: v1.5 — use `bread.hyprland.monitor.disconnected`)* | raw payload | +| `bread.hyprland.monitor.disconnected` *(Since: v1.5)* | raw payload | +| `bread.window.focus.changed` *(Deprecated: v1.5 — use `bread.hyprland.window.focus.changed`)* | raw payload | +| `bread.hyprland.window.focus.changed` *(Since: v1.5)* | raw payload | +| `bread.window.focused` *(Deprecated: v1.5 — use `bread.hyprland.window.focused`)* | `{ address }` | +| `bread.hyprland.window.focused` *(Since: v1.5)* | `{ address }` | +| `bread.window.opened` *(Deprecated: v1.5 — use `bread.hyprland.window.opened`)* | `{ address, workspace, class, title }` | +| `bread.hyprland.window.opened` *(Since: v1.5)* | `{ address, workspace, class, title }` | +| `bread.window.closed` *(Deprecated: v1.5 — use `bread.hyprland.window.closed`)* | `{ address }` | +| `bread.hyprland.window.closed` *(Since: v1.5)* | `{ address }` | +| `bread.window.moved` *(Deprecated: v1.5 — use `bread.hyprland.window.moved`)* | `{ address, workspace }` | +| `bread.hyprland.window.moved` *(Since: v1.5)* | `{ address, workspace }` | +| `bread.hyprland.event` | `{ kind, raw, data }` (unhandled kinds — already namespaced, not part of this migration) | +| `bread.hyprland.snapshot` *(Since: v1.7.1)* | `{ monitors, workspaces, active_workspace, active_window }` — emitted once after the Hyprland event socket connects (and again after a reconnect). `bread.state` applies this event to replace compositor topology so monitors/workspaces/focus are populated before the next live event. Not dual-emitted under a legacy name. | + +##### Compatibility: `[compat]` config + +```toml +[compat] +legacy_hyprland_event_names = true # default during the deprecation window +``` + +Set to `false` to suppress the 10 legacy flat names above and emit only their `bread.hyprland.*` equivalents. This defaults to `true` for now; per the [API Stability & Versioning](#api-stability--versioning) deprecation-window policy, the default will flip to `false` in a later release once the window closes. Removing the legacy names entirely is a further, separate follow-up — see the note in `DEPRECATIONS.md`. #### Power @@ -816,6 +1504,17 @@ Both USB/udev devices and Bluetooth devices emit `bread.device.connected` / `bre | `bread.notify.sent` | `{ title, message, urgency }` | | `bread.state.changed.` | emitted by state watches | +#### Widgets *(Since: v1.3)* + +Emitted by `breadd` itself on every `bread.widget.*` mutation — see [Widgets](#widgets-since-v13). `data` is the full `WidgetSpec` for `registered`/`updated`; just `{ id }` for `removed`. + +| Event | Data | +|-------|------| +| `bread.widget.registered` | `{ id, module, placement, order, visible, tooltip, root, updated_at }` | +| `bread.widget.updated` | same shape as `registered` | +| `bread.widget.removed` | `{ id }` | +| `bread.widget.cleared` | `{}` — fired once at the end of every module reload (`bread reload`), whether or not the widget set actually changed. The registry itself is wiped and re-populated as modules re-run; this is a "go re-fetch" signal for consumers that only react to `bread.widget.*` events, so a module that stops registering widgets (e.g. gets disabled) is noticed even though nothing else fires. | + #### Terminal (shell precmd/preexec hooks) Requires `bread hooks install shell` and sourcing the generated script from your shell rc — see the CLI reference. Fires via the `bread-emit` helper, not the daemon reaching out. @@ -885,11 +1584,13 @@ Rides the same shell-hook transport as Terminal events (`bread hooks install she *Since: v1.1 — the `AdapterSource::App` variant and the known-apps registry (`bread_shared::apps::KNOWN_APPS`). No sibling app emits through this path yet as of this writing except the breadclip pilot (see its own `EVENTS.md` once that lands); the daemon-side plumbing and the convention itself are what v1.1 adds.* +*Since: v1.3 — breadbar is now an active `bread-client` consumer under the `bar` app id (already present in `KNOWN_APPS`): it emits `bread.bar.widget_clicked` for widget clicks (see [Widgets](#widgets-since-v13)) and reads `bread.widget.*` to render the [Dictionary: Runtime state schema](#dictionary-runtime-state-schema)'s `widgets` field.* + Two dotted-name segments are reserved, permanent parts of the schema — not one-off conventions: - **`bread..*`** — inbound events published *by* a sibling `bread*` application about its own state (e.g. `bread.clip.copied`). An app may only publish within its own segment; the daemon enforces this at the IPC boundary (a socket client claiming a `source` of an app id it doesn't own is rejected the same way spoofing `power`/`hyprland` is rejected today). -- **`bread.command..`** — outbound commands *to* a sibling application (e.g. `bread.command.clip.clear`). Any module or app may publish; only the target app subscribes. This reuses the existing event bus in both directions — there is no separate request/response protocol. -- The second dotted segment is drawn from a small known-apps registry (`bread_shared::apps::KNOWN_APPS`); daemon-internal domains (`terminal`, `git`, `hyprland`, `device`, `power`, `network`, `service`, `container`, `project`, `remote`, `system`, `profile`, `notify`, `command`, `workflow`) are reserved and cannot be claimed as app ids. +- **`bread.command..`** — outbound commands *to* a sibling application (e.g. `bread.command.clip.clear`). Any module or app may publish; only the target app subscribes. This reuses the existing event bus in both directions — there is no separate request/response protocol. *Since: v1.7 — well-formed `bread.command..` names (`known-app` ∈ `KNOWN_APPS`, verb a non-empty extra dotted segment) are allowed on the unsourced/`bread-emit` path and via sourced `AdapterSource::App` emit (an app may publish a command to another known app). `BreadClient::command` in bread-utils is the typed helper for the same path. `command` remains in `RESERVED_DOMAINS` so it cannot be claimed as an app id; `bread.command.power.off` and `bread.command.notanapp.x` are still rejected. See [Dictionary: IPC protocol](#dictionary-ipc-protocol).* +- The second dotted segment is drawn from a small known-apps registry (`bread_shared::apps::KNOWN_APPS` in `bread-shared/src/apps.rs`); daemon-internal domains (`terminal`, `git`, `hyprland`, `device`, `power`, `network`, `bluetooth`, `workspace`, `window`, `monitor`, `service`, `container`, `project`, `remote`, `system`, `profile`, `notify`, `command`, `workflow`) are reserved and cannot be claimed as app ids. *Since: v1.5 — `bluetooth`, `workspace`, `window`, and `monitor` added to this list (event families the Bluetooth and Hyprland adapters already published under, but that were missing from it); this same list is now also the boundary the IPC `emit` method's no-`source` path checks event names against, see [Dictionary: IPC protocol](#dictionary-ipc-protocol).* - **Commands are best-effort.** Publishing `bread.command..` with no subscriber (the app isn't installed or isn't running) is a silent no-op — there is nothing to special-case, and no error is raised. An app that acts on a command *should* emit a corresponding `bread...done` (or `.failed`) confirmation; a module that needs to know a command was actually honored must `bread.wait`/`bread.wait_any` on that confirmation with a timeout rather than assume success. There is no mandatory request/response correlation layer — most commands are legitimately fire-and-forget, and building one would contradict the "no listener, no-op" degradation property. - **`bread.exec(" ...")`** remains the zero-infrastructure fallback for triggering a sibling app that has a synchronous CLI and no need for a structured response. @@ -899,10 +1600,11 @@ Two dotted-name segments are reserved, permanent parts of the schema — not one This is the checklist for adding a new sibling `bread*` application to the fabric — it's deliberately short, because the whole design goal of the name-based app registry (over one `AdapterSource` enum variant per app) is that this never requires a daemon change beyond step 1. **breadclip is the reference implementation** — see its own `EVENTS.md` for a worked example of every step below. -1. **Register your app id.** Add it to `KNOWN_APPS` in `bread-shared/src/lib.rs` (a one-line, one-word-per-app list) — this is the only change to the `bread` repo itself a new integration needs. +1. **Register your app id.** Add it to `KNOWN_APPS` in `bread-shared/src/apps.rs` (a one-line, one-word-per-app list) — this is the only change to the `bread` repo itself a new integration needs. 2. **Depend on `bread-utils` with the `bread-client` feature.** In your app's daemon (the long-running piece, if you have one — a short-lived CLI tool can use `bread-emit` instead, see below), add `bread-utils = { ..., features = ["bread-client"] }` and use `bread_utils::bread_client::BreadClient`: - `BreadClient::connect(app_id)` — cheap, cannot fail (there is no persistent connection to fail at construction time). - `client.emit(event, data)` — publish within your own `bread..*` namespace. Each call is its own short-lived connection (fire-and-forget, like `bread-emit`) — safe to call from a short-lived per-event process invocation, not just from inside a long-running loop. + - `client.command(target, verb, data)` — publish `bread.command..` to another known app. Same fire-and-forget socket write as `emit`; this is the typed helper for the command-bus path that `bread-emit bread.command..` uses. *Since: v1.7 — the daemon actually accepts these on the unsourced and sourced-app emit paths; see [Namespaces](#namespaces).* - `client.subscribe("bread.command..**", |event| { ... })` — receive commands addressed to you, on a background thread with its own reconnect/backoff loop. 3. **If you don't have a persistent daemon at all** (just a CLI tool invoked occasionally), skip `bread-client` entirely and shell out to `bread-emit` instead (see `bread-emit`'s own `--help`) — it's built for exactly that case (occasional callers that can't justify holding a socket open). 4. **Emit confirmations for commands you honor.** `bread...done` or `.failed` after acting on a `bread.command..` — optional, but it's what lets a Lua workflow `bread.wait`/`bread.wait_any` for the real outcome instead of assuming success the moment it publishes a command. @@ -969,11 +1671,30 @@ This is the checklist for adding a new sibling `bread*` application to the fabri "updated_at": 1710000001500, "error": null } + ], + "widgets": [ + { + "id": "weather.weather", + "module": "weather", + "placement": "left_of_stats", + "order": 0, + "visible": true, + "tooltip": "Sydney: Partly cloudy", + "root": { + "type": "box", + "orientation": "horizontal", + "children": [ + { "type": "icon", "name": "cloud" }, + { "type": "label", "text": "22°C" } + ] + }, + "updated_at": 1710000001500 + } ] } ``` -`modules[].status` values: `loaded`, `load_error`, `not_found`, `degraded`, `disabled`. `workflows[].state` values: `running`, `done`, `failed`, `timed_out` *(Since: v1.2 — see [Workflows](#workflows-since-v12))*. +`modules[].status` values: `loaded`, `load_error`, `not_found`, `degraded`, `disabled`. `workflows[].state` values: `running`, `done`, `failed`, `timed_out` *(Since: v1.2 — see [Workflows](#workflows-since-v12))*. `widgets[].placement` values: `tray`, `left_of_clock`, `right_of_clock`, `right_of_workspaces`, `left_of_stats` *(Since: v1.3 — see [Widgets](#widgets-since-v13))*. --- @@ -1007,7 +1728,43 @@ Available methods: | `profile.activate` | `name` | Switch active profile | | `events.subscribe` | — | Upgrade to streaming mode; pushes events line by line | | `events.replay` | `since_ms` | Replay buffered events from the last N ms | -| `emit` | `event`, `data`, optional `source`, `kind` | Inject an event. Without `source`, builds a `BreadEvent` directly tagged `System` (legacy path). With `source` set to `terminal`/`git`/`remote`, or a registered sibling-app id (see [Namespaces](#namespaces)), builds a real `RawEvent` (requires `kind` too) that goes through the normalizer like any adapter. Any other `source` value is rejected — this is the anti-spoofing boundary that stops a socket client from forging e.g. `power`/`hyprland` events. | +| `emit` | `event`, `data`, optional `source`, `kind` | Inject an event. Without `source`, builds a `BreadEvent` directly, tagged `Manual` *(Since: v1.5 — previously tagged `System`; see below)*, for manually testing Lua handlers (this is what `bread emit ` and `bread-emit` use). Well-formed `bread.command..` is allowed on this path *(Since: v1.7)*; other reserved domains stay rejected. With `source` set to `terminal`/`git`/`remote`, or a registered sibling-app id (see [Namespaces](#namespaces)), builds a real `RawEvent` (requires `kind` too) that goes through the normalizer like any adapter. A sourced app may also publish a well-formed command to another known app. Any other `source` value is rejected — this is the anti-spoofing boundary that stops a socket client from forging e.g. `power`/`hyprland` events. | | `workflows.list` | — | List running/completed workflow instances and their step/status *(Since: v1.2)* | +| `widgets.list` | — | List all registered widgets across every module *(Since: v1.3)* | + +*Since: v1.6* — `module_host.*`: the RPC bridge an out-of-process +`bread-module-host` child uses in place of direct in-process `bread.*` +bindings (see [Out-of-process module +sandboxing](#out-of-process-module-sandboxing-since-v16)). Meaningful only +on a connection that has completed the handshake below; not intended for +direct use by other clients. + +| Method | Params | Description | +|--------|--------|-------------| +| `module_host.hello` | `token` | One-time handshake. Consumes the token, replies with `{ module, permissions, api_version }` or an error for an unknown/expired token. Takes over the rest of the connection's lifetime as a bidirectional RPC bridge, same as `events.subscribe` does for a plain event stream. | +| `module_host.on` / `.once` | `pattern` | Subscribe; replies `{ subscription_id }`. Matches are pushed asynchronously as `{"push":"event", subscription_id, event}` lines interleaved with ordinary responses. | +| `module_host.off` | `id` | Cancel a subscription. | +| `module_host.after` / `.every` | `delay_ms` / `interval_ms` | Server-managed timer; replies `{ timer_id }`. Fires are pushed as `{"push":"timer", timer_id}`. | +| `module_host.cancel` | `id` | Cancel a timer. | +| `module_host.emit` | `event`, `data` | Same manual-emit semantics (and reserved-domain guard) as the top-level `emit` method. | +| `module_host.log` / `.warn` / `.error` | `message` | Forwarded to `breadd`'s own tracing log, prefixed with the module name. | +| `module_host.fs_read` | `path` | Requires `fs.read` granted; path-prefix-checked against the manifest's `path` hint if one was declared. Replies `{ content }` (`null` if unreadable). | +| `module_host.fs_write` | `path`, `content` | Requires `fs.write`, same scoping check. | +| `module_host.exec` | `cmd` | Requires `exec`; `bin`-hint-checked (by leading command word) if declared. Fire-and-forget, matching `bread.exec`'s own semantics. | +| `module_host.exec_capture` | `cmd`, `timeout_ms` | Requires `exec`. Replies `{ ok, stdout }`. | +| `module_host.state_get` | `key` | Requires `state.read`. Replies `{ value }`. | +| `module_host.status` | `state` (`"loaded"`\|`"load_error"`), `error` | The module-host reports its own load outcome after running `init.lua`; updates `modules.list` status and unblocks `breadd`'s spawn-side wait. | + +Every gated method above checks the module's granted `PermissionKind`s +(learned at hello-time) before attempting the call — belt-and-suspenders +alongside the Landlock sandbox enforced at the OS level on the +module-host process itself, not a replacement for it. The `health` response's `api_version` field lets a client — the CLI, a Lua module via `bread.exec`, or a `bread-client`-linked sibling app — assert compatibility with this document's versioned schema at connect time (see [API Stability & Versioning](#api-stability--versioning)). + +*Since: v1.5 — `emit` without `source` closed a spoofing gap: previously any event name was accepted with zero validation and tagged `System`, the same tag the daemon uses internally for events it originates itself in Rust code (`bread.system.startup`, `bread.profile.activated`, ...). That made a manually-injected event indistinguishable from a trusted, daemon-originated one. Now:* +- *The unsourced path is tagged `AdapterSource::Manual`, not `System` — `System` is reserved for the daemon's own Rust-originated sends and can no longer be produced from data that arrived over the IPC socket.* +- *The event name is rejected if its top-level dotted segment (the part right after `bread.`) is one of the reserved, adapter-owned domains in `bread_shared::apps::RESERVED_DOMAINS` — `terminal`, `git`, `hyprland`, `device`, `power`, `network`, `bluetooth`, `workspace`, `window`, `monitor`, `service`, `container`, `project`, `remote`, `system`, `profile`, `notify`, `command`, `workflow` (see [Namespaces](#namespaces)) — since a socket client emitting e.g. `bread.power.ac.connected` this way would otherwise be indistinguishable from the real power adapter observing it.* +- *Since: v1.7 — well-formed `bread.command..` is an explicit exception to that reserved-domain reject (`command` stays reserved so it cannot be claimed as an app id). `bread.command.clip.clear` is accepted unsourced and as a sourced `AdapterSource::App` emit from another known app; `bread.command.power.off`, `bread.command.notanapp.x`, and `bread.hyprland.*` are still rejected. `API_VERSION` bumped from `1.6.0` to `1.7.0` for this addition.* +- *Since: v1.7.1 — the state engine applies both legacy Hyprland names and `bread.hyprland.*` (so flipping `[compat] legacy_hyprland_event_names = false` no longer freezes monitors/workspace/window). `RuntimeState.workspaces` is written on `workspace.created`/`destroyed` and replaced by `bread.hyprland.snapshot`. `API_VERSION` bumped from `1.7.0` to `1.7.1`.* +- *Freely-named custom/test event names (anything outside those reserved domains, including names with no `bread.` prefix at all) remain unrestricted — this is what keeps `bread emit ` useful for testing Lua handlers without unplugging cables, and what `bread-emit`'s fire-and-forget, no-reply-wait design still works against unchanged (a single JSON line write is still sufficient; no handshake was added).* diff --git a/Examples.md b/Examples.md index 01da058..c610455 100644 --- a/Examples.md +++ b/Examples.md @@ -238,6 +238,78 @@ Check on a running (or finished) workflow via the IPC method directly (there's n echo '{"id":"1","method":"workflows.list","params":{}}' | nc -U -q0 "$XDG_RUNTIME_DIR/bread/breadd.sock" ``` +## Example 5: A live widget in breadbar + +The examples above all react to something; they don't put anything on +screen. `bread.widget` *(Since: v1.3)* does — a module declares a small node +tree and breadbar (or any sibling app that renders `bread.widget.*`) shows +it in one of five fixed layout slots, live-updated from Lua. + +Full source: `examples/modules/cpu-temp-widget.lua`. + +```lua +-- ~/.config/bread/modules/cpu-temp-widget.lua +local M = bread.module({ name = "cpu-temp-widget", version = "1.0.0" }) + +local TEMP_PATH = "/sys/class/hwmon/hwmon6/temp1_input" +local HOT_THRESHOLD_C = 80 + +local function read_temp_c() + local raw = bread.fs.read(TEMP_PATH) + return raw and (tonumber(raw) / 1000) or nil +end + +local function widget_root(temp_c) + local text = temp_c and string.format("%.0f°C", temp_c) or "—" + local hot = temp_c ~= nil and temp_c >= HOT_THRESHOLD_C + return { + type = "box", + children = { + { + type = "label", + text = text, + style = hot and { color = "red", weight = "bold" } or { color = "dim" }, + }, + { + type = "progress", + value = temp_c and math.min(temp_c / 100, 1.0) or 0, + style = hot and { color = "red" } or nil, + }, + }, + } +end + +function M.on_load() + bread.widget.register({ + id = "cpu-temp", + placement = "left_of_stats", + tooltip = "CPU package temperature (Tctl)", + root = widget_root(read_temp_c()), + }) + + bread.every(5000, function() + bread.widget.update("cpu-temp", { root = widget_root(read_temp_c()) }) + end) +end + +return M +``` + +Walking through what each piece buys you: + +- **`root` is a small typed tree, not markup.** `box`/`label`/`icon`/`progress` map directly onto GTK primitives, so any renderer can draw it without interpreting a DSL — see [Widgets](Documentation.md#widgets-since-v13) for the full node reference and the size/depth caps. +- **`bread.widget.update(id, { root = ... })` replaces the whole tree.** There's no node-level patching — for something this small, rebuilding the tree on every tick (here, every 5s) is simpler than diffing, and it's cheap enough that it doesn't matter. +- **`style` is a bounded, typed vocabulary, not a style string.** `color = "red"` here maps to one fixed CSS class the rendering app defines, resolved from the real pywal-derived palette — see [Widgets §style](Documentation.md#style-since-v14) for the full field list. There's also a freeform `class` escape hatch, but a module can't inject arbitrary CSS through either path. +- **Clicks come back as events, not callbacks.** A node's `on_click` value isn't invoked directly — the rendering app emits `bread.bar.widget_clicked` with `{ widget_id, action }`, and your module reacts with a normal `bread.on` handler. See `examples/modules/bluetooth-toggle-widget.lua` for a widget that uses this to drive a real action (`bread.bluetooth.power`) instead of just displaying something — or `examples/modules/focus-mode-widget.lua` for one that drives `bread.profile.activate` and stays in sync when the profile changes from somewhere else entirely (the CLI, another module), not just from its own click. +- **Placement is one of five fixed slots** (`tray`, `left_of_clock`, `right_of_clock`, `right_of_workspaces`, `left_of_stats`) — see `examples/modules/active-window-widget.lua` for `right_of_workspaces` driven by `bread.state.watch` instead of a timer. +- **A widget doesn't have to read hardware.** `examples/modules/workflow-status-widget.lua` polls `bread.workflow.list()` instead — the same engine from Example 4 — and sets `visible = false` to disappear entirely when there's nothing to report, rather than showing a stale or empty readout. + +Check what's currently registered over IPC (there's no dedicated `bread` subcommand for this yet — see `widgets.list` in the [IPC protocol dictionary](Documentation.md#dictionary-ipc-protocol)): + +```bash +echo '{"id":"1","method":"widgets.list","params":{}}' | nc -U -q0 "$XDG_RUNTIME_DIR/bread/breadd.sock" +``` + ## Tips for porting your own scripts - Start by logging the event payload: `bread.log(event.data.raw)` diff --git a/README.md b/README.md index 0cab0db..9b48f5f 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ Instead of scattering behavior across shell scripts, compositor configs, udev ru Bread runs a long-lived daemon (`breadd`) that: 1. Ingests raw signals from your compositor, hardware, and OS -2. Normalizes them into stable, semantic events (`bread.device.dock.connected`, `bread.monitor.connected`, etc.) +2. Normalizes them into stable, semantic events (`bread.device.dock.connected`, `bread.hyprland.monitor.connected`, etc.) 3. Maintains a live model of your desktop state 4. Delivers those events to Lua modules that implement your automation @@ -42,10 +42,12 @@ return M ## Architecture ``` -breadd/ Rust daemon — event pipeline, state engine, IPC, adapter supervision -bread-cli/ CLI frontend — talks to breadd over a Unix socket -bread-shared/ Shared types — RawEvent, BreadEvent, AdapterSource -packaging/ Arch PKGBUILD and systemd user service +breadd/ Rust daemon — event pipeline, state engine, IPC, adapter supervision +bread-cli/ CLI frontend — talks to breadd over a Unix socket +bread-emit/ Tiny fire-and-forget IPC emitter (hooks / command bus) +bread-module-host/ Out-of-process sandboxed Lua module runtime +bread-shared/ Shared types — RawEvent, BreadEvent, AdapterSource +packaging/ systemd user service unit (bakery installs this) ``` The daemon is structured in four layers: @@ -80,7 +82,7 @@ git clone https://git.breadway.dev/Breadway/bread.git cd bread ``` -Run the install script — it builds, symlinks `breadd` and `bread` into `~/.local/bin` (override with `BIN_DIR=…`), installs the systemd user service, and starts the daemon: +Run the install script — it builds, symlinks `breadd`, `bread`, `bread-emit`, and `bread-module-host` into `~/.local/bin` (override with `BIN_DIR=…`), installs the systemd user service, and starts the daemon: ```bash bash scripts/install.sh @@ -92,13 +94,16 @@ Or step by step (system-wide install): cargo build --release sudo install -Dm755 target/release/breadd /usr/bin/breadd sudo install -Dm755 target/release/bread /usr/bin/bread +sudo install -Dm755 target/release/bread-emit /usr/bin/bread-emit +sudo install -Dm755 target/release/bread-module-host /usr/bin/bread-module-host ``` -### Arch Linux (PKGBUILD) +### Via bakery + +Prebuilt binaries ship through `bakery` (the bread-ecosystem package manager), not a PKGBUILD / pacman package: ```bash -cd packaging/arch -makepkg -si +bakery install bread ``` ### systemd user service @@ -144,17 +149,42 @@ enabled = true [events] dedup_window_ms = 100 +[compat] +legacy_hyprland_event_names = true # dual-emits bread.hyprland.* alongside legacy flat names; see Documentation.md + [notifications] default_timeout_ms = 5000 default_urgency = "normal" notify_send_path = "notify-send" [modules] -builtin = true # load built-in modules (monitors, devices, workspaces, binds) +builtin = true # load built-in modules (monitors, devices, workspaces, binds, rules) disable = [] # list of built-in module names to disable ``` -Your automation lives in `~/.config/bread/init.lua`. Modules placed in `~/.config/bread/modules/` are auto-loaded after `init.lua`: +For the common "when event X happens, do Y" case, you don't need Lua at +all — drop rules straight into `~/.config/bread/rules.toml` and skip +`init.lua` entirely: + +```toml +# ~/.config/bread/rules.toml +[[rule]] +on = "device.dock.connected" +run = "~/.config/bread/scripts/dock-connected.sh" + +[[rule]] +on = "power.ac.disconnected" +notify = "Unplugged" +``` + +It's optional and purely additive alongside `init.lua` — see +[Getting started in Documentation.md](Documentation.md#getting-started) for +the full schema (`run` vs `exec` vs `notify`, wildcard `on` patterns, and +how a malformed rule surfaces via `bread doctor`). + +For anything beyond a single action per event, your automation lives in +`~/.config/bread/init.lua`. Modules placed in `~/.config/bread/modules/` are +auto-loaded after `init.lua`: ```lua -- ~/.config/bread/init.lua @@ -190,6 +220,7 @@ bread events bread.device.* # Stream filtered events bread events --since 60 # Replay events from the last 60 seconds bread events --fields event,data # Limit output to specific fields bread events --json # Output raw JSON +bread events --tree # Render as a causality tree (caused_by) instead of a flat stream bread emit # Manually fire an event (for testing) # Profiles @@ -201,6 +232,17 @@ bread modules list # List installed modules and daemon status bread modules install /local/path # Install from a local module directory bread modules remove # Remove an installed module (--yes skips confirmation) bread modules info # Show full manifest and daemon status +bread modules audit # Scan a module's Lua source and suggest a [[permissions]] block + +# Hooks +bread hooks install-shell [shell] # Install precmd/preexec/chpwd shell hooks (auto-detects $SHELL) +bread hooks install-git # Install git hooks (post-commit/checkout/merge) in the current repo + +# Compositor integration +bread init # Install breadbar's Hyprland layer-rule integration (shows a diff, asks to confirm) +bread init --dry-run # Print the proposed diff only, change nothing +bread init --yes # Skip the confirmation prompt (scripted/image builds) +bread init --undo # Remove the previously installed integration ``` --- @@ -211,10 +253,18 @@ Modules are Lua files (or directories) installed to `~/.config/bread/modules/`. ### Installing modules -Modules install from a local directory only. Modules run with full -`bread.exec()` privileges and are **not** sandboxed, so to use a module -published on a git host, clone it yourself and review the Lua before -installing from the local checkout: +Modules install from a local directory only. By default a module runs +in-process with full, ungated `bread.exec()` privileges — the same trust +model as before — so to use a module published on a git host, clone it +yourself and review the Lua before installing from the local checkout. +A module can opt into a smaller, enforced footprint by declaring +`[[permissions]]` in its manifest: it then runs out-of-process under an +OS-level (Landlock) sandbox limited to exactly what it declared, with a +`bread` table that only exposes the granted namespaces. See +[Capability-scoped modules](Documentation.md#capability-scoped-modules-since-v15) and +[Out-of-process module sandboxing](Documentation.md#out-of-process-module-sandboxing-since-v16) +for the full permission taxonomy and what's enforced at the kernel level +versus what isn't yet. ```bash git clone https://github.com/someuser/bread-wifi ~/src/bread-wifi diff --git a/api-schema.toml b/api-schema.toml new file mode 100644 index 0000000..09b138d --- /dev/null +++ b/api-schema.toml @@ -0,0 +1,615 @@ +# Bread Automation API schema — checked-in source-of-truth registry. +# +# This is Workstream F from the governance-hardening report: a *drift +# detector*, not a doc generator. `Documentation.md`'s "Dictionary: Lua API" +# section is hand-written prose (one `#### bread.(...)` heading per +# binding, with worked examples and edge-case notes) — nothing here +# regenerates or reformats that prose. Instead, this file is the checked-in +# list of every `bread.*` Lua binding, IPC method, and `bread` CLI command +# that is supposed to exist right now, and `cargo run -p xtask -- check-docs` +# (wired into CI via .forgejo/workflows/dev-release.yml — fails the build on +# any drift) cross-checks it against: +# +# 1. The actual bindings registered in breadd/src/lua/mod.rs +# (`bread.set("name", ...)` calls, the nested `_tbl.set(...)` calls +# for state/profile/hyprland/widget/machine/fs/json/bluetooth, and the +# handful of bindings defined via plain embedded Lua source rather than +# `bread.set` — log/warn/error/debounce/spawn/wait/wait_any/wait_all/ +# workflow.*). +# 2. The actual IPC methods dispatched in breadd/src/ipc/mod.rs's +# `match req.method.as_str() { ... }` block, plus the specially-cased +# `events.subscribe` streaming upgrade. +# 3. The actual `bread` CLI commands declared in bread-cli/src/main.rs's +# `Commands`/`ModulesCommand`/`HooksCommand` enums. +# 4. Documentation.md, to make sure each lua_function/lua_table/ipc_method +# entry here still has a `#### bread.` heading (Lua) or a row in +# the IPC Methods table (IPC methods). +# 5. README.md's "CLI reference" section, to make sure each cli_command +# entry here still has a `bread ` line there. This check exists +# because that section drifted from Documentation.md/the real CLI +# surface before check-docs covered it at all (missing `modules audit`, +# `hooks install-shell`/`install-git`, `events --tree`) — found and +# fixed by hand, then closed here so it can't recur silently. +# +# Whenever you add, rename, or remove a `bread.*` binding, an IPC method, or +# a `bread` CLI command: +# 1. Update this file to match. +# 2. Update/add the corresponding section in Documentation.md (Lua/IPC) +# or README.md's CLI reference (CLI commands). +# 3. Run `cargo run -p xtask -- check-docs` before committing — it fails +# loudly (non-zero exit) if the schema, the code, and the docs are out +# of sync. CI runs this too (dev-release.yml), so drift that slips past +# a local run still fails the build. +# +# `kind` is one of: "lua_function", "lua_table", "ipc_method", "cli_command". +# +# `since` means two different things depending on `kind`, because CLI +# commands were never part of the Bread Automation API's own versioned +# contract (see Documentation.md's "API Stability & Versioning" section — +# it's explicitly scoped to "Lua API surface + IPC methods + event +# vocabulary + runtime-state schema", not the CLI): +# - lua_function / lua_table / ipc_method: the Bread Automation API +# version (breadd/src/ipc/mod.rs's `API_VERSION`) the binding/method was +# introduced in. Anything from the original v1.0 baseline (no +# `*(Since: vX.Y)*` marker in Documentation.md) is listed as "1.0" here. +# - cli_command: the `bread`/`breadd` package version (the workspace +# crates' `Cargo.toml` `version`, kept in lockstep — see CONTRIBUTING.md) +# the command was introduced in. Pre-existing commands as of this +# registry's creation are listed as "0.7" (the release before this one); +# no attempt was made to date them more precisely than that. +# +# Format chosen: a single checked-in TOML file (this is the "a schema file +# that's checked and diffed against the actual API surface, and CI fails the +# build if they drift" option the source report names, as opposed to Rust +# attribute macros — overkill for a ~45-entry surface with no existing +# proc-macro infrastructure in this workspace). TOML specifically because +# `toml = "0.8"` is already a dependency of breadd/bread-cli/bread-shared +# (see breadd/src/core/config.rs, bread-cli/src/modules_mgmt.rs) — no new +# format/parser needed anywhere in the ecosystem. + +# --------------------------------------------------------------------------- +# Lua API — Events (breadd/src/lua/mod.rs install_api + install_wait_helper) + +[[entry]] +name = "on" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "once" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "filter" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "off" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "emit" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "wait" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "spawn" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "wait_any" +kind = "lua_function" +since = "1.2" + +[[entry]] +name = "wait_all" +kind = "lua_function" +since = "1.2" + +# --------------------------------------------------------------------------- +# Lua API — Workflows (install_workflow_helpers) *(Since: v1.2)* + +[[entry]] +name = "workflow" +kind = "lua_table" +since = "1.2" + +[[entry]] +name = "workflow.define" +kind = "lua_function" +since = "1.2" + +[[entry]] +name = "workflow.start" +kind = "lua_function" +since = "1.2" + +[[entry]] +name = "workflow.step" +kind = "lua_function" +since = "1.2" + +[[entry]] +name = "workflow.status" +kind = "lua_function" +since = "1.2" + +[[entry]] +name = "workflow.list" +kind = "lua_function" +since = "1.2" + +# --------------------------------------------------------------------------- +# Lua API — Widgets (widget_tbl) *(Since: v1.3)* + +[[entry]] +name = "widget" +kind = "lua_table" +since = "1.3" + +[[entry]] +name = "widget.register" +kind = "lua_function" +since = "1.3" + +[[entry]] +name = "widget.update" +kind = "lua_function" +since = "1.3" + +[[entry]] +name = "widget.remove" +kind = "lua_function" +since = "1.3" + +[[entry]] +name = "widget.list" +kind = "lua_function" +since = "1.3" + +# --------------------------------------------------------------------------- +# Lua API — State (state_tbl) + +[[entry]] +name = "state" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "state.get" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.monitors" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.active_workspace" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.active_window" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.devices" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.power" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.network" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.profile" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "state.watch" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Profiles (profile_tbl) + +[[entry]] +name = "profile" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "profile.activate" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Execution, notifications, timers + +[[entry]] +name = "exec" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "exec_capture" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "notify" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "after" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "every" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "cancel" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Hyprland (hyprland_tbl) + +[[entry]] +name = "hyprland" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "hyprland.dispatch" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.keyword" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.eval" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.active_window" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.monitors" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.workspaces" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.clients" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "hyprland.on_raw" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Module declaration + +[[entry]] +name = "module" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Machine and filesystem (machine_tbl / fs_tbl / json_tbl) + +[[entry]] +name = "machine" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "machine.name" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "machine.tags" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "machine.has_tag" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "fs" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "fs.write" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "fs.read" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "fs.exists" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "fs.readlink" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "fs.expand" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "json" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "json.decode" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Bluetooth (bluetooth_tbl) + +[[entry]] +name = "bluetooth" +kind = "lua_table" +since = "1.0" + +[[entry]] +name = "bluetooth.power" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "bluetooth.powered" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "bluetooth.connect" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "bluetooth.disconnect" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "bluetooth.scan" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "bluetooth.devices" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# Lua API — Utilities (install_log_helpers / install_debounce) + +[[entry]] +name = "log" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "warn" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "error" +kind = "lua_function" +since = "1.0" + +[[entry]] +name = "debounce" +kind = "lua_function" +since = "1.0" + +# --------------------------------------------------------------------------- +# IPC methods (breadd/src/ipc/mod.rs handle_request + events.subscribe) + +[[entry]] +name = "ping" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "health" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "state.get" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "state.dump" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "modules.list" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "modules.reload" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "profile.list" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "profile.activate" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "emit" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "events.subscribe" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "events.replay" +kind = "ipc_method" +since = "1.0" + +[[entry]] +name = "workflows.list" +kind = "ipc_method" +since = "1.2" + +[[entry]] +name = "widgets.list" +kind = "ipc_method" +since = "1.3" + +# --------------------------------------------------------------------------- +# CLI commands (bread-cli/src/main.rs) — checked against README.md's "CLI +# reference" section, not Documentation.md (which has no CLI section of its +# own). `since` here is the package version, not the API_VERSION — see this +# file's header. + +[[entry]] +name = "reload" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "state" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "events" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "modules.list" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "modules.install" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "modules.remove" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "modules.info" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "modules.audit" +kind = "cli_command" +since = "0.8" + +[[entry]] +name = "hooks.install-shell" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "hooks.install-git" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "profile-list" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "profile-activate" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "emit" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "ping" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "health" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "doctor" +kind = "cli_command" +since = "0.7" + +[[entry]] +name = "init" +kind = "cli_command" +since = "0.8" diff --git a/bakery.toml b/bakery.toml index ab782a0..33a8998 100644 --- a/bakery.toml +++ b/bakery.toml @@ -1,9 +1,10 @@ name = "bread" description = "Reactive automation daemon and CLI for Linux desktops" -binaries = ["breadd", "bread"] +binaries = ["breadd", "bread", "bread-emit", "bread-module-host"] system_deps = ["systemd-libs", "openssl", "zlib"] optional_system_deps = ["bluez", "hyprland"] bread_deps = [] +license_file = "LICENSE" [[service]] unit = "breadd.service" diff --git a/bread-cli/Cargo.toml b/bread-cli/Cargo.toml index 4fa8e7b..0cd947b 100644 --- a/bread-cli/Cargo.toml +++ b/bread-cli/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bread-cli" -version = "0.7.0" +version = "0.8.0" edition = "2021" [[bin]] diff --git a/bread-cli/src/hooks_shell.rs b/bread-cli/src/hooks_shell.rs index 63b692a..4272c79 100644 --- a/bread-cli/src/hooks_shell.rs +++ b/bread-cli/src/hooks_shell.rs @@ -13,6 +13,20 @@ //! user later doesn't want it, an rc-file edit is much harder to notice and //! undo than a printed snippet they chose to paste in. //! +//! `bread init` (`init.rs`) looks like it breaks this rule — it does +//! propose an edit to a user's own `hyprland.lua` — but it's a narrower, +//! consent-gated exception, not a reversal of it. The difference is what's +//! silent about the failure mode: a missing shell hook is invisible +//! enrichment (no telemetry, nothing looks wrong), so leaving it to the +//! user to paste in at their own pace is the right default. A missing +//! compositor layer rule is not invisible — breadbar renders unblurred and +//! with the wrong opacity, which reads as "this app is broken," not +//! "optional feature not enabled," and there's no snippet a user could be +//! expected to reverse-engineer for that. `init.rs` earns the edit by +//! showing the exact diff, requiring explicit consent (prompt, `--yes`, or +//! nothing at all without a TTY), backing up the file first, and shipping +//! a real `--undo`. See `init.rs`'s module docs for the full rationale. +//! //! # Why bread-emit, not `bread emit` //! //! The generated hooks shell out to the separate `bread-emit` binary diff --git a/bread-cli/src/init.rs b/bread-cli/src/init.rs new file mode 100644 index 0000000..9920f8d --- /dev/null +++ b/bread-cli/src/init.rs @@ -0,0 +1,1281 @@ +//! `bread init` — installs bread's Hyprland compositor integration: the +//! `layerrule`s (blur, ignore_alpha, blur_popups, animation) that make +//! breadbar/breadbox actually look like the translucent shell they're +//! designed as, generated from the active shell theme's `[compositor]` +//! table via `bread-theme layerrules` → `~/.config/hypr/layerrules.json`. +//! +//! # Why this command auto-edits a file, unlike `hooks_shell`/`hooks_git` +//! +//! Read `hooks_shell.rs`'s module header first — it lays out the general +//! rule this repo follows: bread does not silently edit a user's own +//! startup/config files, because that kind of edit is hard to notice and +//! hard to undo. This module is the one deliberate exception, and it is +//! narrow and consent-gated on purpose: +//! +//! - A missing shell hook is invisible enrichment — the shell just doesn't +//! report telemetry, nothing looks broken, and the fix (source a line) +//! is something the user can take at their own pace. +//! - A missing compositor layer rule is not invisible. breadbar renders +//! without blur, without `ignore_alpha`, motion is wrong — it looks like +//! a broken app, not a missing optional feature, and a user hitting that +//! has no way to know the fix is "hand-write five `hl.layer_rule` calls +//! into your Hyprland config." The gap between "install the bread stack" +//! and "the shell looks right" needs to be closable in one command. +//! +//! So: this module *does* propose an edit to the user's own config, but +//! only ever one specific, clearly marked, single block; only after +//! showing the exact diff; only with the user's consent (an interactive +//! prompt, `--yes`, or nothing at all in a non-interactive session); always +//! behind a timestamped backup; and always reversible with `bread init +//! --undo`. Every actual line of layer-rule logic lives in a separate, +//! entirely bread-owned file (`~/.config/hypr/bread.lua`) that is +//! regenerated freely and never hand-edited — the one line touched in the +//! user's own `hyprland.lua` just sources it. +//! +//! # Scope: appearance only +//! +//! `bread.lua` (see [`BREAD_LUA`]) emits `hl.layer_rule` calls built from +//! exactly five fields: `blur`, `ignore_alpha`, `blur_popups`, `animation`, +//! `no_anim`. It never reads or emits window placement, workspace +//! assignment, or focus rules — those are `hl.window_rule` policy, are +//! never part of `layerrules.json`, and are explicitly out of scope for +//! this file even if a future `layerrules.json` somehow grew such a key. +//! An installer that rearranged a user's workspaces on upgrade would be a +//! serious bug; this module is structured so it physically cannot do that. +//! +//! # CLI shape: top-level `Init`, not `HooksCommand::Compositor` +//! +//! `hooks install-shell`/`hooks install-git` share one shape: "generate +//! some bread-owned files, print instructions, never touch the user's own +//! config." This command's shape is different in a way that matters enough +//! to warrant its own top-level verb rather than a third `hooks install` +//! variant: it *proposes an edit to a file it doesn't own*, which needs a +//! diff, a consent gate, a backup, and a symmetrical `--undo` — none of +//! which the `hooks` family has or needs. Folding it into `HooksCommand` +//! would either bolt consent/undo semantics onto a subcommand group that +//! otherwise has neither, or quietly suggest to a reader that hooks and +//! compositor integration are the same kind of operation, when the whole +//! point of this module's design is that they aren't. + +use anyhow::{Context, Result}; +use serde::Deserialize; +use std::collections::BTreeMap; +use std::fs; +use std::io::{self, IsTerminal, Write as IoWrite}; +use std::path::{Path, PathBuf}; + +/// Start-of-block marker written into the user's `hyprland.lua`. Both this +/// and [`MARKER_END`] must appear verbatim (as a whole trimmed line) for a +/// block to be recognized as bread-managed and therefore safe to update or +/// remove; text near, but not matching exactly, is left alone. +pub const MARKER_BEGIN: &str = "-- >>> bread managed >>>"; +/// End-of-block marker. See [`MARKER_BEGIN`]. +pub const MARKER_END: &str = "-- <<< bread managed <<<"; + +/// The single line inserted between the markers. Deliberately just a +/// `pcall(dofile(...))` — every actual rule lives in `bread.lua`, guarded +/// by its own internal `pcall` too (belt and suspenders: this call site +/// can never abort the rest of `hyprland.lua` even if `bread.lua` itself +/// somehow threw outside its own guard, e.g. a syntax error from a +/// half-written file). +fn managed_block_body() -> &'static str { + "pcall(dofile, os.getenv(\"HOME\") .. \"/.config/hypr/bread.lua\") -- bread compositor integration; installed by `bread init`, removed by `bread init --undo`" +} + +fn managed_block_text() -> String { + format!("{MARKER_BEGIN}\n{}\n{MARKER_END}", managed_block_body()) +} + +// --------------------------------------------------------------------------- +// bread.lua — the entirely bread-owned generated file +// --------------------------------------------------------------------------- + +/// Full contents written to `~/.config/hypr/bread.lua`. +/// +/// Self-contained on purpose: it bundles its own minimal JSON object +/// decoder rather than `dofile`-ing `scripts/lib/json.lua`, because that +/// file is a BOS/this-machine convention, not something every Hyprland+Lua +/// user has. The decoder only needs to handle what `layerrules.json` can +/// contain (a flat object of objects with string/number/bool/null leaves) +/// — see `bread-theme layerrules`'s writer for the schema this reads. +/// +/// The whole body runs inside one `pcall`. A missing `layerrules.json` +/// (bread-theme layerrules never run), an unreadable one, or a malformed +/// one all degrade to "no bread layer rules applied this session" — never +/// to a Hyprland config that fails to load. +const BREAD_LUA: &str = r#"-- ~/.config/hypr/bread.lua +-- +-- Generated by `bread init`. DO NOT HAND-EDIT — rerun `bread init` any +-- time to regenerate this file from the current layerrules.json, or +-- `bread init --undo` to remove the one line in hyprland.lua that sources +-- it (this file itself is left in place, inert, until you delete it). +-- +-- Reads ~/.config/hypr/layerrules.json (written by `bread-theme +-- layerrules` from the active shell theme's [compositor] table) and emits +-- one hl.layer_rule() per namespace it describes. +-- +-- Appearance only: blur, ignore_alpha, blur_popups, animation, no_anim. +-- This file must never grow window placement, workspace assignment, or +-- focus rules — those are hl.window_rule policy and belong in your own +-- hyprland.lua, not here. Only these five fields are ever read off each +-- entry below; any other key in layerrules.json (there should not be any) +-- is silently ignored. + +local ok, err = pcall(function() + local path = os.getenv("HOME") .. "/.config/hypr/layerrules.json" + + local fh = io.open(path, "r") + if not fh then + return -- no layerrules.json yet (bread-theme layerrules not run) — nothing to do + end + local raw = fh:read("*a") + fh:close() + + -- Minimal JSON decoder, scoped to layerrules.json's shape (an object of + -- objects; string/number/bool/null leaves; arrays supported for + -- completeness though the schema never uses one). Not a general-purpose + -- parser — see BREAD_LUA's doc comment in bread-cli/src/init.rs for why + -- this doesn't just dofile scripts/lib/json.lua. + local pos, len = 1, #raw + + local function skip_ws() + while pos <= len and raw:sub(pos, pos):match("%s") do + pos = pos + 1 + end + end + + local parse_value + + local function parse_string() + pos = pos + 1 + local out = {} + while pos <= len do + local c = raw:sub(pos, pos) + if c == '"' then + pos = pos + 1 + return table.concat(out) + elseif c == "\\" then + local n = raw:sub(pos + 1, pos + 1) + local escapes = { ['"'] = '"', ["\\"] = "\\", ["/"] = "/", b = "\b", f = "\f", n = "\n", r = "\r", t = "\t" } + out[#out + 1] = escapes[n] or n + pos = pos + 2 + else + out[#out + 1] = c + pos = pos + 1 + end + end + error("unterminated string in layerrules.json") + end + + local function parse_array() + pos = pos + 1 + skip_ws() + local arr = {} + if raw:sub(pos, pos) == "]" then + pos = pos + 1 + return arr + end + while true do + skip_ws() + arr[#arr + 1] = parse_value() + skip_ws() + local c = raw:sub(pos, pos) + pos = pos + 1 + if c == "]" then + return arr + elseif c ~= "," then + error("expected ',' or ']' in layerrules.json array") + end + end + end + + local function parse_object() + pos = pos + 1 + skip_ws() + local obj = {} + if raw:sub(pos, pos) == "}" then + pos = pos + 1 + return obj + end + while true do + skip_ws() + local key = parse_string() + skip_ws() + if raw:sub(pos, pos) ~= ":" then + error("expected ':' in layerrules.json object") + end + pos = pos + 1 + skip_ws() + obj[key] = parse_value() + skip_ws() + local c = raw:sub(pos, pos) + pos = pos + 1 + if c == "}" then + return obj + elseif c ~= "," then + error("expected ',' or '}' in layerrules.json object") + end + end + end + + parse_value = function() + skip_ws() + local c = raw:sub(pos, pos) + if c == '"' then + return parse_string() + elseif c == "{" then + return parse_object() + elseif c == "[" then + return parse_array() + elseif raw:sub(pos, pos + 3) == "true" then + pos = pos + 4 + return true + elseif raw:sub(pos, pos + 4) == "false" then + pos = pos + 5 + return false + elseif raw:sub(pos, pos + 3) == "null" then + pos = pos + 4 + return nil + else + local start = pos + while pos <= len and raw:sub(pos, pos):match("[%d%+%-.eE]") do + pos = pos + 1 + end + if pos == start then + error("unexpected character in layerrules.json at byte " .. pos) + end + return tonumber(raw:sub(start, pos - 1)) + end + end + + local parsed = parse_value() + if type(parsed) ~= "table" then + return + end + + local namespaces = {} + for ns, rule in pairs(parsed) do + if type(ns) == "string" and type(rule) == "table" then + namespaces[#namespaces + 1] = ns + end + end + table.sort(namespaces) -- deterministic emission order + + for _, ns in ipairs(namespaces) do + local r = parsed[ns] + hl.layer_rule({ + name = ns, + match = { namespace = "^" .. ns .. "$" }, + blur = r.blur == true, + ignore_alpha = r.ignore_alpha, + blur_popups = r.blur_popups == true, + animation = r.animation, + no_anim = r.no_anim == true, + }) + end +end) + +if not ok then + -- Never let a bad layerrules.json break the rest of the compositor + -- config — Hyprland just runs without bread's layer rules until the + -- underlying file is fixed (or regenerated with `bread-theme layerrules`). + io.stderr:write("bread.lua: layer rules not applied: " .. tostring(err) .. "\n") +end +"#; + +// --------------------------------------------------------------------------- +// Config layout detection +// --------------------------------------------------------------------------- + +/// What we found at `~/.config/hypr` and whether it's something `bread +/// init` can safely auto-edit. +#[derive(Debug, PartialEq, Eq)] +enum ConfigLayout { + /// `hyprland.lua` exists and is readable as UTF-8 text — the only + /// layout this command will ever write to. + Lua(PathBuf), + /// No `hyprland.lua`, but `hyprland.conf` exists — the legacy hyprlang + /// format. Never auto-edited (a `dofile`-based integration can't work + /// there anyway; conf and Lua are different, mutually exclusive config + /// entry points). + ConfOnly(PathBuf), + /// Neither recognized, or `hyprland.lua` exists but couldn't be read as + /// text (permissions, binary garbage, etc). Conservative default: + /// print instructions, write nothing. + Unrecognized, +} + +fn detect_layout(hypr_dir: &Path) -> ConfigLayout { + let lua_path = hypr_dir.join("hyprland.lua"); + let conf_path = hypr_dir.join("hyprland.conf"); + + if lua_path.is_file() { + return if fs::read_to_string(&lua_path).is_ok() { + ConfigLayout::Lua(lua_path) + } else { + ConfigLayout::Unrecognized + }; + } + if conf_path.is_file() { + return ConfigLayout::ConfOnly(conf_path); + } + ConfigLayout::Unrecognized +} + +// --------------------------------------------------------------------------- +// BOS / existing-owner conflict detection +// --------------------------------------------------------------------------- + +/// How deep to recurse under `~/.config/hypr` while scanning for an +/// existing `breadbar` layer rule. Real trees here are a handful of levels +/// (`scripts/ui/rules.lua`, etc); this is just a hang-safety bound. +const CONFLICT_SCAN_MAX_DEPTH: usize = 8; + +/// Look for a `breadbar*` layer rule bread doesn't own — either BOS's own +/// dotfiles or a user's hand-authored one (this machine's +/// `scripts/ui/rules.lua` is exactly this case: `hl.layer_rule({ name = +/// "breadbar-island", match = { namespace = "^breadbar$" }, ... })`). +/// +/// Detection is deliberately heuristic and file-scoped rather than a real +/// Lua/hyprlang parse: any `.lua` or `.conf` file under `hypr_dir` (other +/// than bread's own generated `bread.lua`) that mentions both a layer-rule +/// keyword (`layer_rule` for Lua, `layerrule` for hyprlang conf) and +/// `breadbar` is treated as an existing owner. False positives (a file +/// that mentions both words without actually defining a breadbar layer +/// rule) are the safe failure mode here — worst case bread declines to +/// install and points at a red herring, which is recoverable by hand; +/// installing a second, conflicting rule set is not. +fn find_breadbar_conflict(hypr_dir: &Path) -> Result> { + if !hypr_dir.is_dir() { + return Ok(None); + } + scan_dir_for_conflict(hypr_dir, 0) +} + +fn scan_dir_for_conflict(dir: &Path, depth: usize) -> Result> { + if depth > CONFLICT_SCAN_MAX_DEPTH { + return Ok(None); + } + let entries = match fs::read_dir(dir) { + Ok(e) => e, + Err(_) => return Ok(None), // an unreadable subdir shouldn't abort the whole command + }; + for entry in entries { + let entry = entry.context("reading directory entry while scanning for compositor conflicts")?; + let path = entry.path(); + let file_type = entry.file_type()?; + + if file_type.is_dir() { + if let Some(found) = scan_dir_for_conflict(&path, depth + 1)? { + return Ok(Some(found)); + } + continue; + } + if !file_type.is_file() { + continue; + } + if path.file_name().and_then(|n| n.to_str()) == Some("bread.lua") { + continue; // our own generated file — never a conflict with itself + } + let ext = path.extension().and_then(|e| e.to_str()).unwrap_or(""); + if ext != "lua" && ext != "conf" { + continue; + } + let Ok(content) = fs::read_to_string(&path) else { + continue; + }; + if mentions_breadbar_layer_rule(&content) { + return Ok(Some(path)); + } + } + Ok(None) +} + +fn mentions_breadbar_layer_rule(content: &str) -> bool { + let lower = content.to_ascii_lowercase(); + let has_layer_rule_keyword = lower.contains("layer_rule") || lower.contains("layerrule"); + has_layer_rule_keyword && lower.contains("breadbar") +} + +// --------------------------------------------------------------------------- +// Managed-block find / plan (pure — operate on strings only) +// --------------------------------------------------------------------------- + +/// Locate the bread-managed block's (start, end) 0-based *line* indices in +/// `content`, if present. A line must match a marker exactly after +/// trimming — a passing mention of the marker text mid-line is not enough, +/// mirroring `hooks_git.rs`'s `is_bread_managed`. +fn find_managed_block(content: &str) -> Option<(usize, usize)> { + let lines: Vec<&str> = content.lines().collect(); + let start = lines.iter().position(|l| l.trim() == MARKER_BEGIN)?; + let end = lines[start..].iter().position(|l| l.trim() == MARKER_END)? + start; + Some((start, end)) +} + +/// Outcome of planning an install edit against a file's current content. +#[derive(Debug, PartialEq, Eq)] +enum ChangeKind { + /// A bread block is already present and byte-identical to what we'd + /// write — nothing to change in `hyprland.lua` (`bread.lua` itself is + /// still freely refreshed by the caller). + Unchanged, + /// No existing block found; the new one will be appended at the end. + Appended, + /// An existing block was found at these 0-based line indices and will + /// be replaced in place (its content differs from what we'd write now + /// — e.g. an older bread version's block). + Replaced { start: usize, end: usize }, +} + +/// Compute the new file content and what kind of change that represents, +/// without touching the filesystem. +fn plan_install(content: &str) -> (String, ChangeKind) { + let block = managed_block_text(); + + if let Some((start, end)) = find_managed_block(content) { + let lines: Vec<&str> = content.lines().collect(); + let existing_block = lines[start..=end].join("\n"); + if existing_block == block { + return (content.to_string(), ChangeKind::Unchanged); + } + + let mut new_lines: Vec<&str> = Vec::with_capacity(lines.len()); + new_lines.extend_from_slice(&lines[..start]); + let block_lines: Vec<&str> = block.lines().collect(); + new_lines.extend_from_slice(&block_lines); + new_lines.extend_from_slice(&lines[end + 1..]); + + let mut new_content = new_lines.join("\n"); + if content.ends_with('\n') { + new_content.push('\n'); + } + (new_content, ChangeKind::Replaced { start, end }) + } else { + let mut new_content = content.to_string(); + if !new_content.is_empty() && !new_content.ends_with('\n') { + new_content.push('\n'); + } + if !new_content.is_empty() { + new_content.push('\n'); // blank separator before the appended block + } + new_content.push_str(&block); + new_content.push('\n'); + (new_content, ChangeKind::Appended) + } +} + +/// Compute the content with the bread-managed block removed, if one is +/// present. Also drops a single blank separator line immediately before +/// the block, if there is one, to avoid leaving a stray blank line behind +/// on every round trip. +fn plan_undo(content: &str) -> Option { + let (start, end) = find_managed_block(content)?; + let lines: Vec<&str> = content.lines().collect(); + + let mut new_lines: Vec<&str> = Vec::with_capacity(lines.len()); + new_lines.extend_from_slice(&lines[..start]); + new_lines.extend_from_slice(&lines[end + 1..]); + + if start > 0 && lines[start - 1].trim().is_empty() { + // Remove the one separator blank line `plan_install` would have + // added, if it's still the line immediately preceding the block. + let idx_in_new = start - 1; + if new_lines.get(idx_in_new).is_some_and(|l| l.trim().is_empty()) { + new_lines.remove(idx_in_new); + } + } + + let mut new_content = new_lines.join("\n"); + if content.ends_with('\n') && !new_content.is_empty() { + new_content.push('\n'); + } + Some(new_content) +} + +// --------------------------------------------------------------------------- +// layerrules.json → hyprlang `.conf` snippet (for the print-only fallback) +// --------------------------------------------------------------------------- + +#[derive(Debug, Deserialize, Default)] +struct LayerRuleEntry { + #[serde(default)] + blur: bool, + ignore_alpha: Option, + #[serde(default)] + blur_popups: bool, + animation: Option, + #[serde(default)] + no_anim: bool, +} + +/// `BTreeMap` so iteration order (used when rendering the snippet) is +/// deterministic without a separate sort step. +type LayerRulesFile = BTreeMap; + +/// Read and parse `~/.config/hypr/layerrules.json`. +/// +/// `None` means the file doesn't exist (not an error — `bread-theme +/// layerrules` just hasn't been run yet). `Some(Err(..))` means it exists +/// but couldn't be read or parsed; the message is meant to be shown to the +/// user as-is. +fn read_layerrules_json(hypr_dir: &Path) -> Option> { + let path = hypr_dir.join("layerrules.json"); + if !path.exists() { + return None; + } + match fs::read_to_string(&path) { + Err(e) => Some(Err(format!("could not read {}: {e}", path.display()))), + Ok(raw) => match serde_json::from_str::(&raw) { + Ok(v) => Some(Ok(v)), + Err(e) => Some(Err(format!("could not parse {} as JSON: {e}", path.display()))), + }, + } +} + +/// Render `rules` as hyprlang `.conf` `layerrule` lines — the manual +/// snippet printed for a `hyprland.conf`-only or unrecognized layout. Same +/// five fields as `bread.lua`, nothing else. +fn render_conf_snippet(rules: &LayerRulesFile) -> String { + let mut out = String::new(); + for (ns, r) in rules { + let pattern = format!("^{ns}$"); + if r.no_anim { + out.push_str(&format!("layerrule = noanim,{pattern}\n")); + } + if r.blur { + out.push_str(&format!("layerrule = blur,{pattern}\n")); + } + if let Some(alpha) = r.ignore_alpha { + out.push_str(&format!("layerrule = ignorealpha {alpha},{pattern}\n")); + } + if r.blur_popups { + out.push_str(&format!("layerrule = blurpopups,{pattern}\n")); + } + if let Some(animation) = &r.animation { + out.push_str(&format!("layerrule = animation {animation},{pattern}\n")); + } + } + out +} + +// --------------------------------------------------------------------------- +// Consent +// --------------------------------------------------------------------------- + +enum Consent { + Yes, + No, + /// No TTY on stdin and `--yes` wasn't given — per spec, this must never + /// write. + NonInteractive, +} + +fn ask_consent(yes: bool, prompt: &str) -> Result { + if yes { + return Ok(Consent::Yes); + } + if !io::stdin().is_terminal() { + return Ok(Consent::NonInteractive); + } + print!("{prompt} [y/N] "); + io::stdout().flush()?; + let mut line = String::new(); + io::stdin().read_line(&mut line)?; + if line.trim().eq_ignore_ascii_case("y") { + Ok(Consent::Yes) + } else { + Ok(Consent::No) + } +} + +// --------------------------------------------------------------------------- +// Backups +// --------------------------------------------------------------------------- + +/// A timestamped backup path alongside `original`, disambiguated with a +/// numeric suffix in the unlikely case two runs land in the same second. +fn unique_backup_path(original: &Path) -> PathBuf { + let stamp = chrono::Local::now().format("%Y%m%d-%H%M%S"); + let base = format!("{}.bak.{stamp}", original.display()); + let mut candidate = PathBuf::from(&base); + let mut n = 1u32; + while candidate.exists() { + candidate = PathBuf::from(format!("{base}.{n}")); + n += 1; + } + candidate +} + +// --------------------------------------------------------------------------- +// Diff / message rendering +// --------------------------------------------------------------------------- + +fn print_proposed_change(path: &Path, original: &str, new_content: &str, change: &ChangeKind) { + println!("Proposed change to {}:", path.display()); + println!(); + match change { + ChangeKind::Unchanged => { + println!(" (already installed — no change needed)"); + } + ChangeKind::Appended => { + let (start, end) = + find_managed_block(new_content).expect("block was just appended"); + let new_lines: Vec<&str> = new_content.lines().collect(); + println!(" appended at end of file (new lines {}-{}):", start + 1, end + 1); + println!(); + for (i, line) in new_lines[start..=end].iter().enumerate() { + println!(" + {:>4} {}", start + 1 + i, line); + } + } + ChangeKind::Replaced { start, end } => { + let old_lines: Vec<&str> = original.lines().collect(); + println!( + " existing bread block at lines {}-{} will be updated:", + start + 1, + end + 1 + ); + println!(); + for (i, line) in old_lines[*start..=*end].iter().enumerate() { + println!(" - {:>4} {}", start + 1 + i, line); + } + let (nstart, nend) = + find_managed_block(new_content).expect("block was just replaced"); + let new_lines: Vec<&str> = new_content.lines().collect(); + for (i, line) in new_lines[nstart..=nend].iter().enumerate() { + println!(" + {:>4} {}", nstart + 1 + i, line); + } + } + } + println!(); +} + +fn print_bos_conflict(path: &Path) { + println!( + "bread init: found an existing breadbar layer rule in {} — refusing to install.", + path.display() + ); + println!( + "Two owners writing the same Hyprland layer rules is how they end up fighting each \ + other on reload. That file already provides this behavior (BOS's own dotfiles, or \ + something hand-authored) — edit it directly if you want to change the rules, or \ + remove it first if you'd rather have `bread init` manage this from now on." + ); +} + +enum ManualReason<'a> { + ConfOnly(&'a Path), + Unrecognized, + LuaUnreadable(&'a Path), +} + +fn print_manual_snippet(hypr_dir: &Path, reason: ManualReason) { + match reason { + ManualReason::ConfOnly(path) => { + println!( + "bread init: found {} but no hyprland.lua — bread only auto-edits the Lua-based \ + Hyprland config, never .conf (they're different, mutually exclusive config \ + entry points), so nothing was written.", + path.display() + ); + } + ManualReason::Unrecognized => { + println!( + "bread init: no recognized Hyprland config found at {} (looked for \ + hyprland.lua, hyprland.conf) — nothing was written.", + hypr_dir.display() + ); + } + ManualReason::LuaUnreadable(path) => { + println!( + "bread init: {} exists but could not be read as text — bread only auto-edits a \ + config it can safely parse, so nothing was written.", + path.display() + ); + } + } + println!(); + + match reason { + ManualReason::ConfOnly(_) | ManualReason::Unrecognized => { + match read_layerrules_json(hypr_dir) { + Some(Ok(rules)) if !rules.is_empty() => { + println!("Paste this into hyprland.conf to get the same blur/opacity behavior:"); + println!(); + print!("{}", render_conf_snippet(&rules)); + } + Some(Ok(_)) => { + println!( + "~/.config/hypr/layerrules.json exists but is empty — nothing to paste \ + yet. Set a theme's [compositor] table and run `bread-theme layerrules`." + ); + } + Some(Err(e)) => { + println!( + "~/.config/hypr/layerrules.json exists but {e} — fix it and re-run \ + `bread init`, or run `bread-theme layerrules` to regenerate it." + ); + } + None => { + println!( + "Run `bread-theme layerrules` first to generate \ + ~/.config/hypr/layerrules.json from your active theme, then re-run \ + `bread init` for the exact snippet." + ); + } + } + } + ManualReason::LuaUnreadable(_) => { + println!("If this really is a Lua config, add this near the end of the file:"); + println!(); + println!("{}", managed_block_text()); + } + } +} + +// --------------------------------------------------------------------------- +// Install / undo +// --------------------------------------------------------------------------- + +fn write_bread_lua(hypr_dir: &Path) -> Result { + fs::create_dir_all(hypr_dir) + .with_context(|| format!("failed to create {}", hypr_dir.display()))?; + let path = hypr_dir.join("bread.lua"); + fs::write(&path, BREAD_LUA).with_context(|| format!("failed to write {}", path.display()))?; + Ok(path) +} + +fn run_install(hypr_dir: &Path, dry_run: bool, yes: bool) -> Result<()> { + if let Some(existing) = find_breadbar_conflict(hypr_dir)? { + print_bos_conflict(&existing); + return Ok(()); + } + + let lua_path = match detect_layout(hypr_dir) { + ConfigLayout::Lua(path) => path, + ConfigLayout::ConfOnly(path) => { + print_manual_snippet(hypr_dir, ManualReason::ConfOnly(&path)); + return Ok(()); + } + ConfigLayout::Unrecognized => { + let candidate = hypr_dir.join("hyprland.lua"); + if candidate.exists() { + print_manual_snippet(hypr_dir, ManualReason::LuaUnreadable(&candidate)); + } else { + print_manual_snippet(hypr_dir, ManualReason::Unrecognized); + } + return Ok(()); + } + }; + + let original = fs::read_to_string(&lua_path) + .with_context(|| format!("failed to read {}", lua_path.display()))?; + let (new_content, change) = plan_install(&original); + + if change == ChangeKind::Unchanged { + println!( + "bread init: compositor integration already installed in {}.", + lua_path.display() + ); + if dry_run { + println!("(dry run — bread.lua left untouched)"); + return Ok(()); + } + let bread_lua_path = write_bread_lua(hypr_dir)?; + println!("bread.lua refreshed at {}", bread_lua_path.display()); + return Ok(()); + } + + print_proposed_change(&lua_path, &original, &new_content, &change); + + if dry_run { + println!("(dry run — no changes made)"); + return Ok(()); + } + + match ask_consent(yes, "Apply this change?")? { + Consent::No => { + println!("aborted — no changes made."); + return Ok(()); + } + Consent::NonInteractive => { + println!( + "non-interactive session — re-run with --yes to apply this change, or paste \ + the snippet above yourself." + ); + return Ok(()); + } + Consent::Yes => {} + } + + let bread_lua_path = write_bread_lua(hypr_dir)?; + let backup = unique_backup_path(&lua_path); + fs::copy(&lua_path, &backup).with_context(|| { + format!("failed to back up {} to {}", lua_path.display(), backup.display()) + })?; + fs::write(&lua_path, &new_content) + .with_context(|| format!("failed to write {}", lua_path.display()))?; + + println!("bread init: installed."); + println!(" wrote {}", bread_lua_path.display()); + println!(" edited {}", lua_path.display()); + println!(" backup {}", backup.display()); + Ok(()) +} + +fn run_undo(hypr_dir: &Path, dry_run: bool, yes: bool) -> Result<()> { + let lua_path = match detect_layout(hypr_dir) { + ConfigLayout::Lua(path) => path, + _ => { + println!( + "bread init --undo: no bread-managed hyprland.lua found at {} — nothing to undo.", + hypr_dir.display() + ); + return Ok(()); + } + }; + + let original = fs::read_to_string(&lua_path) + .with_context(|| format!("failed to read {}", lua_path.display()))?; + + let Some((start, end)) = find_managed_block(&original) else { + println!( + "bread init --undo: no bread-managed block found in {} — nothing to undo.", + lua_path.display() + ); + return Ok(()); + }; + + let new_content = plan_undo(&original).expect("block located just above"); + + println!("Proposed change to {}:", lua_path.display()); + println!(); + println!(" bread block at lines {}-{} will be removed:", start + 1, end + 1); + println!(); + let old_lines: Vec<&str> = original.lines().collect(); + for (i, line) in old_lines[start..=end].iter().enumerate() { + println!(" - {:>4} {}", start + 1 + i, line); + } + println!(); + + if dry_run { + println!("(dry run — no changes made)"); + return Ok(()); + } + + match ask_consent(yes, "Remove this block?")? { + Consent::No => { + println!("aborted — no changes made."); + return Ok(()); + } + Consent::NonInteractive => { + println!("non-interactive session — re-run with --yes to apply this change."); + return Ok(()); + } + Consent::Yes => {} + } + + let backup = unique_backup_path(&lua_path); + fs::copy(&lua_path, &backup).with_context(|| { + format!("failed to back up {} to {}", lua_path.display(), backup.display()) + })?; + fs::write(&lua_path, &new_content) + .with_context(|| format!("failed to write {}", lua_path.display()))?; + + println!("bread init --undo: removed."); + println!(" edited {}", lua_path.display()); + println!(" backup {}", backup.display()); + + let bread_lua = hypr_dir.join("bread.lua"); + if bread_lua.exists() { + println!( + " note {} was left in place (harmless — nothing sources it anymore); delete \ + it yourself if you want it gone", + bread_lua.display() + ); + } + Ok(()) +} + +// --------------------------------------------------------------------------- +// Public entry points +// --------------------------------------------------------------------------- + +/// `~/.config/hypr` — Hyprland always reads its config from here; unlike +/// most XDG apps this is not `$XDG_CONFIG_HOME`-relative in practice, so +/// this resolves `$HOME` directly rather than going through +/// `dirs::config_dir()`. +pub fn hypr_dir() -> PathBuf { + if let Some(home) = dirs::home_dir() { + return home.join(".config").join("hypr"); + } + if let Ok(home) = std::env::var("HOME") { + return PathBuf::from(home).join(".config").join("hypr"); + } + PathBuf::from(".config/hypr") +} + +/// `bread init` entry point. +pub fn run(dry_run: bool, yes: bool, undo: bool) -> Result<()> { + let dir = hypr_dir(); + if undo { + run_undo(&dir, dry_run, yes) + } else { + run_install(&dir, dry_run, yes) + } +} + +/// Status lines for `bread doctor`'s compositor section. Pure +/// filesystem/string inspection — no daemon round trip, so this works even +/// when breadd isn't running, and it never installs anything itself. +pub fn doctor_report(hypr_dir: &Path) -> Vec { + let mut lines = Vec::new(); + + if let Ok(Some(existing)) = find_breadbar_conflict(hypr_dir) { + lines.push(format!( + " compositor ✓ layer rules provided by {} (not bread-managed)", + existing.display() + )); + return lines; + } + + match detect_layout(hypr_dir) { + ConfigLayout::Lua(path) => { + let content = fs::read_to_string(&path).unwrap_or_default(); + let installed = find_managed_block(&content).is_some(); + let bread_lua_exists = hypr_dir.join("bread.lua").is_file(); + match (installed, bread_lua_exists) { + (true, true) => lines.push( + " compositor ✓ installed (bread.lua sourced from hyprland.lua)".to_string(), + ), + (true, false) => lines.push( + " compositor ⚠ hyprland.lua sources bread.lua, but bread.lua is missing \ + — run `bread init` to regenerate it" + .to_string(), + ), + (false, _) => lines.push( + " compositor ✗ not installed — run `bread init` to enable layer-rule \ + blur/opacity for breadbar" + .to_string(), + ), + } + } + ConfigLayout::ConfOnly(_) => { + lines.push( + " compositor ✗ not installed (hyprland.conf detected, not the Lua config) \ + — run `bread init` for the layerrule snippet to paste in by hand" + .to_string(), + ); + } + ConfigLayout::Unrecognized => { + lines.push( + " compositor ✗ not installed (no recognized Hyprland config found) — run \ + `bread init`" + .to_string(), + ); + } + } + + let layerrules_json = hypr_dir.join("layerrules.json"); + lines.push(format!( + " layerrules {}", + if layerrules_json.is_file() { + format!("present ({})", layerrules_json.display()) + } else { + "missing — run `bread-theme layerrules`".to_string() + } + )); + + lines +} + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + use tempfile::TempDir; + + // -- managed block: find / plan_install / plan_undo ------------------- + + #[test] + fn find_managed_block_locates_exact_markers() { + let content = "before\n-- >>> bread managed >>>\nfoo\n-- <<< bread managed <<<\nafter\n"; + assert_eq!(find_managed_block(content), Some((1, 3))); + } + + #[test] + fn find_managed_block_none_when_absent() { + assert_eq!(find_managed_block("nothing here\n"), None); + } + + #[test] + fn find_managed_block_requires_exact_trimmed_match() { + let content = "-- this mentions >>> bread managed >>> in passing\n"; + assert_eq!(find_managed_block(content), None); + } + + #[test] + fn plan_install_appends_when_absent() { + let content = "local x = 1\n"; + let (new_content, change) = plan_install(content); + assert_eq!(change, ChangeKind::Appended); + assert!(new_content.starts_with("local x = 1\n\n-- >>> bread managed >>>")); + assert!(new_content.trim_end().ends_with(MARKER_END)); + } + + #[test] + fn plan_install_is_idempotent() { + let content = "local x = 1\n"; + let (once, _) = plan_install(content); + let (twice, change) = plan_install(&once); + assert_eq!(change, ChangeKind::Unchanged); + assert_eq!(once, twice); + // Running install a second (or third) time must never duplicate + // the block. + assert_eq!(twice.matches(MARKER_BEGIN).count(), 1); + assert_eq!(twice.matches(MARKER_END).count(), 1); + } + + #[test] + fn plan_install_replaces_stale_block_in_place() { + let content = format!( + "local x = 1\n\n{MARKER_BEGIN}\n-- an old/different bread line\n{MARKER_END}\n" + ); + let (new_content, change) = plan_install(&content); + assert!(matches!(change, ChangeKind::Replaced { .. })); + assert_eq!(new_content.matches(MARKER_BEGIN).count(), 1); + assert!(new_content.contains(managed_block_body())); + assert!(!new_content.contains("an old/different bread line")); + } + + #[test] + fn plan_undo_removes_block_and_separator() { + let content = "local x = 1\n\n-- >>> bread managed >>>\nfoo\n-- <<< bread managed <<<\n"; + let undone = plan_undo(content).unwrap(); + assert_eq!(undone, "local x = 1\n"); + assert!(!undone.contains(MARKER_BEGIN)); + } + + #[test] + fn plan_undo_none_when_no_block() { + assert_eq!(plan_undo("local x = 1\n"), None); + } + + #[test] + fn install_then_undo_round_trips_to_appendable_state() { + let original = "local x = 1\n"; + let (installed, _) = plan_install(original); + let undone = plan_undo(&installed).unwrap(); + // Not required to be byte-identical to the original (only one + // blank-line convention is guaranteed to be cleaned up), but the + // result must contain no trace of the managed block and must be + // fresh ground for another install. + assert!(!undone.contains(MARKER_BEGIN)); + assert!(!undone.contains(MARKER_END)); + let (_, change) = plan_install(&undone); + assert_eq!(change, ChangeKind::Appended); + } + + // -- config layout detection ------------------------------------------- + + #[test] + fn detect_layout_prefers_lua_when_present() { + let dir = TempDir::new().unwrap(); + fs::write(dir.path().join("hyprland.lua"), "-- lua config\n").unwrap(); + fs::write(dir.path().join("hyprland.conf"), "monitor=,preferred,auto,1\n").unwrap(); + match detect_layout(dir.path()) { + ConfigLayout::Lua(p) => assert_eq!(p, dir.path().join("hyprland.lua")), + other => panic!("expected Lua layout, got {other:?}"), + } + } + + #[test] + fn detect_layout_falls_back_to_conf_only() { + let dir = TempDir::new().unwrap(); + fs::write(dir.path().join("hyprland.conf"), "monitor=,preferred,auto,1\n").unwrap(); + match detect_layout(dir.path()) { + ConfigLayout::ConfOnly(p) => assert_eq!(p, dir.path().join("hyprland.conf")), + other => panic!("expected ConfOnly layout, got {other:?}"), + } + } + + #[test] + fn detect_layout_unrecognized_when_neither_present() { + let dir = TempDir::new().unwrap(); + assert_eq!(detect_layout(dir.path()), ConfigLayout::Unrecognized); + } + + #[test] + fn detect_layout_unrecognized_when_lua_unreadable_binary() { + let dir = TempDir::new().unwrap(); + // Invalid UTF-8 bytes — fs::read_to_string will fail on this. + fs::write(dir.path().join("hyprland.lua"), [0xff, 0xfe, 0x00, 0xff]).unwrap(); + assert_eq!(detect_layout(dir.path()), ConfigLayout::Unrecognized); + } + + // -- BOS / existing-owner conflict detection --------------------------- + + #[test] + fn conflict_detected_in_nested_rules_file() { + let dir = TempDir::new().unwrap(); + let scripts_ui = dir.path().join("scripts").join("ui"); + fs::create_dir_all(&scripts_ui).unwrap(); + fs::write( + scripts_ui.join("rules.lua"), + "hl.layer_rule({ name = \"breadbar-island\", match = { namespace = \"^breadbar$\" }, blur = true })\n", + ) + .unwrap(); + let found = find_breadbar_conflict(dir.path()).unwrap(); + assert_eq!(found, Some(scripts_ui.join("rules.lua"))); + } + + #[test] + fn conflict_detected_in_conf_style_layerrule() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("hyprland.conf"), + "layerrule = blur,^(breadbar)$\n", + ) + .unwrap(); + let found = find_breadbar_conflict(dir.path()).unwrap(); + assert_eq!(found, Some(dir.path().join("hyprland.conf"))); + } + + #[test] + fn no_conflict_on_unrelated_content() { + let dir = TempDir::new().unwrap(); + fs::write(dir.path().join("hyprland.lua"), "hl.window_rule({ class = \"kitty\" })\n") + .unwrap(); + assert_eq!(find_breadbar_conflict(dir.path()).unwrap(), None); + } + + #[test] + fn own_generated_bread_lua_is_never_a_conflict() { + let dir = TempDir::new().unwrap(); + fs::write(dir.path().join("bread.lua"), BREAD_LUA).unwrap(); + // bread.lua emits hl.layer_rule({ name = ns, ... }) for a namespace + // that could well be literally "breadbar" once layerrules.json has + // that key — the scan must still skip bread.lua by filename. + assert_eq!(find_breadbar_conflict(dir.path()).unwrap(), None); + } + + #[test] + fn conflict_scan_ignores_non_lua_conf_files() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("notes.txt"), + "hl.layer_rule breadbar reminder to self\n", + ) + .unwrap(); + assert_eq!(find_breadbar_conflict(dir.path()).unwrap(), None); + } + + // -- layerrules.json reading / conf snippet rendering ------------------- + + #[test] + fn read_layerrules_json_missing_file_is_none() { + let dir = TempDir::new().unwrap(); + assert!(read_layerrules_json(dir.path()).is_none()); + } + + #[test] + fn read_layerrules_json_malformed_is_reported_not_panicking() { + let dir = TempDir::new().unwrap(); + fs::write(dir.path().join("layerrules.json"), "{ this is not json ").unwrap(); + let result = read_layerrules_json(dir.path()); + assert!(matches!(result, Some(Err(_)))); + } + + #[test] + fn read_layerrules_json_parses_valid_file() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("layerrules.json"), + r#"{"breadbar":{"blur":true,"ignore_alpha":0.2,"blur_popups":true,"animation":"slide top","no_anim":false}}"#, + ) + .unwrap(); + let result = read_layerrules_json(dir.path()).unwrap().unwrap(); + assert_eq!(result.len(), 1); + assert!(result["breadbar"].blur); + assert_eq!(result["breadbar"].ignore_alpha, Some(0.2)); + } + + #[test] + fn render_conf_snippet_emits_expected_lines() { + let mut rules = LayerRulesFile::new(); + rules.insert( + "breadbar".to_string(), + LayerRuleEntry { + blur: true, + ignore_alpha: Some(0.2), + blur_popups: true, + animation: Some("slide top".to_string()), + no_anim: false, + }, + ); + let snippet = render_conf_snippet(&rules); + assert!(snippet.contains("layerrule = blur,^breadbar$")); + assert!(snippet.contains("layerrule = ignorealpha 0.2,^breadbar$")); + assert!(snippet.contains("layerrule = blurpopups,^breadbar$")); + assert!(snippet.contains("layerrule = animation slide top,^breadbar$")); + assert!(!snippet.contains("noanim")); + } + + #[test] + fn render_conf_snippet_no_anim_only() { + let mut rules = LayerRulesFile::new(); + rules.insert( + "breadbar-dismiss".to_string(), + LayerRuleEntry { + no_anim: true, + ..Default::default() + }, + ); + let snippet = render_conf_snippet(&rules); + assert_eq!(snippet, "layerrule = noanim,^breadbar-dismiss$\n"); + } + + // -- doctor report -------------------------------------------------- + + #[test] + fn doctor_report_reports_not_installed() { + let dir = TempDir::new().unwrap(); + fs::write(dir.path().join("hyprland.lua"), "-- empty\n").unwrap(); + let lines = doctor_report(dir.path()); + assert!(lines.iter().any(|l| l.contains("not installed"))); + } + + #[test] + fn doctor_report_reports_installed() { + let dir = TempDir::new().unwrap(); + let (content, _) = plan_install("-- empty\n"); + fs::write(dir.path().join("hyprland.lua"), content).unwrap(); + fs::write(dir.path().join("bread.lua"), BREAD_LUA).unwrap(); + let lines = doctor_report(dir.path()); + assert!(lines.iter().any(|l| l.contains("✓ installed"))); + } + + #[test] + fn doctor_report_reports_bos_conflict_distinctly() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("hyprland.lua"), + "hl.layer_rule({ match = { namespace = \"^breadbar$\" } })\n", + ) + .unwrap(); + let lines = doctor_report(dir.path()); + assert!(lines.iter().any(|l| l.contains("not bread-managed"))); + } + + // -- backup path uniqueness ----------------------------------------- + + #[test] + fn unique_backup_path_disambiguates_collisions() { + let dir = TempDir::new().unwrap(); + let original = dir.path().join("hyprland.lua"); + fs::write(&original, "x").unwrap(); + let first = unique_backup_path(&original); + fs::write(&first, "backup 1").unwrap(); + let second = unique_backup_path(&original); + assert_ne!(first, second); + } +} diff --git a/bread-cli/src/main.rs b/bread-cli/src/main.rs index 843e758..67e91fe 100644 --- a/bread-cli/src/main.rs +++ b/bread-cli/src/main.rs @@ -1,3 +1,4 @@ +mod init; mod hooks_git; mod hooks_shell; mod modules_mgmt; @@ -6,6 +7,7 @@ use anyhow::Result; use clap::{Parser, Subcommand}; use notify::{RecommendedWatcher, RecursiveMode, Watcher}; use serde_json::{json, Value}; +use std::collections::HashMap; use std::env; use std::io::{self, Write as IoWrite}; use std::path::{Path, PathBuf}; @@ -54,6 +56,12 @@ enum Commands { /// Replay events from the last N seconds #[arg(long)] since: Option, + /// Render events as a causality tree via `caused_by` instead of a + /// flat stream (events emitted from inside a `bread.emit()` call + /// made by another event's Lua handler are nested under it). + /// Overrides `--json` — tree rendering always uses the formatted view. + #[arg(long)] + tree: bool, }, /// Manage installed Lua modules Modules { @@ -92,6 +100,22 @@ enum Commands { #[arg(long)] json: bool, }, + /// Install bread's Hyprland compositor layer-rule integration + /// (breadbar/breadbox blur, ignore_alpha, animation) into + /// ~/.config/hypr/hyprland.lua, with consent, a backup, and full undo. + /// See bread-cli/src/init.rs for the design rationale. + Init { + /// Print the proposed diff and change nothing + #[arg(long)] + dry_run: bool, + /// Skip the confirmation prompt (for scripted/image builds) + #[arg(long)] + yes: bool, + /// Remove the previously installed marked block instead of + /// installing it + #[arg(long)] + undo: bool, + }, } #[derive(Subcommand, Debug)] @@ -125,6 +149,9 @@ enum ModulesCommand { List, /// Show full manifest details for a module Info { name: String }, + /// Statically scan an installed module's Lua source and suggest a + /// `[[permissions]]` block for its `bread.module.toml` manifest + Audit { name: String }, } #[tokio::main] @@ -158,8 +185,9 @@ async fn main() -> Result<()> { json, fields, since, + tree, } => { - stream_events(&socket, pattern, json, fields, since).await?; + stream_events(&socket, pattern, json, fields, since, tree).await?; } Commands::Modules { subcommand } => { handle_modules_cmd(subcommand, &socket).await?; @@ -213,6 +241,9 @@ async fn main() -> Result<()> { print_doctor(&socket).await?; } } + Commands::Init { dry_run, yes, undo } => { + init::run(dry_run, yes, undo)?; + } } Ok(()) @@ -303,6 +334,55 @@ async fn handle_modules_cmd(cmd: ModulesCommand, socket: &Path) -> Result<()> { println!("source: {}", m.source); println!("installed_at: {}", m.installed_at); println!("status: {}", status); + match &m.permissions { + None => println!( + "permissions: (none declared — full, ungated bread.* access; see 'bread doctor')" + ), + Some(perms) if perms.is_empty() => { + println!("permissions: (declared empty — baseline access only)") + } + Some(perms) => { + println!("permissions:"); + for p in perms { + let mut line = format!(" - {:?}", p.kind); + if let Some(path) = &p.path { + line.push_str(&format!(" path={path}")); + } + if let Some(bin) = &p.bin { + line.push_str(&format!(" bin={bin}")); + } + println!("{line}"); + } + } + } + } + + ModulesCommand::Audit { name } => { + let module_dir = mods_dir.join(&name); + if !module_dir.exists() { + eprintln!("bread: module '{}' is not installed", name); + std::process::exit(1); + } + let suggested = modules_mgmt::audit_module(&module_dir)?; + if suggested.is_empty() { + println!( + "bread: no capability-gated bread.* calls found in '{}' — \ + it appears to only use baseline APIs (events, timers, json, \ + logging). Declaring `permissions = []` in bread.module.toml \ + documents that intentionally and avoids the 'no permissions \ + declared' warning from `bread doctor`.", + name + ); + return Ok(()); + } + println!( + "bread: suggested permissions for '{}' (best-effort static scan — \ + review before pasting into bread.module.toml; false positives \ + are possible, missing an actually-needed permission should be rare \ + for direct bread.exec()-style call sites):\n", + name + ); + print!("{}", modules_mgmt::render_permissions_toml(&suggested)?); } } Ok(()) @@ -378,7 +458,13 @@ async fn stream_events( raw_json: bool, fields: Option, since: Option, + tree: bool, ) -> Result<()> { + // Tree rendering needs `id`/`caused_by` visible in a consistent shape, + // so it always uses the formatted view — a live-streaming-friendly + // indent-as-you-go tree rather than buffering the whole stream. + let mut causality = CausalityTracker::default(); + if let Some(seconds) = since { let replay = send_request( socket, @@ -388,7 +474,9 @@ async fn stream_events( .await?; if let Some(list) = replay.as_array() { for item in list { - if raw_json { + if tree { + causality.print(item); + } else if raw_json { println!("{}", serde_json::to_string_pretty(item)?); } else { print_event(item, fields.as_deref()); @@ -426,7 +514,9 @@ async fn stream_events( while let Some(line) = lines.next_line().await? { let value: Value = serde_json::from_str(&line)?; - if raw_json { + if tree { + causality.print(&value); + } else if raw_json { println!("{}", serde_json::to_string_pretty(&value)?); } else { print_event(&value, fields.as_deref()); @@ -436,6 +526,63 @@ async fn stream_events( Ok(()) } +/// Tracks `id` -> `caused_by` for events seen so far in this stream/replay +/// batch, so each new event can be indented under its parent as it arrives +/// — no buffering, no waiting for the stream to end. An event whose parent +/// hasn't been seen yet (e.g. the parent predates a replay window, or the +/// causing event is filtered out by the subscription pattern) is rendered +/// as its own root rather than blocking on a parent that may never show up. +#[derive(Default)] +struct CausalityTracker { + parents: HashMap>, +} + +impl CausalityTracker { + /// Depth = number of ancestors reachable by following `caused_by`. + /// Guards against cycles/self-loops (shouldn't happen, but a rendering + /// bug here must never hang the CLI) with both a seen-set and a hard cap. + fn depth(&self, id: &str) -> usize { + let mut depth = 0; + let mut current = id.to_string(); + let mut seen = std::collections::HashSet::new(); + while let Some(Some(parent)) = self.parents.get(¤t) { + if depth >= 64 || !seen.insert(current.clone()) { + break; + } + depth += 1; + current = parent.clone(); + } + depth + } + + fn print(&mut self, event: &Value) { + let id = event.get("id").and_then(Value::as_str).map(str::to_string); + let caused_by = event + .get("caused_by") + .and_then(Value::as_str) + .map(str::to_string); + + let depth = if let Some(id) = &id { + self.parents.insert(id.clone(), caused_by.clone()); + self.depth(id) + } else { + 0 + }; + + let ts = event.get("timestamp").and_then(Value::as_u64).unwrap_or(0); + let event_name = event.get("event").and_then(Value::as_str).unwrap_or("?"); + let source = event.get("source").and_then(Value::as_str).unwrap_or("?"); + let time = format_timestamp(ts); + let indent = " ".repeat(depth); + let connector = if depth > 0 { "\u{2514}\u{2500} " } else { "" }; + let id_display = id.as_deref().unwrap_or("?"); + println!("{indent}{connector}{time} {event_name} source={source} id={id_display}"); + if let Some(data) = event.get("data") { + println!("{indent} data: {data}"); + } + } +} + fn print_json(value: &Value) -> Result<()> { println!("{}", serde_json::to_string_pretty(value)?); Ok(()) @@ -564,6 +711,7 @@ async fn print_doctor(socket: &Path) -> Result<()> { println!(); println!(" start the daemon: systemctl --user start breadd"); println!(" view logs: journalctl --user -u breadd -f"); + print_compositor_doctor_section(); return Ok(()); } @@ -602,14 +750,35 @@ fn render_doctor(health: &Value) { if let Some(modules) = health.get("modules").and_then(Value::as_array) { println!(); println!("modules"); + let mut ungated_count = 0; for module in modules { let name = module.get("name").and_then(Value::as_str).unwrap_or("?"); let status = module.get("status").and_then(Value::as_str).unwrap_or("?"); let error = module.get("last_error").and_then(Value::as_str); + let ungated = module + .get("ungated") + .and_then(Value::as_bool) + .unwrap_or(false); println!(" {:30} {}", name, status); if let Some(error) = error { println!(" └ {error}"); } + if ungated { + ungated_count += 1; + println!( + " └ ⚠ running with full, ungated access — no permissions \ + manifest declared (add `[[permissions]]` to its \ + bread.module.toml, or run `bread modules audit {name}` \ + for a suggested block)" + ); + } + } + if ungated_count > 0 { + println!(); + println!( + " {ungated_count} module(s) running with full, ungated bread.* access — \ + see above" + ); } } @@ -627,6 +796,20 @@ fn render_doctor(health: &Value) { } } } + + print_compositor_doctor_section(); +} + +/// Compositor integration status — pure filesystem check, independent of +/// the daemon, so it prints the same whether breadd is up or not. Reports +/// only; `bread doctor` never installs anything (that's `bread init`'s +/// job). +fn print_compositor_doctor_section() { + println!(); + println!("compositor"); + for line in init::doctor_report(&init::hypr_dir()) { + println!("{line}"); + } } fn config_directory() -> PathBuf { diff --git a/bread-cli/src/modules_mgmt.rs b/bread-cli/src/modules_mgmt.rs index f0b92a9..2376093 100644 --- a/bread-cli/src/modules_mgmt.rs +++ b/bread-cli/src/modules_mgmt.rs @@ -1,4 +1,5 @@ use anyhow::{bail, Context, Result}; +use bread_shared::{ModulePermission, PermissionKind}; use chrono::Utc; use serde::{Deserialize, Serialize}; use std::fs; @@ -13,6 +14,16 @@ pub struct ModuleManifest { pub author: String, pub source: String, pub installed_at: String, + /// Declared `[[permissions]]` entries. `None` means the manifest has no + /// `permissions` key at all — either because it predates this field (an + /// already-installed module) or because the author simply didn't add + /// one. `breadd` treats that the same way: full, ungated `bread.*` + /// access, same as today, but `bread doctor` flags it so the gap is + /// visible instead of silently permanent. An explicit `permissions = []` + /// is different: it's a deliberate "baseline only" declaration and does + /// *not* get flagged. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub permissions: Option>, } /// Resolve a module source string to a local directory path. @@ -227,3 +238,235 @@ fn copy_dir(src: &Path, dst: &Path) -> Result<()> { } Ok(()) } + +// --------------------------------------------------------------------------- +// `bread modules audit` — best-effort static permission suggestion +// --------------------------------------------------------------------------- +// +// This is deliberately a text scan, not a Lua parser. `breadd`'s own +// scoping mechanism only cares whether a permission was declared at all +// (see `Documentation.md`'s "Capability-scoped modules" section), so the +// bar here is the same one the report set: false positives (suggesting a +// permission a module doesn't strictly need) are fine, false negatives on +// a plain `bread.exec("...")`-style call site should be rare. It is not +// expected to follow dynamic dispatch, string-built calls, or anything a +// real parser would be needed for. + +/// Statically scan every `.lua` file in `module_dir` (recursively — a +/// module may `require()` sibling files from its own directory) for +/// `bread.*` call-site patterns and return a suggested, deduplicated +/// permission list for the user to review. +pub fn audit_module(module_dir: &Path) -> Result> { + let mut found: std::collections::BTreeMap = + std::collections::BTreeMap::new(); + let mut files = Vec::new(); + collect_lua_files(module_dir, &mut files)?; + for file in &files { + if let Ok(src) = fs::read_to_string(file) { + scan_lua_source(&src, &mut found); + } + } + Ok(found.into_values().collect()) +} + +/// Render a suggested permission list as a pastable `[[permissions]]` TOML +/// block, matching exactly what `bread.module.toml` expects. +pub fn render_permissions_toml(perms: &[ModulePermission]) -> Result { + #[derive(Serialize)] + struct PermissionsBlock<'a> { + permissions: &'a [ModulePermission], + } + toml::to_string_pretty(&PermissionsBlock { permissions: perms }) + .context("failed to render suggested permissions as TOML") +} + +fn collect_lua_files(dir: &Path, out: &mut Vec) -> Result<()> { + if !dir.exists() { + return Ok(()); + } + for entry in fs::read_dir(dir)? { + let entry = entry?; + let path = entry.path(); + if path.is_dir() { + collect_lua_files(&path, out)?; + } else if path.extension().and_then(|e| e.to_str()) == Some("lua") { + out.push(path); + } + } + Ok(()) +} + +/// Scan one file's source for `bread.[.]` occurrences and +/// classify each into a permission, accumulating into `found` (keyed by +/// kind, so repeated call sites for the same permission collapse to one +/// suggestion — first-seen scoping hint wins). +fn scan_lua_source(src: &str, found: &mut std::collections::BTreeMap) { + const NEEDLE: &str = "bread."; + let mut cursor = 0usize; + while let Some(rel) = src[cursor..].find(NEEDLE) { + let ident_start = cursor + rel + NEEDLE.len(); + cursor = ident_start; + let rest = &src[ident_start..]; + let ident_len = rest + .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '.')) + .unwrap_or(rest.len()); + let ident = rest[..ident_len].trim_end_matches('.'); + if ident.is_empty() { + continue; + } + classify_call_site(ident, &rest[ident_len..], found); + } +} + +fn classify_call_site( + ident: &str, + tail: &str, + found: &mut std::collections::BTreeMap, +) { + let (kind, bin, path): (PermissionKind, Option, Option) = match ident { + "fs.write" => (PermissionKind::FsWrite, None, extract_first_string_arg(tail)), + "fs.read" | "fs.exists" | "fs.readlink" | "fs.expand" => { + (PermissionKind::FsRead, None, extract_first_string_arg(tail)) + } + "exec" | "exec_capture" => { + let hint = extract_first_string_arg(tail) + .and_then(|s| s.split_whitespace().next().map(str::to_string)); + (PermissionKind::Exec, hint, None) + } + "notify" => (PermissionKind::Notify, None, None), + "profile.activate" => (PermissionKind::ProfileActivate, None, None), + "state.watch" => (PermissionKind::StateWatch, None, extract_first_string_arg(tail)), + other if other == "state" || other.starts_with("state.") => { + (PermissionKind::StateRead, None, extract_first_string_arg(tail)) + } + other if other == "machine" || other.starts_with("machine.") => { + (PermissionKind::Machine, None, None) + } + other if other == "hyprland" || other.starts_with("hyprland.") => { + (PermissionKind::Hyprland, None, None) + } + other if other == "widget" || other.starts_with("widget.") => { + (PermissionKind::Widget, None, None) + } + other if other == "bluetooth" || other.starts_with("bluetooth.") => { + (PermissionKind::Bluetooth, None, None) + } + // Everything else (on/once/filter/off/emit/after/every/cancel/json/ + // module/log/warn/error/debounce/spawn/wait/wait_any/wait_all/ + // workflow/__private) is baseline — always available, nothing to + // suggest. + _ => return, + }; + found + .entry(kind) + .or_insert(ModulePermission { kind, path, bin }); +} + +/// Best-effort extraction of the first quoted string literal appearing on +/// the same line right after a call-site's opening paren, e.g. +/// `bread.exec("hyprpaper --config foo")` -> `Some("hyprpaper --config foo")`. +/// Returns `None` for dynamic/variable arguments (`bread.fs.read(path)`) — +/// the permission is still suggested, just without a scoping hint. +fn extract_first_string_arg(tail: &str) -> Option { + let line_end = tail.find('\n').unwrap_or(tail.len()); + let window = &tail[..line_end]; + let quote_pos = window.find(['"', '\''])?; + let quote_char = window.as_bytes()[quote_pos] as char; + let after = &window[quote_pos + 1..]; + let quote_end = after.find(quote_char)?; + Some(after[..quote_end].to_string()) +} + +#[cfg(test)] +mod audit_tests { + use super::*; + use tempfile::TempDir; + + #[test] + fn audit_detects_fs_read_and_widget_from_cpu_temp_widget_style_module() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("init.lua"), + r#" + local M = bread.module({ name = "cpu-temp-widget", version = "1.0.0" }) + local function read_temp_c() + local raw = bread.fs.read("/sys/class/hwmon/hwmon6/temp1_input") + return raw + end + function M.on_load() + bread.widget.register({ id = "cpu-temp" }) + bread.every(5000, function() + bread.widget.update("cpu-temp", {}) + end) + end + return M + "#, + ) + .unwrap(); + + let perms = audit_module(dir.path()).unwrap(); + let kinds: Vec = perms.iter().map(|p| p.kind).collect(); + assert!(kinds.contains(&PermissionKind::FsRead)); + assert!(kinds.contains(&PermissionKind::Widget)); + assert!(!kinds.contains(&PermissionKind::Exec)); + assert!(!kinds.contains(&PermissionKind::Bluetooth)); + + let fs_perm = perms.iter().find(|p| p.kind == PermissionKind::FsRead).unwrap(); + assert_eq!(fs_perm.path.as_deref(), Some("/sys/class/hwmon/hwmon6/temp1_input")); + } + + #[test] + fn audit_extracts_exec_bin_hint_and_ignores_baseline_calls() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("init.lua"), + r#" + local M = bread.module({ name = "wallpaper", version = "1.0.0" }) + function M.on_load() + bread.on("bread.monitor.connected", function() + bread.exec("hyprpaper --config /tmp/foo") + end) + bread.log("loaded") + end + return M + "#, + ) + .unwrap(); + + let perms = audit_module(dir.path()).unwrap(); + assert_eq!(perms.len(), 1); + assert_eq!(perms[0].kind, PermissionKind::Exec); + assert_eq!(perms[0].bin.as_deref(), Some("hyprpaper")); + } + + #[test] + fn audit_scans_required_sibling_files_in_module_directory() { + let dir = TempDir::new().unwrap(); + fs::write( + dir.path().join("init.lua"), + r#"local lib = require("./lib"); return bread.module({ name = "m", version = "1.0.0" })"#, + ) + .unwrap(); + fs::write( + dir.path().join("lib.lua"), + r#"return { go = function() bread.bluetooth.power(true) end }"#, + ) + .unwrap(); + + let perms = audit_module(dir.path()).unwrap(); + assert!(perms.iter().any(|p| p.kind == PermissionKind::Bluetooth)); + } + + #[test] + fn render_permissions_toml_produces_pastable_block() { + let perms = vec![ModulePermission { + kind: PermissionKind::Exec, + path: None, + bin: Some("hyprpaper".to_string()), + }]; + let rendered = render_permissions_toml(&perms).unwrap(); + assert!(rendered.contains("[[permissions]]")); + assert!(rendered.contains("type = \"exec\"")); + assert!(rendered.contains("bin = \"hyprpaper\"")); + } +} diff --git a/bread-emit/Cargo.toml b/bread-emit/Cargo.toml index 2324b03..0205f50 100644 --- a/bread-emit/Cargo.toml +++ b/bread-emit/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bread-emit" -version = "0.7.0" +version = "0.8.0" edition = "2021" [[bin]] diff --git a/bread-module-host/Cargo.toml b/bread-module-host/Cargo.toml new file mode 100644 index 0000000..b8ffef6 --- /dev/null +++ b/bread-module-host/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "bread-module-host" +version = "0.8.0" +edition = "2021" + +[[bin]] +name = "bread-module-host" +path = "src/main.rs" + +# Deliberately minimal dependency footprint (Workstream G): this binary is +# itself reviewable attack surface running third-party Lua under an +# OS-level sandbox constructed by breadd's parent process (see +# breadd/src/module_host.rs) — it does not depend on landlock itself, since +# the Landlock ruleset is applied by breadd via Command::pre_exec() *before* +# this binary's own main() ever runs (landlock_restrict_self() applies to +# the calling process across the subsequent execve()). +[dependencies] +bread-shared = { path = "../bread-shared" } +serde.workspace = true +serde_json.workspace = true +tokio = { version = "1.40", features = ["net", "io-util", "rt", "rt-multi-thread", "time", "macros", "sync"] } +anyhow.workspace = true +tracing.workspace = true +tracing-subscriber.workspace = true +mlua = { version = "0.9", features = ["lua54", "vendored", "serialize"] } +uuid.workspace = true + +[dev-dependencies] +tempfile.workspace = true diff --git a/bread-module-host/src/io.rs b/bread-module-host/src/io.rs new file mode 100644 index 0000000..96c1d42 --- /dev/null +++ b/bread-module-host/src/io.rs @@ -0,0 +1,269 @@ +//! The async half of `bread-module-host`: owns the Unix socket connection +//! back to `breadd` and speaks the newline-delimited-JSON IPC protocol +//! (`breadd/src/ipc/mod.rs`), extended with `module_host.*` methods (see +//! `breadd/src/module_host.rs` for the server side of this bridge). +//! +//! Runs on its own dedicated OS thread with its own single-threaded Tokio +//! runtime — mirroring `breadd`'s own `spawn_runtime` split between an async +//! IPC/adapters world and a synchronous, single-threaded Lua world (see +//! `breadd/src/lua/mod.rs`'s `spawn_runtime`). The Lua-driving thread in +//! `main.rs` talks to this thread over two plain `std::sync::mpsc` channels +//! (`IoCommand` out, `HostMessage` in) rather than sharing an async runtime, +//! since `mlua::Lua` values are not `Send` and Lua callbacks need to make +//! synchronous (blocking, from Lua's point of view) RPC calls. + +use std::collections::HashMap; +use std::path::PathBuf; +use std::sync::{mpsc, Arc, Mutex}; +use std::time::Duration; + +use bread_shared::{ModuleHostHello, ModuleHostPush}; +use serde_json::{json, Value}; +use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader}; +use tokio::net::UnixStream; +use tracing::warn; + +/// A request the Lua-driving thread wants sent to `breadd`, with a reply +/// channel for the (blocking, from Lua's perspective) response. +pub enum IoCommand { + Request { + method: String, + params: Value, + reply: mpsc::Sender>, + }, +} + +/// In-flight RPC calls awaiting a response, keyed by request id: each entry +/// is the reply channel for the call that's blocked waiting on it. +type PendingReplies = Arc>>>>; + +/// Something the IO thread has for the Lua-driving thread: either an +/// unsolicited push (a subscribed event fired, a timer fired) or "the +/// connection is gone" (breadd exited, socket closed, etc). +pub enum HostMessage { + Push(ModuleHostPush), + Closed, +} + +#[derive(serde::Deserialize)] +struct RpcResponse { + #[allow(dead_code)] + id: String, + #[serde(default)] + result: Option, + #[serde(default)] + error: Option, +} + +/// Connect, perform the `module_host.hello` handshake, and — on success — +/// run the steady-state request/response + push-forwarding loop until the +/// connection closes. `hello_tx` is always sent to exactly once, before +/// anything else; the caller blocks on it to learn the module's granted +/// identity (or why the handshake failed) before doing anything else. +pub fn run( + socket_path: PathBuf, + token: String, + cmd_rx: mpsc::Receiver, + host_tx: mpsc::Sender, + hello_tx: mpsc::Sender>, +) { + let rt = match tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + { + Ok(rt) => rt, + Err(e) => { + let _ = hello_tx.send(Err(format!("failed to start io runtime: {e}"))); + return; + } + }; + + rt.block_on(async move { + let stream = match UnixStream::connect(&socket_path).await { + Ok(s) => s, + Err(e) => { + let _ = hello_tx.send(Err(format!( + "failed to connect to {}: {e}", + socket_path.display() + ))); + return; + } + }; + let (read_half, mut write_half) = stream.into_split(); + let mut lines = BufReader::new(read_half).lines(); + + let hello_req = json!({ + "id": "hello", + "method": "module_host.hello", + "params": { "token": token }, + }); + let Ok(hello_line) = serde_json::to_string(&hello_req) else { + let _ = hello_tx.send(Err("failed to encode hello request".to_string())); + return; + }; + if write_half + .write_all(format!("{hello_line}\n").as_bytes()) + .await + .is_err() + { + let _ = hello_tx.send(Err("failed to write hello request".to_string())); + return; + } + + let response_line = match lines.next_line().await { + Ok(Some(line)) => line, + Ok(None) => { + let _ = hello_tx.send(Err( + "connection closed before hello response".to_string(), + )); + return; + } + Err(e) => { + let _ = hello_tx.send(Err(format!("read error awaiting hello: {e}"))); + return; + } + }; + let resp: RpcResponse = match serde_json::from_str(&response_line) { + Ok(r) => r, + Err(e) => { + let _ = hello_tx.send(Err(format!("malformed hello response: {e}"))); + return; + } + }; + if let Some(err) = resp.error { + let _ = hello_tx.send(Err(err)); + return; + } + let hello: ModuleHostHello = match resp + .result + .and_then(|v| serde_json::from_value(v).ok()) + { + Some(h) => h, + None => { + let _ = hello_tx.send(Err("hello response missing result".to_string())); + return; + } + }; + if hello_tx.send(Ok(hello)).is_err() { + return; + } + + // Steady state. `pending` routes response lines back to whichever + // Lua-side call is blocked waiting for them; a dedicated thread + // bridges the synchronous `cmd_rx` (fed from the Lua thread) onto an + // async channel this task can select on. + let pending: PendingReplies = Arc::new(Mutex::new(HashMap::new())); + + let (async_cmd_tx, mut async_cmd_rx) = tokio::sync::mpsc::unbounded_channel::(); + std::thread::spawn(move || { + while let Ok(cmd) = cmd_rx.recv() { + if async_cmd_tx.send(cmd).is_err() { + break; + } + } + }); + + let pending_for_writer = pending.clone(); + let write_task = tokio::spawn(async move { + let mut next_id: u64 = 1; + while let Some(IoCommand::Request { + method, + params, + reply, + }) = async_cmd_rx.recv().await + { + let id = format!("m{next_id}"); + next_id += 1; + let req = json!({ "id": id, "method": method, "params": params }); + let line = match serde_json::to_string(&req) { + Ok(l) => l, + Err(e) => { + let _ = reply.send(Err(e.to_string())); + continue; + } + }; + pending_for_writer.lock().unwrap().insert(id.clone(), reply); + if write_half + .write_all(format!("{line}\n").as_bytes()) + .await + .is_err() + { + if let Some(tx) = pending_for_writer.lock().unwrap().remove(&id) { + let _ = tx.send(Err("write failed; connection lost".to_string())); + } + break; + } + } + }); + + loop { + let line = match lines.next_line().await { + Ok(Some(l)) => l, + Ok(None) => break, + Err(e) => { + warn!(error = %e, "module-host: connection read error"); + break; + } + }; + if line.trim().is_empty() { + continue; + } + let value: Value = match serde_json::from_str(&line) { + Ok(v) => v, + Err(e) => { + warn!(error = %e, "module-host: malformed line from breadd"); + continue; + } + }; + if value.get("push").is_some() { + match serde_json::from_value::(value) { + Ok(push) => { + if host_tx.send(HostMessage::Push(push)).is_err() { + break; + } + } + Err(e) => warn!(error = %e, "module-host: malformed push message"), + } + } else if let Ok(resp) = serde_json::from_value::(value) { + if let Some(tx) = pending.lock().unwrap().remove(&resp.id) { + let result = match resp.error { + Some(e) => Err(e), + None => Ok(resp.result.unwrap_or(Value::Null)), + }; + let _ = tx.send(result); + } + } + } + + write_task.abort(); + // Any calls still blocked waiting for a reply need to be unblocked + // rather than hanging forever now that the connection is gone. + for (_, tx) in pending.lock().unwrap().drain() { + let _ = tx.send(Err("connection closed".to_string())); + } + let _ = host_tx.send(HostMessage::Closed); + }); +} + +/// Blocking helper used from Lua callback closures (which run on the +/// Lua-driving thread, not the async IO thread): send a request and wait — +/// with a timeout, so a wedged connection can't hang a Lua callback forever +/// — for its response. +pub fn call( + cmd_tx: &mpsc::Sender, + method: &str, + params: Value, + timeout: Duration, +) -> Result { + let (reply_tx, reply_rx) = mpsc::channel(); + cmd_tx + .send(IoCommand::Request { + method: method.to_string(), + params, + reply: reply_tx, + }) + .map_err(|_| "io thread gone".to_string())?; + reply_rx + .recv_timeout(timeout) + .map_err(|_| format!("{method} timed out"))? +} diff --git a/bread-module-host/src/lua_env.rs b/bread-module-host/src/lua_env.rs new file mode 100644 index 0000000..cfaab0d --- /dev/null +++ b/bread-module-host/src/lua_env.rs @@ -0,0 +1,531 @@ +//! The Lua half of `bread-module-host`: a `bread` table whose functions are +//! RPC-backed proxies to `breadd` instead of directly touching daemon state, +//! plus a dispatch loop that turns `ModuleHostPush` messages (from +//! `crate::io`) into Lua callback invocations. +//! +//! Structurally a slimmed-down sibling of `breadd/src/lua/mod.rs`'s +//! `LuaEngine`/`spawn_runtime`: one dedicated thread runs Lua synchronously +//! and reacts to messages from a channel (`HostMessage` here, `LuaMessage` +//! there); a separate thread/task owns the actual async I/O. Only ONE +//! module is ever loaded per `bread-module-host` process, so there's no +//! module registry, load ordering, or `after` dependency resolution here — +//! `breadd` already resolved all of that before deciding this module needed +//! its own process. +//! +//! `bread.module()`'s `store` is process-local (an in-memory table, not +//! synced back to `breadd`) — a documented gap vs. the in-process +//! implementation's `bread.module().store`, which persists in +//! `RuntimeState` and is visible to `bread modules info`/other modules. +//! Fine for a single module's own private scratch state; not fine yet for +//! anything that expects cross-module visibility. See `Documentation.md`. + +use std::cell::RefCell; +use std::collections::{HashMap, HashSet}; +use std::rc::Rc; +use std::sync::mpsc; +use std::time::Duration; + +use anyhow::{anyhow, Result}; +use bread_shared::{BreadEvent, ModulePermission, PermissionKind}; +use mlua::{Error as LuaError, Function, Lua, LuaSerdeExt, RegistryKey, Table, Value as LuaValue}; +use serde_json::{json, Value as JsonValue}; +use tracing::error; + +use crate::io::{call, IoCommand}; + +/// Timeout for a single RPC round trip to `breadd`. Generous relative to a +/// same-host Unix socket hop — this exists to fail loudly if the connection +/// wedges rather than to accommodate genuinely slow calls. +const RPC_TIMEOUT: Duration = Duration::from_secs(10); + +/// Pure-Lua `bread.spawn`/`bread.wait` sugar, copied verbatim from +/// `breadd/src/lua/mod.rs`'s `install_wait_helper`. It only depends on +/// `coroutine` plus `bread.once`/`bread.on`/`bread.after`/`bread.cancel`, +/// all of which this module provides as RPC-backed bindings above, so the +/// suspension mechanism works unmodified against a remote event source. +/// +/// Deliberately duplicated rather than shared: extracting this into +/// `bread-shared` (so `breadd` and `bread-module-host` load the same +/// constant instead of two hand-kept-in-sync copies) is flagged as +/// follow-up work in `Documentation.md` — doing it here would also require +/// making `breadd`'s currently-private `const BUILTIN_*`/wait-helper +/// strings public, which is a larger refactor than this workstream's time +/// budget covers. +const WAIT_HELPER: &str = r#" +bread.spawn = function(fn) + local co = coroutine.create(fn) + local ok, err = coroutine.resume(co) + if not ok then + error(err) + end +end + +bread.wait = function(pattern, opts) + if type(pattern) ~= "string" then + error("bread.wait requires a pattern string") + end + opts = opts or {} + local co = coroutine.running() + if not co then + error("bread.wait must be called inside a coroutine") + end + local id + local timer + id = bread.once(pattern, function(event) + if timer then + bread.cancel(timer) + end + coroutine.resume(co, event) + end) + if opts.timeout then + timer = bread.after(opts.timeout, function() + bread.off(id) + coroutine.resume(co, nil) + end) + end + return coroutine.yield() +end +"#; + +fn json_to_lua<'lua>(lua: &'lua Lua, value: &JsonValue) -> mlua::Result> { + Ok(match value { + JsonValue::Null => LuaValue::Nil, + JsonValue::Bool(b) => LuaValue::Boolean(*b), + JsonValue::Number(n) => { + if let Some(i) = n.as_i64() { + LuaValue::Integer(i) + } else { + LuaValue::Number(n.as_f64().unwrap_or(0.0)) + } + } + JsonValue::String(s) => LuaValue::String(lua.create_string(s)?), + JsonValue::Array(arr) => { + let tbl = lua.create_table()?; + for (i, v) in arr.iter().enumerate() { + tbl.set(i + 1, json_to_lua(lua, v)?)?; + } + LuaValue::Table(tbl) + } + JsonValue::Object(obj) => { + let tbl = lua.create_table()?; + for (k, v) in obj.iter() { + tbl.set(k.clone(), json_to_lua(lua, v)?)?; + } + LuaValue::Table(tbl) + } + }) +} + +/// The Lua VM plus the bookkeeping needed to route `ModuleHostPush` +/// messages to the right registered callback. Lives entirely on one thread +/// (`mlua::Lua` is `!Send`) — see `main.rs`. +pub struct ModuleHostLua { + lua: Lua, + /// subscription_id or timer_id -> the Lua callback registered for it. + handlers: Rc>>, + registered: Rc>, + module_table_key: Rc>>, + module_name: String, +} + +impl ModuleHostLua { + pub fn new( + cmd_tx: mpsc::Sender, + module_name: String, + permissions: Vec, + ) -> Result { + let lua = Lua::new(); + let bread = lua.create_table()?; + let handlers: Rc>> = Rc::new(RefCell::new(HashMap::new())); + let registered = Rc::new(RefCell::new(false)); + let module_table_key: Rc>> = Rc::new(RefCell::new(None)); + + Self::install_module_fn( + &lua, + &bread, + module_name.clone(), + registered.clone(), + module_table_key.clone(), + )?; + Self::install_logging(&lua, &bread, cmd_tx.clone())?; + Self::install_json(&lua, &bread)?; + Self::install_events(&lua, &bread, cmd_tx.clone(), handlers.clone())?; + Self::install_timers(&lua, &bread, cmd_tx.clone(), handlers.clone())?; + Self::install_emit(&lua, &bread, cmd_tx.clone())?; + + let granted: HashSet = permissions.iter().map(|p| p.kind).collect(); + Self::install_fs(&lua, &bread, cmd_tx.clone(), &granted)?; + Self::install_exec(&lua, &bread, cmd_tx.clone(), &granted)?; + Self::install_state(&lua, &bread, cmd_tx, &granted)?; + + lua.globals().set("bread", bread)?; + lua.load(WAIT_HELPER).set_name("").exec()?; + + Ok(Self { + lua, + handlers, + registered, + module_table_key, + module_name, + }) + } + + fn install_module_fn( + lua: &Lua, + bread: &Table, + expected_name: String, + registered: Rc>, + module_table_key: Rc>>, + ) -> Result<()> { + let store: Rc>> = Rc::new(RefCell::new(HashMap::new())); + let module_fn = lua.create_function(move |lua, table: Table| -> mlua::Result { + let name: String = table.get("name")?; + if name != expected_name { + return Err(LuaError::RuntimeError(format!( + "bread.module({{name = \"{name}\"}}) does not match the module breadd spawned this process for (\"{expected_name}\")" + ))); + } + let version: Option = table.get("version").ok(); + + let module_tbl = lua.create_table()?; + module_tbl.set("name", name.clone())?; + if let Some(v) = version { + module_tbl.set("version", v)?; + } + + let store_tbl = lua.create_table()?; + let store_get = store.clone(); + let get_fn = lua.create_function(move |lua, key: String| { + match store_get.borrow().get(&key) { + Some(v) => json_to_lua(lua, v), + None => Ok(LuaValue::Nil), + } + })?; + store_tbl.set("get", get_fn)?; + + let store_set = store.clone(); + let set_fn = lua.create_function(move |lua, (key, value): (String, LuaValue)| { + let json: JsonValue = lua.from_value(value).unwrap_or(JsonValue::Null); + store_set.borrow_mut().insert(key, json); + Ok(()) + })?; + store_tbl.set("set", set_fn)?; + module_tbl.set("store", store_tbl)?; + + *registered.borrow_mut() = true; + let key = lua.create_registry_value(module_tbl.clone())?; + *module_table_key.borrow_mut() = Some(key); + + Ok(module_tbl) + })?; + bread.set("module", module_fn)?; + Ok(()) + } + + fn install_logging(lua: &Lua, bread: &Table, cmd_tx: mpsc::Sender) -> Result<()> { + for (name, method) in [ + ("log", "module_host.log"), + ("warn", "module_host.warn"), + ("error", "module_host.error"), + ] { + let cmd_tx = cmd_tx.clone(); + let f = lua.create_function(move |_, message: String| { + let _ = call(&cmd_tx, method, json!({ "message": message }), RPC_TIMEOUT); + Ok(()) + })?; + bread.set(name, f)?; + } + Ok(()) + } + + fn install_json(lua: &Lua, bread: &Table) -> Result<()> { + let json_tbl = lua.create_table()?; + let decode_fn = lua.create_function(|lua, s: String| { + match serde_json::from_str::(&s) { + Ok(v) => Ok((json_to_lua(lua, &v)?, LuaValue::Nil)), + Err(e) => Ok((LuaValue::Nil, LuaValue::String(lua.create_string(e.to_string())?))), + } + })?; + json_tbl.set("decode", decode_fn)?; + bread.set("json", json_tbl)?; + Ok(()) + } + + fn install_events( + lua: &Lua, + bread: &Table, + cmd_tx: mpsc::Sender, + handlers: Rc>>, + ) -> Result<()> { + for (name, once) in [("on", false), ("once", true)] { + let cmd_tx = cmd_tx.clone(); + let handlers = handlers.clone(); + let method = if once { "module_host.once" } else { "module_host.on" }; + let f = lua.create_function(move |lua, (pattern, callback): (String, Function)| { + let result = call(&cmd_tx, method, json!({ "pattern": pattern }), RPC_TIMEOUT) + .map_err(LuaError::external)?; + let id = result + .get("subscription_id") + .and_then(|v| v.as_str()) + .ok_or_else(|| LuaError::external("module_host.on: missing subscription_id"))? + .to_string(); + let key = lua.create_registry_value(callback)?; + handlers.borrow_mut().insert(id.clone(), key); + Ok(id) + })?; + bread.set(name, f)?; + } + + let cmd_tx_off = cmd_tx.clone(); + let handlers_off = handlers.clone(); + let off_fn = lua.create_function(move |_, id: String| { + let _ = call(&cmd_tx_off, "module_host.off", json!({ "id": id }), RPC_TIMEOUT); + handlers_off.borrow_mut().remove(&id); + Ok(()) + })?; + bread.set("off", off_fn)?; + Ok(()) + } + + fn install_timers( + lua: &Lua, + bread: &Table, + cmd_tx: mpsc::Sender, + handlers: Rc>>, + ) -> Result<()> { + for (name, method, param_key) in [ + ("after", "module_host.after", "delay_ms"), + ("every", "module_host.every", "interval_ms"), + ] { + let cmd_tx = cmd_tx.clone(); + let handlers = handlers.clone(); + let f = lua.create_function(move |lua, (delay_ms, callback): (u64, Function)| { + let result = call(&cmd_tx, method, json!({ param_key: delay_ms }), RPC_TIMEOUT) + .map_err(LuaError::external)?; + let id = result + .get("timer_id") + .and_then(|v| v.as_str()) + .ok_or_else(|| LuaError::external(format!("{method}: missing timer_id")))? + .to_string(); + let key = lua.create_registry_value(callback)?; + handlers.borrow_mut().insert(id.clone(), key); + Ok(id) + })?; + bread.set(name, f)?; + } + + let cmd_tx_cancel = cmd_tx.clone(); + let handlers_cancel = handlers.clone(); + let cancel_fn = lua.create_function(move |_, id: String| { + let _ = call(&cmd_tx_cancel, "module_host.cancel", json!({ "id": id }), RPC_TIMEOUT); + handlers_cancel.borrow_mut().remove(&id); + Ok(()) + })?; + bread.set("cancel", cancel_fn)?; + Ok(()) + } + + fn install_emit(lua: &Lua, bread: &Table, cmd_tx: mpsc::Sender) -> Result<()> { + let emit_fn = lua.create_function(move |lua, (event, data): (String, Option)| { + let data_json: JsonValue = match data { + Some(v) => lua.from_value(v).unwrap_or(JsonValue::Null), + None => json!({}), + }; + call( + &cmd_tx, + "module_host.emit", + json!({ "event": event, "data": data_json }), + RPC_TIMEOUT, + ) + .map(|_| ()) + .map_err(LuaError::external) + })?; + bread.set("emit", emit_fn)?; + Ok(()) + } + + /// `bread.state.get(path)`, gated on `state.read`. Only the `get` + /// shorthand is bridged here — `.monitors()`/`.active_workspace()`/etc. + /// convenience wrappers and `state.watch` (a standing subscription, a + /// materially different capability — see `PermissionKind::StateWatch`'s + /// doc comment in `bread-shared`) are deferred; see `Documentation.md`'s + /// Workstream G section for the full list of what's bridged vs. not. + fn install_state( + lua: &Lua, + bread: &Table, + cmd_tx: mpsc::Sender, + granted: &HashSet, + ) -> Result<()> { + if !granted.contains(&PermissionKind::StateRead) { + return Ok(()); + } + let state_tbl = lua.create_table()?; + let get_fn = lua.create_function(move |lua, key: String| { + let result = call(&cmd_tx, "module_host.state_get", json!({ "key": key }), RPC_TIMEOUT) + .map_err(LuaError::external)?; + match result.get("value") { + Some(v) => json_to_lua(lua, v), + None => Ok(LuaValue::Nil), + } + })?; + state_tbl.set("get", get_fn)?; + bread.set("state", state_tbl)?; + Ok(()) + } + + fn install_fs( + lua: &Lua, + bread: &Table, + cmd_tx: mpsc::Sender, + granted: &HashSet, + ) -> Result<()> { + if !granted.contains(&PermissionKind::FsRead) && !granted.contains(&PermissionKind::FsWrite) { + return Ok(()); + } + let fs_tbl = lua.create_table()?; + if granted.contains(&PermissionKind::FsRead) { + let cmd_tx = cmd_tx.clone(); + let read_fn = lua.create_function(move |_, path: String| { + let result = call(&cmd_tx, "module_host.fs_read", json!({ "path": path }), RPC_TIMEOUT) + .map_err(LuaError::external)?; + Ok(result + .get("content") + .and_then(|v| v.as_str()) + .map(|s| s.to_string())) + })?; + fs_tbl.set("read", read_fn)?; + } + if granted.contains(&PermissionKind::FsWrite) { + let cmd_tx = cmd_tx.clone(); + let write_fn = lua.create_function(move |_, (path, content): (String, String)| { + call( + &cmd_tx, + "module_host.fs_write", + json!({ "path": path, "content": content }), + RPC_TIMEOUT, + ) + .map(|_| ()) + .map_err(LuaError::external) + })?; + fs_tbl.set("write", write_fn)?; + } + bread.set("fs", fs_tbl)?; + Ok(()) + } + + fn install_exec( + lua: &Lua, + bread: &Table, + cmd_tx: mpsc::Sender, + granted: &HashSet, + ) -> Result<()> { + if !granted.contains(&PermissionKind::Exec) { + return Ok(()); + } + let cmd_tx_exec = cmd_tx.clone(); + let exec_fn = lua.create_function(move |_, cmd: String| { + call(&cmd_tx_exec, "module_host.exec", json!({ "cmd": cmd }), RPC_TIMEOUT) + .map(|_| ()) + .map_err(LuaError::external) + })?; + bread.set("exec", exec_fn)?; + + let exec_capture_fn = lua.create_function(move |_, (cmd, opts): (String, Option
)| { + let timeout_ms: u64 = opts + .as_ref() + .and_then(|o| o.get("timeout_ms").ok()) + .unwrap_or(2000); + let call_timeout = RPC_TIMEOUT + Duration::from_millis(timeout_ms); + let result = call( + &cmd_tx, + "module_host.exec_capture", + json!({ "cmd": cmd, "timeout_ms": timeout_ms }), + call_timeout, + ) + .map_err(LuaError::external)?; + let ok = result.get("ok").and_then(|v| v.as_bool()).unwrap_or(false); + let stdout = result + .get("stdout") + .and_then(|v| v.as_str()) + .unwrap_or("") + .to_string(); + Ok((ok, stdout)) + })?; + bread.set("exec_capture", exec_capture_fn)?; + Ok(()) + } + + /// Load and execute the module's `init.lua`, then verify it actually + /// called `bread.module(...)` — mirrors `breadd`'s own + /// `load_module`/`load_scoped_lua_file` contract exactly (see + /// `breadd/src/lua/mod.rs`). + pub fn load_entry(&self, entry_path: &std::path::Path) -> Result<()> { + let src = std::fs::read_to_string(entry_path) + .map_err(|e| anyhow!("failed to read {}: {e}", entry_path.display()))?; + self.lua + .load(&src) + .set_name(entry_path.to_string_lossy().as_ref()) + .exec() + .map_err(|e| anyhow!(e.to_string()))?; + + if !*self.registered.borrow() { + return Err(anyhow!("module did not call bread.module(...)")); + } + self.run_on_load() + } + + fn run_on_load(&self) -> Result<()> { + let key_ref = self.module_table_key.borrow(); + let Some(key) = key_ref.as_ref() else { + return Ok(()); + }; + let module_tbl: Table = self + .lua + .registry_value(key) + .map_err(|e| anyhow!(e.to_string()))?; + let hook: Option = module_tbl.get("on_load").ok(); + drop(key_ref); + if let Some(hook) = hook { + hook.call::<_, ()>(()) + .map_err(|e| anyhow!("{} on_load failed: {e}", self.module_name))?; + } + Ok(()) + } + + pub fn dispatch_event(&self, subscription_id: &str, event: &BreadEvent) { + let func = self.lookup(subscription_id); + if let Some(func) = func { + if let Err(e) = self.call_event_handler(&func, event) { + error!(subscription_id, error = %e, "module-host: event handler error"); + } + } + } + + pub fn dispatch_timer(&self, timer_id: &str) { + let func = self.lookup(timer_id); + if let Some(func) = func { + if let Err(e) = func.call::<_, ()>(()) { + error!(timer_id, error = %e, "module-host: timer handler error"); + } + } + } + + fn lookup(&self, id: &str) -> Option> { + let handlers = self.handlers.borrow(); + let key = handlers.get(id)?; + self.lua.registry_value::(key).ok() + } + + fn call_event_handler(&self, func: &Function, event: &BreadEvent) -> mlua::Result<()> { + let data = json_to_lua(&self.lua, &event.data)?; + let evt_tbl = self.lua.create_table()?; + evt_tbl.set("event", event.event.clone())?; + evt_tbl.set("data", data)?; + evt_tbl.set("timestamp", event.timestamp)?; + evt_tbl.set("id", event.id.clone())?; + if let Some(caused_by) = &event.caused_by { + evt_tbl.set("caused_by", caused_by.clone())?; + } + func.call::<_, ()>(evt_tbl) + } +} diff --git a/bread-module-host/src/main.rs b/bread-module-host/src/main.rs new file mode 100644 index 0000000..cfc1a03 --- /dev/null +++ b/bread-module-host/src/main.rs @@ -0,0 +1,164 @@ +//! `bread-module-host` — the out-of-process runtime for a single third-party +//! Bread module (Workstream G). +//! +//! `breadd` spawns one of these per out-of-process module (see +//! `breadd/src/module_host.rs`), sandboxed at the OS level via a Landlock +//! ruleset applied by the parent *before* this binary's own `main()` ever +//! runs (through `Command::pre_exec` — see that module's doc comment for +//! why this binary itself has no Landlock dependency at all). This process +//! then: +//! +//! 1. Connects to `breadd`'s existing IPC socket +//! (`$XDG_RUNTIME_DIR/bread/breadd.sock` by default). +//! 2. Presents the one-time token `breadd` gave it (via `$BREAD_MODULE_TOKEN`, +//! an env var rather than argv, which is visible to any process via +//! `/proc/*/cmdline`) via `module_host.hello` and learns its own identity +//! (module name + granted permissions) from `breadd`'s answer — it never +//! asserts its own name and have that trusted. +//! 3. Loads exactly one module's `init.lua` (`$BREAD_MODULE_ENTRY`) into a +//! fresh Lua VM whose `bread` table is built entirely from RPC-backed +//! proxies (see `lua_env`) instead of direct in-process bindings. +//! 4. Reports load success/failure back to `breadd` (`module_host.status`), +//! then dispatches subscribed events/timers pushed down the same +//! connection until it closes. +//! +//! Env vars, all required except `BREAD_MODULE_SOCKET` and +//! `BREAD_MODULE_NAME`: +//! - `BREAD_MODULE_TOKEN` — one-time handshake token. +//! - `BREAD_MODULE_ENTRY` — absolute path to the module's entry `.lua` file. +//! - `BREAD_MODULE_SOCKET` — override for breadd's socket path (defaults to +//! `bread_shared::resolve_socket_path()`, the same resolution breadd's own +//! `Config::socket_path` uses). +//! - `BREAD_MODULE_NAME` — informational only (early log lines before the +//! hello response arrives); never trusted for permission lookup. + +mod io; +mod lua_env; + +use std::path::PathBuf; +use std::sync::mpsc; +use std::time::Duration; + +use bread_shared::{ModuleHostHello, ModuleHostPush}; +use tracing::{error, info, warn}; + +use io::{HostMessage, IoCommand}; +use lua_env::ModuleHostLua; + +fn main() { + tracing_subscriber::fmt() + .with_env_filter(tracing_subscriber::EnvFilter::from_default_env()) + .init(); + + let module_name_hint = std::env::var("BREAD_MODULE_NAME").unwrap_or_else(|_| "?".to_string()); + + let token = match std::env::var("BREAD_MODULE_TOKEN") { + Ok(t) => t, + Err(_) => { + eprintln!("bread-module-host: missing BREAD_MODULE_TOKEN env var"); + std::process::exit(1); + } + }; + let entry = match std::env::var("BREAD_MODULE_ENTRY") { + Ok(e) => PathBuf::from(e), + Err(_) => { + eprintln!("bread-module-host: missing BREAD_MODULE_ENTRY env var"); + std::process::exit(1); + } + }; + let socket_path = match std::env::var("BREAD_MODULE_SOCKET") { + Ok(s) => PathBuf::from(s), + Err(_) => bread_shared::resolve_socket_path(), + }; + + info!( + module_hint = %module_name_hint, + entry = %entry.display(), + socket = %socket_path.display(), + "bread-module-host starting" + ); + + let (cmd_tx, cmd_rx) = mpsc::channel::(); + let (host_tx, host_rx) = mpsc::channel::(); + let (hello_tx, hello_rx) = mpsc::channel::>(); + + if std::thread::Builder::new() + .name("module-host-io".to_string()) + .spawn(move || io::run(socket_path, token, cmd_rx, host_tx, hello_tx)) + .is_err() + { + eprintln!("bread-module-host: failed to spawn io thread"); + std::process::exit(1); + } + + let hello = match hello_rx.recv_timeout(Duration::from_secs(15)) { + Ok(Ok(h)) => h, + Ok(Err(e)) => { + error!(error = %e, "bread-module-host: hello handshake failed"); + std::process::exit(1); + } + Err(_) => { + error!("bread-module-host: timed out waiting for hello handshake"); + std::process::exit(1); + } + }; + + info!( + module = %hello.module, + permissions = ?hello.permissions, + api_version = %hello.api_version, + "bread-module-host: identity established by breadd" + ); + + let engine = match ModuleHostLua::new(cmd_tx.clone(), hello.module.clone(), hello.permissions.clone()) { + Ok(e) => e, + Err(e) => { + error!(error = %e, "bread-module-host: failed to build lua environment"); + report_status(&cmd_tx, false, Some(e.to_string())); + std::process::exit(1); + } + }; + + match engine.load_entry(&entry) { + Ok(()) => { + info!(module = %hello.module, "bread-module-host: module loaded successfully"); + report_status(&cmd_tx, true, None); + } + Err(e) => { + error!(module = %hello.module, error = %e, "bread-module-host: module load failed"); + report_status(&cmd_tx, false, Some(e.to_string())); + std::process::exit(1); + } + } + + // Steady state: dispatch pushed events/timers until the connection to + // breadd drops (breadd exited, socket closed, or we were killed and + // this line never runs at all — see breadd/src/module_host.rs's + // child-reap thread for the other half of that crash-isolation story). + loop { + match host_rx.recv() { + Ok(HostMessage::Push(ModuleHostPush::Event { + subscription_id, + event, + })) => { + engine.dispatch_event(&subscription_id, &event); + } + Ok(HostMessage::Push(ModuleHostPush::Timer { timer_id })) => { + engine.dispatch_timer(&timer_id); + } + Ok(HostMessage::Closed) | Err(_) => { + warn!("bread-module-host: connection to breadd closed, exiting"); + break; + } + } + } +} + +fn report_status(cmd_tx: &mpsc::Sender, ok: bool, error: Option) { + let params = if ok { + serde_json::json!({ "state": "loaded" }) + } else { + serde_json::json!({ "state": "load_error", "error": error }) + }; + let _ = io::call(cmd_tx, "module_host.status", params, Duration::from_secs(5)); +} diff --git a/bread-shared/Cargo.toml b/bread-shared/Cargo.toml index bf6ce66..91f8cc3 100644 --- a/bread-shared/Cargo.toml +++ b/bread-shared/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bread-shared" -version = "0.7.0" +version = "0.8.0" edition = "2021" [dependencies] @@ -8,3 +8,4 @@ serde.workspace = true serde_json.workspace = true dirs.workspace = true toml = "0.8" +uuid = { version = "1", features = ["v4"] } diff --git a/bread-shared/src/apps.rs b/bread-shared/src/apps.rs index 7e6b18c..4ecbcc5 100644 --- a/bread-shared/src/apps.rs +++ b/bread-shared/src/apps.rs @@ -11,13 +11,30 @@ /// (commands) namespaces. pub const KNOWN_APPS: &[&str] = &[ "clip", "pad", "bar", "box", "lock", "mon", "paper", "search", "shot", "arr", "crumbs", "help", - "bakery", + "bakery", "cast", ]; /// Daemon-internal domains that are reserved and can never be claimed as an /// app id, even if a future `bread*` app would otherwise want that name — /// these are the top-level segments the normalizer and built-in event /// families already use. +/// +/// This is also the single source of truth the IPC boundary checks before +/// allowing a manual (no-`source`) `emit` request to use an event name — a +/// socket client may freely emit a custom/test event, but not one whose +/// top-level segment is one of these, since that would let it impersonate +/// a real adapter (or another daemon-internal event family) rather than +/// producing an obviously-manual one. The one exception is a well-formed +/// [`validate_command_event`] name (`bread.command..`): +/// `command` stays reserved so it cannot be claimed as an app id, but the +/// command bus itself is meant to be publishable. See [`is_reserved_domain`] +/// and `breadd/src/ipc/mod.rs`'s `emit` handler. *Since: v1.5 — `bluetooth`, +/// `workspace`, `window`, and `monitor` added (event families the Hyprland +/// and Bluetooth adapters already published under, but that were missing +/// from this list) when this became a spoofing-prevention boundary and not +/// just an app-id-conflict one. Since: v1.7 — command-bus exception. +/// `module`, `state`, `widget`, and `reload` are daemon-synthesized +/// families and must stay unclaimable.* const RESERVED_DOMAINS: &[&str] = &[ "terminal", "git", @@ -34,6 +51,14 @@ const RESERVED_DOMAINS: &[&str] = &[ "notify", "command", "workflow", + "bluetooth", + "workspace", + "window", + "monitor", + "module", + "state", + "widget", + "reload", ]; /// Whether `id` is a registered sibling-app id. @@ -50,11 +75,63 @@ pub fn is_reserved_domain(id: &str) -> bool { /// Whether `event` is a well-formed event name for `app` — i.e. it starts /// with `bread..`. An app may only publish within its own namespace /// segment; this is what the IPC boundary checks before constructing a -/// `RawEvent` tagged `AdapterSource::App(app)`. +/// `RawEvent` tagged `AdapterSource::App(app)`. Command events addressed +/// to another known app are a separate, explicit exception — see +/// [`validate_command_event`]. pub fn validate_app_namespace(app: &str, event: &str) -> bool { event.starts_with(&format!("bread.{app}.")) } +/// Whether `event` is in the outbound command namespace +/// (`bread.command.*`). Does not check that the target is a known app — +/// use [`validate_command_event`] for that. +pub fn is_command_event(event: &str) -> bool { + event.starts_with("bread.command.") +} + +/// The app id a command event is addressed to — the segment immediately +/// after `bread.command.`. Returns `None` if `event` is not a command +/// event or the app-id segment is empty. +pub fn command_target(event: &str) -> Option<&str> { + let rest = event.strip_prefix("bread.command.")?; + let app = rest.split('.').next()?; + if app.is_empty() { + None + } else { + Some(app) + } +} + +/// Whether `event` is a well-formed command to a registered sibling app: +/// `bread.command..` with `known_app` in [`KNOWN_APPS`] +/// and a non-empty verb (at least one extra dotted segment). +/// +/// This is the exception the IPC unsourced/`bread-emit` path (and sourced +/// `AdapterSource::App` emit) use so any module or app can publish +/// commands without `command` leaving [`is_reserved_domain`] — `command` +/// must stay unclaimable as an app id. `bread.command.power.off` and +/// `bread.command.notanapp.x` still fail because the target is not in +/// [`KNOWN_APPS`]. +pub fn validate_command_event(event: &str) -> bool { + let rest = match event.strip_prefix("bread.command.") { + Some(rest) => rest, + None => return false, + }; + let Some((app, verb)) = rest.split_once('.') else { + return false; + }; + is_known_app(app) && !verb.is_empty() +} + +/// The top-level dotted segment after `bread.` in an event name — e.g. +/// `Some("power")` for `"bread.power.ac.connected"`. Returns `None` for +/// event names that don't start with `bread.` at all, which are always +/// outside any reserved namespace (freely-named custom/test events, the +/// `bread emit ` debug use case, never take this prefix). +pub fn event_domain(event: &str) -> Option<&str> { + event.strip_prefix("bread.")?.split('.').next() +} + #[cfg(test)] mod tests { use super::*; @@ -88,6 +165,46 @@ mod tests { assert!(!is_reserved_domain("clip")); } + #[test] + fn reserved_domains_cover_every_adapter_owned_event_family() { + // Every top-level segment a real adapter (via the normalizer) or the + // daemon itself publishes under must be reserved, or a manual/no-source + // `emit` over the IPC socket could impersonate it undetected. + for domain in [ + "power", + "network", + "device", + "bluetooth", + "hyprland", + "workspace", + "monitor", + "window", + "system", + "module", + "state", + "widget", + "reload", + ] { + assert!( + is_reserved_domain(domain), + "'{domain}' is an adapter-owned event family and must be reserved" + ); + } + } + + #[test] + fn event_domain_extracts_top_level_segment() { + assert_eq!(event_domain("bread.power.ac.connected"), Some("power")); + assert_eq!(event_domain("bread.custom.event"), Some("custom")); + assert_eq!(event_domain("bread.test"), Some("test")); + } + + #[test] + fn event_domain_is_none_without_bread_prefix() { + assert_eq!(event_domain("power.ac.connected"), None); + assert_eq!(event_domain(""), None); + } + #[test] fn validate_app_namespace_accepts_own_namespace() { assert!(validate_app_namespace("clip", "bread.clip.copied")); @@ -110,4 +227,47 @@ mod tests { // because it shares a string prefix. assert!(!validate_app_namespace("clip", "bread.clipx.copied")); } + + #[test] + fn is_command_event_requires_command_prefix() { + assert!(is_command_event("bread.command.clip.clear")); + assert!(is_command_event("bread.command.power.off")); + assert!(!is_command_event("bread.command")); + assert!(!is_command_event("bread.clip.copied")); + assert!(!is_command_event("command.clip.clear")); + } + + #[test] + fn command_target_extracts_app_id() { + assert_eq!(command_target("bread.command.clip.clear"), Some("clip")); + assert_eq!(command_target("bread.command.cast.start.now"), Some("cast")); + assert_eq!(command_target("bread.command.clip"), Some("clip")); + assert_eq!(command_target("bread.command."), None); + assert_eq!(command_target("bread.clip.copied"), None); + } + + #[test] + fn validate_command_event_accepts_known_app_with_verb() { + assert!(validate_command_event("bread.command.clip.clear")); + assert!(validate_command_event("bread.command.cast.start")); + assert!(validate_command_event("bread.command.clip.stack.clear")); + } + + #[test] + fn validate_command_event_rejects_unknown_target_or_missing_verb() { + assert!(!validate_command_event("bread.command.power.off")); + assert!(!validate_command_event("bread.command.notanapp.x")); + assert!(!validate_command_event("bread.command.clip")); + assert!(!validate_command_event("bread.command.clip.")); + assert!(!validate_command_event("bread.command.")); + assert!(!validate_command_event("bread.hyprland.workspace.changed")); + assert!(!validate_command_event("bread.clip.copied")); + } + + #[test] + fn command_stays_reserved_and_is_not_a_known_app() { + assert!(is_reserved_domain("command")); + assert!(!is_known_app("command")); + assert!(!validate_command_event("bread.command.command.x")); + } } diff --git a/bread-shared/src/lib.rs b/bread-shared/src/lib.rs index f5982d8..411e8e4 100644 --- a/bread-shared/src/lib.rs +++ b/bread-shared/src/lib.rs @@ -10,6 +10,12 @@ use serde::{Deserialize, Serialize}; pub mod apps; pub mod glob; +pub mod module_host_ipc; +pub mod permissions; +pub mod widget; + +pub use module_host_ipc::{ModuleHostHello, ModuleHostPush}; +pub use permissions::{ModulePermission, PermissionKind}; /// Identifies which adapter produced an event. /// @@ -31,9 +37,25 @@ pub enum AdapterSource { Power, /// Network state (rtnetlink / NetworkManager). Network, - /// Internal events synthesized by the daemon itself - /// (e.g. `bread.profile.activated`, `bread.state.changed.*`). + /// Internal events synthesized by the daemon itself, i.e. trusted, + /// Rust-code-originated sends via `emit_tx` (e.g. `bread.system.startup`, + /// `bread.profile.activated`, `bread.state.changed.*`, and Lua's + /// `bread.emit()` binding). Never assignable from data that arrived + /// over the IPC socket — see [`Manual`](AdapterSource::Manual) for that + /// case. *Since: v1.5 — this constraint is now enforced; previously the + /// IPC `emit` method's no-`source` path could also tag events `System`.* System, + /// A manual `emit` IPC request with no `source` param — a human or + /// script poked the daemon's Unix socket directly (e.g. `bread emit + /// ` for testing Lua handlers without unplugging cables). + /// Distinct from [`System`](AdapterSource::System) so downstream Lua + /// modules and tooling can tell "someone manually injected this event" + /// apart from "a real adapter observed this" or "the daemon itself + /// produced this." The IPC boundary restricts which event names may be + /// tagged this way — it may not claim an adapter-owned namespace (see + /// `apps::is_reserved_domain`), but is otherwise free for custom/test + /// event names. *Since: v1.5* + Manual, /// BlueZ Bluetooth stack via D-Bus. Bluetooth, /// Shell precmd/preexec hooks (terminal command lifecycle, cwd changes). @@ -89,20 +111,65 @@ pub struct BreadEvent { pub source: AdapterSource, /// Structured event data. The shape depends on the event family. pub data: serde_json::Value, + /// Unique id for this specific event instance, assigned at construction. + /// + /// *Since: v1.5* — enables causality tracking (`caused_by`) across chains + /// of Lua modules that re-emit events from inside `bread.on` handlers. + pub id: String, + /// The `id` of the event whose Lua handler emitted this event via + /// `bread.emit()`, if any. + /// + /// `None` for events that originate outside any Lua handler invocation + /// (adapter-normalized events, IPC `emit`, daemon-internal sends like + /// `bread.system.startup` / `bread.profile.activated`). Populated only + /// when the event was constructed by `bread.emit()` while a subscriber + /// callback was synchronously running — see the "current dispatch id" + /// mechanism on `breadd`'s Lua engine. + /// + /// *Since: v1.5* + pub caused_by: Option, } impl BreadEvent { - /// Construct a new event with `timestamp` set to the current wall-clock. + /// Construct a new event with `timestamp` set to the current wall-clock, + /// a freshly generated `id`, and `caused_by` unset. pub fn new(event: impl Into, source: AdapterSource, data: serde_json::Value) -> Self { + Self::with_timestamp(event, now_unix_ms(), source, data) + } + + /// Construct a new event with an explicit `timestamp`, preserving the + /// originating signal's observed time instead of "now". Used by the + /// normalizer, which carries `RawEvent::timestamp` through unchanged. + /// + /// Like [`BreadEvent::new`], this always assigns a fresh `id` and leaves + /// `caused_by` unset — callers that need to thread causality set + /// `caused_by` on the returned value themselves. + pub fn with_timestamp( + event: impl Into, + timestamp: u64, + source: AdapterSource, + data: serde_json::Value, + ) -> Self { Self { event: event.into(), - timestamp: now_unix_ms(), + timestamp, source, data, + id: new_event_id(), + caused_by: None, } } } +/// Generate a fresh unique id for a [`BreadEvent`]. +/// +/// Every construction path (`BreadEvent::new`, `BreadEvent::with_timestamp`, +/// and any remaining struct-literal construction) calls this so every event +/// gets a stable identity to hang `caused_by` chains off of. +pub fn new_event_id() -> String { + uuid::Uuid::new_v4().to_string() +} + /// Current Unix epoch in milliseconds. /// /// Falls back to `0` if the system clock is before the epoch, which keeps @@ -221,6 +288,10 @@ mod tests { serde_json::to_string(&AdapterSource::System).unwrap(), "\"system\"" ); + assert_eq!( + serde_json::to_string(&AdapterSource::Manual).unwrap(), + "\"manual\"" + ); assert_eq!( serde_json::to_string(&AdapterSource::Bluetooth).unwrap(), "\"bluetooth\"" @@ -267,6 +338,7 @@ mod tests { AdapterSource::Power, AdapterSource::Network, AdapterSource::System, + AdapterSource::Manual, AdapterSource::Bluetooth, AdapterSource::Terminal, AdapterSource::Git, @@ -315,6 +387,8 @@ mod tests { timestamp: 1_700_000_000_000, source: AdapterSource::Udev, data: json!({ "id": "usb-1-1.4", "name": "Logitech" }), + id: "test-id-1".to_string(), + caused_by: Some("test-id-0".to_string()), }; let raw = serde_json::to_string(&original).unwrap(); let decoded: BreadEvent = serde_json::from_str(&raw).unwrap(); @@ -323,6 +397,30 @@ mod tests { assert_eq!(decoded.timestamp, original.timestamp); assert_eq!(decoded.source, original.source); assert_eq!(decoded.data, original.data); + assert_eq!(decoded.id, original.id); + assert_eq!(decoded.caused_by, original.caused_by); + } + + #[test] + fn bread_event_new_assigns_unique_id_and_no_cause() { + let a = BreadEvent::new("bread.test.a", AdapterSource::System, json!({})); + let b = BreadEvent::new("bread.test.b", AdapterSource::System, json!({})); + assert!(!a.id.is_empty()); + assert_ne!(a.id, b.id, "each constructed event should get a unique id"); + assert_eq!(a.caused_by, None); + } + + #[test] + fn bread_event_with_timestamp_preserves_timestamp_and_assigns_id() { + let event = BreadEvent::with_timestamp( + "bread.test.c", + 42, + AdapterSource::Udev, + json!({ "x": 1 }), + ); + assert_eq!(event.timestamp, 42); + assert!(!event.id.is_empty()); + assert_eq!(event.caused_by, None); } #[test] diff --git a/bread-shared/src/module_host_ipc.rs b/bread-shared/src/module_host_ipc.rs new file mode 100644 index 0000000..653cb7f --- /dev/null +++ b/bread-shared/src/module_host_ipc.rs @@ -0,0 +1,108 @@ +//! Wire types shared between `breadd`'s IPC server and the `bread-module-host` +//! client for the out-of-process module bridge (Workstream G). +//! +//! Living here (rather than duplicated as private structs in each crate) +//! means the two processes can't drift on what a `module_host.hello` +//! response or an async event/timer push looks like on the wire — the same +//! failure mode `ModulePermission`/`PermissionKind` already guard against +//! for the manifest schema (see `permissions.rs`). +//! +//! The request side (`{"id", "method", "params"}`) and the plain response +//! side (`{"id", "result"/"error"}`) are *not* duplicated here: they're +//! generic enough (a bare method+params envelope) that both ends already +//! define their own minimal local copy, and sharing a type for something +//! that's just "an id, a string, and a `Value`" buys little. What's shared +//! is the part that's easy to get subtly wrong across two independently +//! maintained crates: the exact shape of the one-time `hello` handshake +//! result and the tagged push-message envelope used for unsolicited +//! event/timer delivery on an otherwise request/response connection. + +use serde::{Deserialize, Serialize}; + +use crate::permissions::ModulePermission; +use crate::BreadEvent; + +/// The successful result of a `module_host.hello` call — what `breadd` +/// looked up for the presented one-time token, told back to the +/// `bread-module-host` process that presented it. Deliberately does not +/// trust anything the child process asserts about its own identity (see +/// `breadd/src/module_host.rs`'s token/registry doc comments) — this is +/// `breadd` telling the child who *it* has decided the child is, based on +/// which token was issued for which pending spawn. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ModuleHostHello { + pub module: String, + pub permissions: Vec, + pub api_version: String, +} + +/// An unsolicited message `breadd` pushes down an already-established +/// module-host connection, interleaved with ordinary request/response +/// lines. Distinguished on the wire by the `"push"` tag (internally-tagged +/// enum), which never collides with a plain `{"id", "result"/"error"}` +/// response envelope or an `{"id", "method", "params"}` request envelope — +/// neither of those ever carries a `"push"` key. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "push")] +pub enum ModuleHostPush { + /// A `bread.on`/`bread.once` subscription (registered via + /// `module_host.on`/`module_host.once`) matched an event. + #[serde(rename = "event")] + Event { + subscription_id: String, + event: BreadEvent, + }, + /// A `bread.after`/`bread.every` timer (registered via + /// `module_host.after`/`module_host.every`) fired. + #[serde(rename = "timer")] + Timer { timer_id: String }, +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{AdapterSource, PermissionKind}; + + #[test] + fn hello_round_trips() { + let hello = ModuleHostHello { + module: "wallpaper".to_string(), + permissions: vec![ModulePermission { + kind: PermissionKind::FsRead, + path: Some("~/Wallpapers".to_string()), + bin: None, + }], + api_version: "1.6.0".to_string(), + }; + let json = serde_json::to_string(&hello).unwrap(); + let back: ModuleHostHello = serde_json::from_str(&json).unwrap(); + assert_eq!(back.module, "wallpaper"); + assert_eq!(back.permissions.len(), 1); + } + + #[test] + fn push_event_tag_is_distinguishable_from_a_response_envelope() { + let push = ModuleHostPush::Event { + subscription_id: "sub-1".to_string(), + event: BreadEvent::new("bread.test.tick", AdapterSource::Manual, serde_json::json!({})), + }; + let value = serde_json::to_value(&push).unwrap(); + assert_eq!(value.get("push").and_then(|v| v.as_str()), Some("event")); + // A plain response envelope never has a "push" key — this is the + // disambiguator bread-module-host's read loop relies on. + assert!(value.get("id").is_none()); + } + + #[test] + fn push_timer_round_trips() { + let push = ModuleHostPush::Timer { + timer_id: "timer-1".to_string(), + }; + let json = serde_json::to_string(&push).unwrap(); + let back: ModuleHostPush = serde_json::from_str(&json).unwrap(); + match back { + ModuleHostPush::Timer { timer_id } => assert_eq!(timer_id, "timer-1"), + _ => panic!("wrong variant"), + } + } +} diff --git a/bread-shared/src/permissions.rs b/bread-shared/src/permissions.rs new file mode 100644 index 0000000..ba9ff08 --- /dev/null +++ b/bread-shared/src/permissions.rs @@ -0,0 +1,187 @@ +//! Structured module permission types for the capability-scoped module API. +//! +//! This is the `[[permissions]]` schema for `bread.module.toml`. It is shared +//! between `bread-cli` (which parses/writes the manifest on `bread modules +//! install`/`audit`) and `breadd` (which reads the same manifest to build a +//! capability-scoped Lua environment for third-party modules) so the two +//! never drift on what a permission "type" string means — see +//! `Documentation.md`'s "Capability-scoped modules" section for the full +//! baseline-vs-gated taxonomy this enum encodes. + +use serde::{Deserialize, Serialize}; + +/// One `[[permissions]]` entry in a module's `bread.module.toml`, e.g.: +/// +/// ```toml +/// [[permissions]] +/// type = "fs.read" +/// path = "~/Wallpapers" +/// ``` +/// +/// `path`/`bin` are optional scoping metadata (a filesystem path prefix, a +/// state-tree path, or a binary name). **They are not enforced by the +/// in-process Lua environment scoping `breadd` builds today** — that +/// mechanism only gates *presence* of a `bread.*` binding (a module without +/// `fs.read` sees `bread.fs == nil`, full stop). Recording the scoping +/// metadata now means manifests won't need a second migration when the +/// planned out-of-process module sandboxing workstream lands and actually +/// enforces path/bin matching per call — that enforcement is explicitly out +/// of scope here. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ModulePermission { + #[serde(rename = "type")] + pub kind: PermissionKind, + /// Scoping hint for `fs.read`/`fs.write` (a path prefix) or + /// `state.read`/`state.watch` (a dotted state-tree path, e.g. + /// `"monitors"`). Advisory only — see the struct-level doc. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub path: Option, + /// Scoping hint for `exec` (the binary name the module intends to run, + /// e.g. `"hyprpaper"`). Advisory only — see the struct-level doc. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub bin: Option, +} + +/// The permission taxonomy covering every capability-gated `bread.*` +/// binding. +/// +/// Not covered here because they're **baseline** (always available to every +/// module, gated or not — no real side effect, or a side effect a module +/// can't function at all without): `bread.on`/`once`/`filter`/`off`/`emit` +/// (event subscription is how a module does anything), `bread.after`/ +/// `every`/`cancel` (timers), `bread.json` (pure decode), `bread.module` +/// (required just to register), `bread.log`/`warn`/`error` (diagnostics), +/// `bread.debounce`/`spawn`/`wait`/`wait_any`/`wait_all`/`workflow` (pure +/// Lua sugar built entirely on top of the baseline primitives above). +/// +/// Gated because they touch the filesystem, spawn processes, control +/// hardware, or otherwise have a real side effect: +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub enum PermissionKind { + /// `bread.state.get`/`.monitors`/`.active_workspace`/`.active_window`/ + /// `.devices`/`.power`/`.network`/`.profile` — read-only snapshots of + /// daemon-maintained runtime state. + #[serde(rename = "state.read")] + StateRead, + /// `bread.state.watch` — a standing subscription to state changes, + /// gated separately from `state.read` since a long-lived watch is a + /// more persistent capability than a one-off read. + #[serde(rename = "state.watch")] + StateWatch, + /// `bread.profile.activate` — switches the daemon's system-wide active + /// profile, a real cross-module side effect. + #[serde(rename = "profile.activate")] + ProfileActivate, + /// `bread.exec` and `bread.exec_capture` — spawns an arbitrary shell + /// command. + #[serde(rename = "exec")] + Exec, + /// `bread.notify` — sends a desktop notification. + #[serde(rename = "notify")] + Notify, + /// `bread.machine.name`/`.tags`/`.has_tag` — reads hostname/tags, + /// including an optional on-disk `sync.toml`. + #[serde(rename = "machine")] + Machine, + /// `bread.hyprland.*` — compositor IPC (dispatch/keyword/eval read and + /// control the running Hyprland session). + #[serde(rename = "hyprland")] + Hyprland, + /// `bread.widget.*` — registers/updates/removes a rendered widget in a + /// sibling `bread*` app (breadbar). + #[serde(rename = "widget")] + Widget, + /// `bread.fs.read`/`.exists`/`.readlink`/`.expand` — read-only + /// filesystem access. + #[serde(rename = "fs.read")] + FsRead, + /// `bread.fs.write` — filesystem writes. + #[serde(rename = "fs.write")] + FsWrite, + /// `bread.bluetooth.*` — BlueZ control (power/connect/disconnect/scan). + #[serde(rename = "bluetooth")] + Bluetooth, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn permission_round_trips_through_toml_with_dotted_type_names() { + let toml_src = r#" + type = "fs.read" + path = "~/Wallpapers" + "#; + let perm: ModulePermission = toml::from_str(toml_src).unwrap(); + assert_eq!(perm.kind, PermissionKind::FsRead); + assert_eq!(perm.path.as_deref(), Some("~/Wallpapers")); + assert_eq!(perm.bin, None); + } + + #[test] + fn exec_permission_with_bin_round_trips() { + let toml_src = r#" + type = "exec" + bin = "hyprpaper" + "#; + let perm: ModulePermission = toml::from_str(toml_src).unwrap(); + assert_eq!(perm.kind, PermissionKind::Exec); + assert_eq!(perm.bin.as_deref(), Some("hyprpaper")); + } + + #[test] + fn permission_list_round_trips_as_array_of_tables() { + #[derive(Serialize, Deserialize)] + struct Wrapper { + #[serde(default)] + permissions: Option>, + } + + let w = Wrapper { + permissions: Some(vec![ + ModulePermission { + kind: PermissionKind::StateRead, + path: Some("monitors".to_string()), + bin: None, + }, + ModulePermission { + kind: PermissionKind::Exec, + path: None, + bin: Some("hyprpaper".to_string()), + }, + ]), + }; + let out = toml::to_string_pretty(&w).unwrap(); + assert!(out.contains("[[permissions]]")); + assert!(out.contains("type = \"state.read\"")); + assert!(out.contains("type = \"exec\"")); + + let back: Wrapper = toml::from_str(&out).unwrap(); + assert_eq!(back.permissions.unwrap().len(), 2); + } + + #[test] + fn missing_permissions_field_deserializes_to_none() { + #[derive(Serialize, Deserialize)] + struct Wrapper { + #[serde(default)] + permissions: Option>, + name: String, + } + let w: Wrapper = toml::from_str("name = \"x\"\n").unwrap(); + assert!(w.permissions.is_none()); + } + + #[test] + fn explicit_empty_permissions_deserializes_to_some_empty() { + #[derive(Serialize, Deserialize)] + struct Wrapper { + #[serde(default)] + permissions: Option>, + name: String, + } + let w: Wrapper = toml::from_str("name = \"x\"\npermissions = []\n").unwrap(); + assert_eq!(w.permissions, Some(vec![])); + } +} diff --git a/bread-shared/src/widget.rs b/bread-shared/src/widget.rs new file mode 100644 index 0000000..50d148b --- /dev/null +++ b/bread-shared/src/widget.rs @@ -0,0 +1,580 @@ +//! Wire types for Lua-declared bar widgets. +//! +//! A module running in breadd's Lua runtime can register a small declarative +//! node tree (see [`WidgetNode`]) that gets rendered generically by a +//! sibling `bread*` app (breadbar) in its bar or hamburger-popover free +//! space. These types are the shared contract between `breadd` (which +//! stores/validates/emits them from `bread.widget.*`) and any renderer. + +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +/// Maximum nesting depth of a widget's node tree (the root counts as depth 1). +pub const MAX_NODE_DEPTH: usize = 4; +/// Maximum total number of nodes (root + all descendants) in a widget's tree. +pub const MAX_NODE_COUNT: usize = 50; + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum Orientation { + Horizontal, + Vertical, +} + +/// One node in a widget's declarative render tree. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case", tag = "type")] +pub enum WidgetNode { + Box { + #[serde(default = "default_orientation")] + orientation: Orientation, + #[serde(default)] + spacing: Option, + #[serde(default)] + class: Option, + #[serde(default)] + style: Option, + #[serde(default)] + on_click: Option, + #[serde(default)] + children: Vec, + }, + Label { + text: String, + #[serde(default)] + class: Option, + #[serde(default)] + style: Option, + #[serde(default)] + on_click: Option, + }, + Icon { + #[serde(default)] + name: Option, + #[serde(default)] + path: Option, + #[serde(default)] + size: Option, + #[serde(default)] + class: Option, + #[serde(default)] + style: Option, + #[serde(default)] + on_click: Option, + }, + Progress { + value: f64, + #[serde(default)] + class: Option, + #[serde(default)] + style: Option, + #[serde(default)] + on_click: Option, + }, +} + +fn default_orientation() -> Orientation { + Orientation::Horizontal +} + +/// A bounded, typed vocabulary for a node's appearance — the alternative to +/// letting Lua hand the renderer a raw CSS/style string. Every field is a +/// small closed enum, so an invalid value is simply a deserialization error, +/// the same as any other malformed field; there is no free-text surface here +/// for a module to smuggle style-string injection through. +/// +/// Fields left `None` mean "renderer default" (see `render.rs`'s `build_node` +/// for what that default looks like), not "no style" — a node with no +/// `style` at all is fully equivalent to one whose every field is `None`. +#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)] +pub struct WidgetStyle { + pub color: Option, + pub weight: Option, + pub size: Option, + pub align: Option, + pub background: Option, + pub radius: Option, + pub padding: Option, +} + +/// Foreground/text colors, one per name `bread-theme`'s shared stylesheet +/// defines via `@define-color` (see that crate's `color_pairs()`). Deliberately +/// excludes `bg`/`surface`/`overlay`, which only make sense as backgrounds. +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum SemanticColor { + /// Foreground / body text color. + Fg, + /// Muted foreground — the existing `.dim` look, formalized. + Dim, + Accent, + Red, + Green, + Yellow, + Blue, + Pink, + Teal, +} + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum FontWeight { + Normal, + Bold, +} + +/// Text size scale (10/12/14/16/20px) — `sm`/`md` match `bread-theme::tokens`' +/// existing `FONT_SIZE_SECONDARY`/`FONT_SIZE_BASE` rather than inventing a +/// second set of magic numbers; `xs`/`lg`/`xl` fill out the rest of the scale +/// (the spacing scale's 4/8/12/16/20px is for padding/radius, not text — +/// applying it directly to `font-size` renders illegibly at the small end). +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum TextSize { + Xs, + Sm, + Md, + Lg, + Xl, +} + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum Align { + Start, + Center, + End, +} + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum Background { + None, + Surface, + Card, +} + +/// Reuses `bread-theme::tokens`' radius scale: `sm` = tertiary (4px, small +/// interactive elements), `md` = primary (8px), `full` = pill (999px). +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum Radius { + None, + Sm, + Md, + Full, +} + +/// Reuses `bread-theme::tokens`' spacing scale (4/8/12px). +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum Padding { + None, + Xs, + Sm, + Md, +} + +/// Where a widget renders in breadbar. Each variant names a fixed slot in +/// breadbar's existing `CenterBox` layout (workspaces | clock | stats), plus +/// the hamburger control-panel popover's tray section. +#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq, Hash)] +#[serde(rename_all = "snake_case")] +pub enum WidgetPlacement { + /// Tucked inside the hamburger control-panel popover, alongside the + /// existing SNI tray icons. + Tray, + /// In the center section, immediately left of the clock label. + LeftOfClock, + /// In the center section, immediately right of the clock label. + RightOfClock, + /// In the start section, immediately right of the workspace buttons. + RightOfWorkspaces, + /// In the end section, immediately left of the CPU/RAM/power/battery group. + LeftOfStats, +} + +/// A full widget declaration, as stored in `RuntimeState.widgets` and +/// returned by the `widgets.list` IPC method. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct WidgetSpec { + /// Fully-qualified id: `"."`. Unique across all widgets. + pub id: String, + /// Name of the module that registered this widget. + pub module: String, + pub placement: WidgetPlacement, + /// Sort priority within a placement; lower sorts first. + #[serde(default)] + pub order: i32, + #[serde(default = "default_visible")] + pub visible: bool, + #[serde(default)] + pub tooltip: Option, + pub root: WidgetNode, + /// Unix epoch milliseconds of the last register/update. + pub updated_at: u64, +} + +fn default_visible() -> bool { + true +} + +/// Why a [`WidgetNode`] tree failed validation. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum WidgetValidationError { + TooDeep { max: usize }, + TooManyNodes { max: usize }, + InvalidClass { class: String }, +} + +impl std::fmt::Display for WidgetValidationError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::TooDeep { max } => write!(f, "widget node tree exceeds max depth of {max}"), + Self::TooManyNodes { max } => { + write!(f, "widget node tree exceeds max node count of {max}") + } + Self::InvalidClass { class } => write!( + f, + "invalid css class '{class}': must match ^[a-zA-Z][a-zA-Z0-9_-]{{0,63}}$" + ), + } + } +} + +impl std::error::Error for WidgetValidationError {} + +/// A CSS class is restricted to a conservative identifier shape so widget +/// styling can only opt into classes predefined in breadbar's stylesheet — +/// there is no raw style/CSS injection surface from Lua. +fn is_valid_class(class: &str) -> bool { + let mut chars = class.chars(); + let Some(first) = chars.next() else { + return false; + }; + if !first.is_ascii_alphabetic() { + return false; + } + class.len() <= 64 + && chars.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') +} + +impl WidgetNode { + /// The node's CSS class hook, if any — a renderer should apply this via + /// its GTK equivalent of `add_css_class` rather than injecting raw style. + pub fn class(&self) -> Option<&str> { + match self { + Self::Box { class, .. } + | Self::Label { class, .. } + | Self::Icon { class, .. } + | Self::Progress { class, .. } => class.as_deref(), + } + } + + /// The node's typed style vocabulary, if any — a renderer maps each + /// `Some` field to a predefined CSS class (see `render.rs`'s + /// `apply_style`), never to raw injected CSS. + pub fn style(&self) -> Option<&WidgetStyle> { + match self { + Self::Box { style, .. } + | Self::Label { style, .. } + | Self::Icon { style, .. } + | Self::Progress { style, .. } => style.as_ref(), + } + } + + /// The node's opaque click payload, if any — a renderer attaches a click + /// handler that reports this value back verbatim (see the Lua API's + /// "Click events" contract in `Documentation.md`), it never interprets it. + pub fn on_click(&self) -> Option<&Value> { + match self { + Self::Box { on_click, .. } + | Self::Label { on_click, .. } + | Self::Icon { on_click, .. } + | Self::Progress { on_click, .. } => on_click.as_ref(), + } + } + + fn children(&self) -> &[WidgetNode] { + match self { + Self::Box { children, .. } => children, + _ => &[], + } + } + + /// Validate depth, total node count, and every `class` field. Call this + /// on any tree received from Lua before storing or broadcasting it. + pub fn validate(&self) -> Result<(), WidgetValidationError> { + let mut total = 0usize; + self.validate_inner(1, &mut total) + } + + fn validate_inner( + &self, + depth: usize, + total: &mut usize, + ) -> Result<(), WidgetValidationError> { + if depth > MAX_NODE_DEPTH { + return Err(WidgetValidationError::TooDeep { max: MAX_NODE_DEPTH }); + } + *total += 1; + if *total > MAX_NODE_COUNT { + return Err(WidgetValidationError::TooManyNodes { max: MAX_NODE_COUNT }); + } + if let Some(class) = self.class() { + if !is_valid_class(class) { + return Err(WidgetValidationError::InvalidClass { + class: class.to_string(), + }); + } + } + for child in self.children() { + child.validate_inner(depth + 1, total)?; + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn label(class: Option<&str>) -> WidgetNode { + WidgetNode::Label { + text: "x".to_string(), + class: class.map(str::to_string), + style: None, + on_click: None, + } + } + + fn box_of(children: Vec) -> WidgetNode { + WidgetNode::Box { + orientation: Orientation::Horizontal, + spacing: None, + class: None, + style: None, + on_click: None, + children, + } + } + + #[test] + fn simple_label_is_valid() { + assert!(label(Some("dim")).validate().is_ok()); + } + + #[test] + fn rejects_invalid_class_characters() { + assert_eq!( + label(Some("dim; color: red")).validate(), + Err(WidgetValidationError::InvalidClass { + class: "dim; color: red".to_string() + }) + ); + } + + #[test] + fn rejects_class_starting_with_digit() { + assert!(label(Some("1dim")).validate().is_err()); + } + + #[test] + fn rejects_empty_class() { + assert!(label(Some("")).validate().is_err()); + } + + #[test] + fn accepts_class_with_underscore_and_hyphen() { + assert!(label(Some("my_class-2")).validate().is_ok()); + } + + #[test] + fn rejects_tree_deeper_than_max() { + // depth 1 (root box) -> 2 -> 3 -> 4 -> 5 (label), exceeds MAX_NODE_DEPTH=4 + let tree = box_of(vec![box_of(vec![box_of(vec![box_of(vec![label(None)])])])]); + assert_eq!( + tree.validate(), + Err(WidgetValidationError::TooDeep { max: MAX_NODE_DEPTH }) + ); + } + + #[test] + fn accepts_tree_at_max_depth() { + // depth 1 -> 2 -> 3 -> 4 (label), exactly MAX_NODE_DEPTH + let tree = box_of(vec![box_of(vec![box_of(vec![label(None)])])]); + assert!(tree.validate().is_ok()); + } + + #[test] + fn rejects_too_many_nodes() { + let children: Vec = (0..MAX_NODE_COUNT).map(|_| label(None)).collect(); + let tree = box_of(children); + assert_eq!( + tree.validate(), + Err(WidgetValidationError::TooManyNodes { max: MAX_NODE_COUNT }) + ); + } + + #[test] + fn accepts_node_count_at_max() { + let children: Vec = (0..MAX_NODE_COUNT - 1).map(|_| label(None)).collect(); + let tree = box_of(children); + assert!(tree.validate().is_ok()); + } + + #[test] + fn widget_spec_round_trips_through_json() { + let spec = WidgetSpec { + id: "weather.temp".to_string(), + module: "weather".to_string(), + placement: WidgetPlacement::LeftOfStats, + order: 10, + visible: true, + tooltip: Some("Sydney".to_string()), + root: box_of(vec![ + WidgetNode::Icon { + name: Some("cloud".to_string()), + path: None, + size: Some(16), + class: None, + style: None, + on_click: None, + }, + label(Some("dim")), + WidgetNode::Progress { + value: 0.5, + class: None, + style: Some(WidgetStyle { + color: Some(SemanticColor::Accent), + ..Default::default() + }), + on_click: Some(json!({ "action": "refresh" })), + }, + ]), + updated_at: 1_700_000_000_000, + }; + let raw = serde_json::to_string(&spec).unwrap(); + let decoded: WidgetSpec = serde_json::from_str(&raw).unwrap(); + assert_eq!(decoded.id, spec.id); + assert_eq!(decoded.placement, spec.placement); + } + + #[test] + fn placement_serializes_as_snake_case() { + assert_eq!( + serde_json::to_string(&WidgetPlacement::Tray).unwrap(), + "\"tray\"" + ); + assert_eq!( + serde_json::to_string(&WidgetPlacement::LeftOfClock).unwrap(), + "\"left_of_clock\"" + ); + assert_eq!( + serde_json::to_string(&WidgetPlacement::RightOfClock).unwrap(), + "\"right_of_clock\"" + ); + assert_eq!( + serde_json::to_string(&WidgetPlacement::RightOfWorkspaces).unwrap(), + "\"right_of_workspaces\"" + ); + assert_eq!( + serde_json::to_string(&WidgetPlacement::LeftOfStats).unwrap(), + "\"left_of_stats\"" + ); + } + + #[test] + fn node_serializes_with_type_tag() { + let value = serde_json::to_value(label(Some("dim"))).unwrap(); + assert_eq!(value["type"], "label"); + assert_eq!(value["text"], "x"); + assert_eq!(value["class"], "dim"); + } + + #[test] + fn node_without_style_omits_it_when_serialized_and_back() { + let node = label(None); + assert!(node.style().is_none()); + let raw = serde_json::to_string(&node).unwrap(); + let decoded: WidgetNode = serde_json::from_str(&raw).unwrap(); + assert!(decoded.style().is_none()); + } + + #[test] + fn style_field_is_optional_when_absent_from_json() { + let raw = json!({ "type": "label", "text": "x" }); + let node: WidgetNode = serde_json::from_value(raw).unwrap(); + assert!(node.style().is_none()); + } + + #[test] + fn style_round_trips_through_json() { + let node = WidgetNode::Label { + text: "x".to_string(), + class: None, + style: Some(WidgetStyle { + color: Some(SemanticColor::Red), + weight: Some(FontWeight::Bold), + size: Some(TextSize::Lg), + align: Some(Align::Center), + background: Some(Background::Card), + radius: Some(Radius::Sm), + padding: Some(Padding::Xs), + }), + on_click: None, + }; + let raw = serde_json::to_string(&node).unwrap(); + let decoded: WidgetNode = serde_json::from_str(&raw).unwrap(); + let style = decoded.style().expect("style should round-trip"); + assert_eq!(style.color, Some(SemanticColor::Red)); + assert_eq!(style.weight, Some(FontWeight::Bold)); + assert_eq!(style.size, Some(TextSize::Lg)); + assert_eq!(style.align, Some(Align::Center)); + assert_eq!(style.background, Some(Background::Card)); + assert_eq!(style.radius, Some(Radius::Sm)); + assert_eq!(style.padding, Some(Padding::Xs)); + } + + #[test] + fn style_enums_serialize_as_snake_case() { + assert_eq!(serde_json::to_string(&SemanticColor::Dim).unwrap(), "\"dim\""); + assert_eq!(serde_json::to_string(&Background::None).unwrap(), "\"none\""); + assert_eq!(serde_json::to_string(&Radius::Full).unwrap(), "\"full\""); + assert_eq!(serde_json::to_string(&Padding::Xs).unwrap(), "\"xs\""); + assert_eq!(serde_json::to_string(&Align::End).unwrap(), "\"end\""); + assert_eq!(serde_json::to_string(&FontWeight::Bold).unwrap(), "\"bold\""); + } + + #[test] + fn invalid_style_color_fails_to_deserialize() { + let raw = json!({ "type": "label", "text": "x", "style": { "color": "bg" } }); + assert!(serde_json::from_value::(raw).is_err()); + } + + #[test] + fn style_with_all_fields_none_is_equivalent_to_default() { + assert_eq!( + serde_json::to_value(WidgetStyle::default()).unwrap(), + json!({ + "color": null, "weight": null, "size": null, + "align": null, "background": null, "radius": null, "padding": null + }) + ); + } + + #[test] + fn style_does_not_affect_validation() { + let node = WidgetNode::Label { + text: "x".to_string(), + class: None, + style: Some(WidgetStyle { + color: Some(SemanticColor::Accent), + ..Default::default() + }), + on_click: None, + }; + assert!(node.validate().is_ok()); + } +} diff --git a/breadd/Cargo.toml b/breadd/Cargo.toml index 599e0dd..03d402c 100644 --- a/breadd/Cargo.toml +++ b/breadd/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "breadd" -version = "0.7.0" +version = "0.8.0" edition = "2021" [dependencies] @@ -22,6 +22,8 @@ netlink-packet-route = "0.11" netlink-packet-core = "0.4" libc = "0.2" notify = "6.1" +landlock.workspace = true +uuid.workspace = true [dev-dependencies] tempfile.workspace = true diff --git a/breadd/src/adapters/hyprland.rs b/breadd/src/adapters/hyprland.rs index 2c4a47b..7778d91 100644 --- a/breadd/src/adapters/hyprland.rs +++ b/breadd/src/adapters/hyprland.rs @@ -4,7 +4,7 @@ use std::path::PathBuf; use anyhow::{anyhow, Result}; use bread_shared::{now_unix_ms, AdapterSource, RawEvent}; use serde_json::json; -use tokio::io::{AsyncBufReadExt, BufReader}; +use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}; use tokio::net::UnixStream; use tokio::sync::mpsc; use tracing::{debug, warn}; @@ -24,6 +24,13 @@ impl Adapter for HyprlandAdapter { debug!("hyprland adapter started"); let socket = hyprland_event_socket()?; let stream = UnixStream::connect(&socket).await?; + // Snapshot current compositor topology *after* the event socket is + // connected so we don't miss a change that lands during the query, + // then apply the snapshot first so bread.state is populated before + // the live stream. Failure is non-fatal: live events still work. + if let Err(e) = emit_topology_snapshot(&tx).await { + warn!("hyprland topology snapshot failed: {e}"); + } let reader = BufReader::new(stream); let mut lines = reader.lines(); @@ -83,6 +90,53 @@ fn hyprland_event_socket() -> Result { } } +/// Request socket sits next to `.socket2.sock` as `.socket.sock`. +fn hyprland_request_socket() -> Result { + let events = hyprland_event_socket()?; + let parent = events + .parent() + .ok_or_else(|| anyhow!("hyprland event socket has no parent dir"))?; + Ok(parent.join(".socket.sock")) +} + +async fn hyprland_request_json(request: &str) -> Result { + let path = hyprland_request_socket()?; + let mut stream = UnixStream::connect(&path).await?; + stream.write_all(request.as_bytes()).await?; + stream.shutdown().await?; + let mut buf = String::new(); + stream.read_to_string(&mut buf).await?; + serde_json::from_str(&buf) + .map_err(|e| anyhow!("hyprland {request} JSON: {e}")) +} + +/// Query current monitors / workspaces / focus and emit one +/// `hyprland.snapshot` RawEvent. The normalizer turns that into +/// `bread.hyprland.snapshot`; the state engine replaces topology from it. +async fn emit_topology_snapshot(tx: &mpsc::Sender) -> Result<()> { + let monitors = hyprland_request_json("j/monitors").await.unwrap_or(json!([])); + let workspaces = hyprland_request_json("j/workspaces") + .await + .unwrap_or(json!([])); + let active_workspace = hyprland_request_json("j/activeworkspace").await.ok(); + let active_window = hyprland_request_json("j/activewindow").await.ok(); + + tx.send(RawEvent { + source: AdapterSource::Hyprland, + kind: "hyprland.snapshot".to_string(), + payload: json!({ + "monitors": monitors, + "workspaces": workspaces, + "active_workspace": active_workspace, + "active_window": active_window, + }), + timestamp: now_unix_ms(), + }) + .await + .map_err(|_| anyhow!("raw channel closed during hyprland snapshot"))?; + Ok(()) +} + fn parse_hyprland_line(line: &str) -> (String, String) { if let Some((kind, data)) = line.split_once(">>") { return (kind.to_string(), data.to_string()); diff --git a/breadd/src/adapters/udev.rs b/breadd/src/adapters/udev.rs index 8142980..2744703 100644 --- a/breadd/src/adapters/udev.rs +++ b/breadd/src/adapters/udev.rs @@ -2,7 +2,7 @@ use std::os::unix::io::AsRawFd; use anyhow::Result; use bread_shared::{now_unix_ms, AdapterSource, RawEvent}; -use serde_json::json; +use serde_json::{json, Value}; use tokio::sync::mpsc; use tracing::debug; @@ -19,20 +19,13 @@ impl UdevAdapter { } pub async fn enumerate_existing(&self, tx: &mpsc::Sender) -> Result<()> { - let devices = enumerate_with_udev(&self.subsystems)?; - for device in devices { - tx.send(RawEvent { - source: AdapterSource::Udev, - kind: "udev.enumerate".to_string(), - payload: json!({ - "action": "add", - "id": device.id, - "name": device.name, - "subsystem": device.subsystem, - }), - timestamp: now_unix_ms(), - }) - .await?; + let mut enumerator = udev::Enumerator::new()?; + for subsystem in &self.subsystems { + enumerator.match_subsystem(subsystem)?; + } + for device in enumerator.scan_devices()? { + tx.send(build_device_event(&device, "add", "udev.enumerate")) + .await?; } Ok(()) } @@ -50,12 +43,6 @@ impl Adapter for UdevAdapter { } } -struct ScannedDevice { - id: String, - name: String, - subsystem: String, -} - // udev::MonitorSocket uses a non-blocking socket; calling iter().next() without // first polling the fd returns None immediately and exits the loop — which is // why the old code silently fell back to sysfs on every start. We use poll(2) @@ -110,81 +97,157 @@ fn build_event(event: &udev::Event) -> RawEvent { .action() .map(|a| a.to_string_lossy().to_string()) .unwrap_or_else(|| "change".to_string()); - let subsystem = event + build_device_event(event, &action, "udev.change") +} + +/// Shared live/enumerate payload. `udev::Event` deref's to `Device`, so +/// boot-time enumerate of an already-plugged device is equivalent to an +/// `add` of that same device (same identity + classification fields +/// `resolve_device` needs). +fn build_device_event(device: &udev::Device, action: &str, kind: &str) -> RawEvent { + let subsystem = device .subsystem() .map(|s| s.to_string_lossy().to_string()) .unwrap_or_else(|| "unknown".to_string()); - let name = event + let name = device .property_value("ID_MODEL") - .or_else(|| event.property_value("NAME")) + .or_else(|| device.property_value("NAME")) .map(|v| v.to_string_lossy().to_string()) - .or_else(|| event.devnode().map(|n| n.display().to_string())) + .or_else(|| device.devnode().map(|n| n.display().to_string())) .unwrap_or_else(|| "unknown".to_string()); - let id = event.syspath().to_string_lossy().to_string(); + let id = device.syspath().to_string_lossy().to_string(); RawEvent { source: AdapterSource::Udev, - kind: "udev.change".to_string(), - payload: json!({ - "action": action, - "id": id, - "name": name, - "subsystem": subsystem, - "id_input_keyboard": prop_bool(event, "ID_INPUT_KEYBOARD"), - "id_input_mouse": prop_bool(event, "ID_INPUT_MOUSE"), - "id_input_joystick": prop_bool(event, "ID_INPUT_JOYSTICK"), - "id_input_touchpad": prop_bool(event, "ID_INPUT_TOUCHPAD"), - "id_input_tablet": prop_bool(event, "ID_INPUT_TABLET"), - "id_usb_class": prop_str(event, "ID_USB_CLASS"), - "id_usb_interfaces": prop_str(event, "ID_USB_INTERFACES"), - "id_vendor": prop_str(event, "ID_VENDOR"), - "id_model": prop_str(event, "ID_MODEL"), - "vendor_id": prop_str(event, "ID_VENDOR_ID"), - "product_id": prop_str(event, "ID_MODEL_ID"), - }), + kind: kind.to_string(), + payload: udev_event_payload( + action, + &id, + &name, + &subsystem, + UdevClassification::from_device(device), + ), timestamp: now_unix_ms(), } } -fn enumerate_with_udev(subsystems: &[String]) -> Result> { - let mut enumerator = udev::Enumerator::new()?; - for subsystem in subsystems { - enumerator.match_subsystem(subsystem)?; - } - - let mut out = Vec::new(); - for dev in enumerator.scan_devices()? { - let subsystem = dev - .subsystem() - .map(|s| s.to_string_lossy().to_string()) - .unwrap_or_else(|| "unknown".to_string()); - let name = dev - .property_value("ID_MODEL") - .or_else(|| dev.property_value("NAME")) - .map(|v| v.to_string_lossy().to_string()) - .or_else(|| dev.sysname().to_str().map(ToString::to_string)) - .unwrap_or_else(|| "unknown".to_string()); - let id = dev.syspath().to_string_lossy().to_string(); - out.push(ScannedDevice { - id, - name, - subsystem, - }); - } - - Ok(out) +/// Classification / identity fields copied onto every udev payload so +/// `resolve_device` can name a device after boot the same way it names a +/// live plug-in. +struct UdevClassification { + id_input_keyboard: bool, + id_input_mouse: bool, + id_input_joystick: bool, + id_input_touchpad: bool, + id_input_tablet: bool, + id_usb_class: Option, + id_usb_interfaces: Option, + id_vendor: Option, + id_model: Option, + vendor_id: Option, + product_id: Option, } -fn prop_bool(event: &udev::Event, key: &str) -> bool { - event +impl UdevClassification { + fn from_device(device: &udev::Device) -> Self { + Self { + id_input_keyboard: prop_bool(device, "ID_INPUT_KEYBOARD"), + id_input_mouse: prop_bool(device, "ID_INPUT_MOUSE"), + id_input_joystick: prop_bool(device, "ID_INPUT_JOYSTICK"), + id_input_touchpad: prop_bool(device, "ID_INPUT_TOUCHPAD"), + id_input_tablet: prop_bool(device, "ID_INPUT_TABLET"), + id_usb_class: prop_str(device, "ID_USB_CLASS"), + id_usb_interfaces: prop_str(device, "ID_USB_INTERFACES"), + id_vendor: prop_str(device, "ID_VENDOR"), + id_model: prop_str(device, "ID_MODEL"), + vendor_id: prop_str(device, "ID_VENDOR_ID"), + product_id: prop_str(device, "ID_MODEL_ID"), + } + } +} + +fn udev_event_payload( + action: &str, + id: &str, + name: &str, + subsystem: &str, + class: UdevClassification, +) -> Value { + json!({ + "action": action, + "id": id, + "name": name, + "subsystem": subsystem, + "id_input_keyboard": class.id_input_keyboard, + "id_input_mouse": class.id_input_mouse, + "id_input_joystick": class.id_input_joystick, + "id_input_touchpad": class.id_input_touchpad, + "id_input_tablet": class.id_input_tablet, + "id_usb_class": class.id_usb_class, + "id_usb_interfaces": class.id_usb_interfaces, + "id_vendor": class.id_vendor, + "id_model": class.id_model, + "vendor_id": class.vendor_id, + "product_id": class.product_id, + }) +} + +fn prop_bool(device: &udev::Device, key: &str) -> bool { + device .property_value(key) .and_then(|v| v.to_str()) .map(|v| v == "1") .unwrap_or(false) } -fn prop_str(event: &udev::Event, key: &str) -> Option { - event +fn prop_str(device: &udev::Device, key: &str) -> Option { + device .property_value(key) .map(|v| v.to_string_lossy().to_string()) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn enumerate_payload_includes_classification_fields() { + // Boot-time enumerate used to send only {action,id,name,subsystem}, + // so resolve_device could never match vendor/product/input rules + // and bread.state.devices stayed "unknown" until the next unplug. + let payload = udev_event_payload( + "add", + "/sys/devices/pci0000:00/usb1/1-3", + "Keychron K2", + "usb", + UdevClassification { + id_input_keyboard: true, + id_input_mouse: false, + id_input_joystick: false, + id_input_touchpad: false, + id_input_tablet: false, + id_usb_class: None, + id_usb_interfaces: None, + id_vendor: Some("Keychron".into()), + id_model: Some("Keychron K2".into()), + vendor_id: Some("3434".into()), + product_id: Some("d030".into()), + }, + ); + assert_eq!(payload["action"], "add"); + assert_eq!(payload["id"], "/sys/devices/pci0000:00/usb1/1-3"); + assert_eq!(payload["name"], "Keychron K2"); + assert_eq!(payload["subsystem"], "usb"); + assert_eq!(payload["vendor_id"], "3434"); + assert_eq!(payload["product_id"], "d030"); + assert_eq!(payload["id_vendor"], "Keychron"); + assert_eq!(payload["id_model"], "Keychron K2"); + assert_eq!(payload["id_input_keyboard"], true); + assert_eq!(payload["id_input_mouse"], false); + assert_eq!(payload["id_input_joystick"], false); + assert_eq!(payload["id_input_touchpad"], false); + assert_eq!(payload["id_input_tablet"], false); + assert!(payload["id_usb_class"].is_null()); + assert!(payload["id_usb_interfaces"].is_null()); + } +} diff --git a/breadd/src/core/config.rs b/breadd/src/core/config.rs index 3ce75c5..d54b639 100644 --- a/breadd/src/core/config.rs +++ b/breadd/src/core/config.rs @@ -19,6 +19,8 @@ pub struct Config { pub notifications: NotificationsConfig, #[serde(default)] pub events: EventsConfig, + #[serde(default)] + pub compat: CompatConfig, } #[derive(Debug, Clone, Deserialize)] @@ -119,6 +121,22 @@ pub struct EventsConfig { pub dedup_window_ms: u64, } +/// Deprecation-window toggles for backwards compatibility with pre-namespace +/// event names. See `[compat]` in `breadd.toml` / `Documentation.md`'s +/// Hyprland event reference for the migration this gates. +#[derive(Debug, Clone, Deserialize)] +pub struct CompatConfig { + /// When `true` (the default during the deprecation window), the Hyprland + /// adapter dual-emits both its legacy flat event names (e.g. + /// `bread.workspace.changed`) and their namespaced `bread.hyprland.*` + /// equivalents (e.g. `bread.hyprland.workspace.changed`). Set to `false` + /// to suppress the legacy names and emit only the namespaced ones — this + /// will become the default in a later release once the deprecation + /// window closes. + #[serde(default = "default_true")] + pub legacy_hyprland_event_names: bool, +} + #[derive(Debug, Clone, Deserialize)] pub struct NotificationsConfig { #[serde(default = "default_notify_timeout")] @@ -218,6 +236,14 @@ impl Default for NotificationsConfig { } } +impl Default for CompatConfig { + fn default() -> Self { + Self { + legacy_hyprland_event_names: default_true(), + } + } +} + impl Config { pub fn load() -> Result { let path = config_path(); @@ -256,6 +282,19 @@ fn config_path() -> PathBuf { expand_home("~/.config/bread/breadd.toml") } +/// Location of the optional `rules.toml` — declarative automation rules +/// (see `crate::core::rules`). Resolved with the exact same +/// `XDG_CONFIG_HOME`-vs-`HOME` precedence as `config_path()` above; see the +/// `expand_home` doc comment for why every config-adjacent path the daemon +/// resolves has to agree on that precedence. +pub fn rules_path() -> PathBuf { + if let Ok(xdg) = env::var("XDG_CONFIG_HOME") { + return Path::new(&xdg).join("bread").join("rules.toml"); + } + + expand_home("~/.config/bread/rules.toml") +} + /// Expands a leading `~/`. `~/.config/...` paths specifically prefer /// `$XDG_CONFIG_HOME` when it's set, consistent with `config_path()`'s own /// resolution of `breadd.toml` itself — otherwise the default `lua.entry_point` @@ -264,7 +303,7 @@ fn config_path() -> PathBuf { /// though the config file that sets them was found via that same variable, /// which is exactly the kind of inconsistency that made init.lua/module /// loading silently no-op for a XDG_CONFIG_HOME-only test setup. -fn expand_home(input: &str) -> PathBuf { +pub(crate) fn expand_home(input: &str) -> PathBuf { if let Some(stripped) = input.strip_prefix("~/.config/") { if let Ok(xdg_config) = env::var("XDG_CONFIG_HOME") { return Path::new(&xdg_config).join(stripped); @@ -379,6 +418,7 @@ mod tests { assert_eq!(cfg.notifications.notify_send_path, "notify-send"); assert!(cfg.modules.builtin); assert!(cfg.modules.disable.is_empty()); + assert!(cfg.compat.legacy_hyprland_event_names); } #[test] @@ -394,6 +434,7 @@ mod tests { let cfg: Config = toml::from_str("").unwrap(); assert_eq!(cfg.daemon.log_level, "info"); assert!(cfg.adapters.hyprland.enabled); + assert!(cfg.compat.legacy_hyprland_event_names); } #[test] @@ -435,6 +476,9 @@ dedup_window_ms = 250 default_timeout_ms = 1000 default_urgency = "critical" notify_send_path = "/usr/local/bin/notify-send" + +[compat] +legacy_hyprland_event_names = false "#; let cfg: Config = toml::from_str(raw).unwrap(); assert_eq!(cfg.daemon.log_level, "debug"); @@ -453,6 +497,7 @@ notify_send_path = "/usr/local/bin/notify-send" assert_eq!(cfg.events.dedup_window_ms, 250); assert_eq!(cfg.notifications.default_timeout_ms, 1000); assert_eq!(cfg.notifications.default_urgency, "critical"); + assert!(!cfg.compat.legacy_hyprland_event_names); } #[test] @@ -466,6 +511,23 @@ log_level = "trace" // Untouched sections still get their defaults. assert!(cfg.adapters.hyprland.enabled); assert_eq!(cfg.events.dedup_window_ms, 100); + assert!(cfg.compat.legacy_hyprland_event_names); + } + + #[test] + fn compat_section_defaults_legacy_hyprland_names_to_true() { + let cfg = Config::default(); + assert!(cfg.compat.legacy_hyprland_event_names); + } + + #[test] + fn compat_section_can_disable_legacy_hyprland_names() { + let raw = r#" +[compat] +legacy_hyprland_event_names = false +"#; + let cfg: Config = toml::from_str(raw).unwrap(); + assert!(!cfg.compat.legacy_hyprland_event_names); } #[test] @@ -586,4 +648,25 @@ log_level = "trace" PathBuf::from("/synthetic/home/.config/bread/breadd.toml") ); } + + #[test] + fn rules_path_respects_xdg_config_home() { + let _g = EnvGuard::new(&["XDG_CONFIG_HOME", "HOME"]); + std::env::set_var("XDG_CONFIG_HOME", "/synthetic/xdg-config"); + assert_eq!( + rules_path(), + PathBuf::from("/synthetic/xdg-config/bread/rules.toml") + ); + } + + #[test] + fn rules_path_falls_back_to_home_when_no_xdg() { + let _g = EnvGuard::new(&["XDG_CONFIG_HOME", "HOME"]); + std::env::remove_var("XDG_CONFIG_HOME"); + std::env::set_var("HOME", "/synthetic/home"); + assert_eq!( + rules_path(), + PathBuf::from("/synthetic/home/.config/bread/rules.toml") + ); + } } diff --git a/breadd/src/core/mod.rs b/breadd/src/core/mod.rs index bdb2e19..cffd9da 100644 --- a/breadd/src/core/mod.rs +++ b/breadd/src/core/mod.rs @@ -1,5 +1,6 @@ pub mod config; pub mod normalizer; +pub mod rules; pub mod state_engine; pub mod subscriptions; pub mod supervisor; diff --git a/breadd/src/core/normalizer.rs b/breadd/src/core/normalizer.rs index 96e40c8..d765296 100644 --- a/breadd/src/core/normalizer.rs +++ b/breadd/src/core/normalizer.rs @@ -1,7 +1,10 @@ use std::collections::HashMap; use std::sync::RwLock; -use bread_shared::{apps::validate_app_namespace, AdapterSource, BreadEvent, RawEvent}; +use bread_shared::{ + apps::{validate_app_namespace, validate_command_event}, + AdapterSource, BreadEvent, RawEvent, +}; use serde_json::{json, Value}; /// How many multiples of `dedup_window_ms` an entry must be idle before eviction. @@ -14,6 +17,11 @@ pub struct EventNormalizer { /// fired within the current window, so subsequent child-node events from the /// same plug-in are suppressed at the normalizer level. seen_devices: RwLock>, + /// Mirrors `[compat] legacy_hyprland_event_names` in `breadd.toml`. When + /// `true` (the default during the deprecation window), `normalize_hyprland` + /// dual-emits both its legacy flat event names and their namespaced + /// `bread.hyprland.*` equivalents. See `with_legacy_hyprland_event_names`. + legacy_hyprland_event_names: bool, } impl EventNormalizer { @@ -22,9 +30,21 @@ impl EventNormalizer { dedup_window_ms, recent: RwLock::new(HashMap::new()), seen_devices: RwLock::new(HashMap::new()), + legacy_hyprland_event_names: true, } } + /// Overrides whether the Hyprland adapter's legacy flat event names + /// (`bread.workspace.changed` etc.) keep firing alongside their + /// `bread.hyprland.*` equivalents. Defaults to `true` via `new`, mirroring + /// `[compat] legacy_hyprland_event_names`'s documented default during the + /// deprecation window; `main.rs` overrides this from + /// `config.compat.legacy_hyprland_event_names`. + pub fn with_legacy_hyprland_event_names(mut self, enabled: bool) -> Self { + self.legacy_hyprland_event_names = enabled; + self + } + pub fn normalize(&self, raw: &RawEvent) -> Vec { let mut out = match &raw.source { AdapterSource::Udev => self.normalize_udev(raw), @@ -43,6 +63,23 @@ impl EventNormalizer { event: raw.kind.clone(), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, + data: raw.payload.clone(), + }], + // `Manual` is never constructed as a `RawEvent::source` in this + // codebase — the IPC boundary's unsourced `emit` path builds a + // `BreadEvent` directly (see `breadd/src/ipc/mod.rs`), bypassing + // this normalizer entirely, exactly as `System` did before it. + // This arm exists only so the match stays exhaustive; if that + // ever changes, pass-through (like `System`) is the sane default + // rather than silently dropping the event. + AdapterSource::Manual => vec![BreadEvent { + event: raw.kind.clone(), + timestamp: raw.timestamp, + source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }], }; @@ -143,6 +180,8 @@ impl EventNormalizer { event: format!("bread.device.{}", verb), timestamp: raw.timestamp, source: AdapterSource::Udev, + id: bread_shared::new_event_id(), + caused_by: None, data: json!({ "id": id, "device": "unknown", @@ -157,6 +196,17 @@ impl EventNormalizer { } fn normalize_hyprland(&self, raw: &RawEvent) -> Vec { + if raw.kind == "hyprland.snapshot" { + return vec![BreadEvent { + event: "bread.hyprland.snapshot".to_string(), + timestamp: raw.timestamp, + source: AdapterSource::Hyprland, + id: bread_shared::new_event_id(), + caused_by: None, + data: raw.payload.clone(), + }]; + } + let kind = raw .payload .get("kind") @@ -169,97 +219,119 @@ impl EventNormalizer { .unwrap_or(""); match kind { - "workspace" | "workspacev2" => vec![BreadEvent { - event: "bread.workspace.changed".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: raw.payload.clone(), - }], - "createworkspace" => vec![BreadEvent { - event: "bread.workspace.created".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ "workspace": data }), - }], - "destroyworkspace" => vec![BreadEvent { - event: "bread.workspace.destroyed".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ "workspace": data }), - }], - "monitoradded" => vec![BreadEvent { - event: "bread.monitor.connected".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ "name": data }), - }], - "monitorremoved" => vec![BreadEvent { - event: "bread.monitor.disconnected".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ "name": data }), - }], - "activewindow" => vec![BreadEvent { - event: "bread.window.focus.changed".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: raw.payload.clone(), - }], + "workspace" | "workspacev2" => { + self.emit_hyprland_dual("bread.workspace.changed", raw.payload.clone(), raw) + } + "createworkspace" => self.emit_hyprland_dual( + "bread.workspace.created", + json!({ "workspace": data }), + raw, + ), + "destroyworkspace" => self.emit_hyprland_dual( + "bread.workspace.destroyed", + json!({ "workspace": data }), + raw, + ), + "monitoradded" => { + self.emit_hyprland_dual("bread.monitor.connected", json!({ "name": data }), raw) + } + "monitorremoved" => { + self.emit_hyprland_dual("bread.monitor.disconnected", json!({ "name": data }), raw) + } + "activewindow" => { + self.emit_hyprland_dual("bread.window.focus.changed", raw.payload.clone(), raw) + } "activewindowv2" => { let fields = split_hyprland_fields(data); - vec![BreadEvent { - event: "bread.window.focused".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ + self.emit_hyprland_dual( + "bread.window.focused", + json!({ "address": fields.first().unwrap_or(&"") }), - }] + raw, + ) } "openwindow" => { let fields = split_hyprland_fields(data); - vec![BreadEvent { - event: "bread.window.opened".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ + self.emit_hyprland_dual( + "bread.window.opened", + json!({ "address": fields.first().unwrap_or(&""), "workspace": fields.get(1).unwrap_or(&""), "class": fields.get(2).unwrap_or(&""), "title": fields.get(3).unwrap_or(&""), }), - }] + raw, + ) } "closewindow" => { let fields = split_hyprland_fields(data); - vec![BreadEvent { - event: "bread.window.closed".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ "address": fields.first().unwrap_or(&"") }), - }] + self.emit_hyprland_dual( + "bread.window.closed", + json!({ "address": fields.first().unwrap_or(&"") }), + raw, + ) } "movewindow" => { let fields = split_hyprland_fields(data); - vec![BreadEvent { - event: "bread.window.moved".to_string(), - timestamp: raw.timestamp, - source: AdapterSource::Hyprland, - data: json!({ + self.emit_hyprland_dual( + "bread.window.moved", + json!({ "address": fields.first().unwrap_or(&""), "workspace": fields.get(1).unwrap_or(&""), }), - }] + raw, + ) } _ => vec![BreadEvent { event: "bread.hyprland.event".to_string(), timestamp: raw.timestamp, source: AdapterSource::Hyprland, + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }], } } + /// Emits a Hyprland event under its namespaced `bread.hyprland.` + /// name — always — plus, when `legacy_hyprland_event_names` is enabled + /// (the default during the deprecation window), a second `BreadEvent` + /// under the pre-namespace flat name (e.g. `bread.workspace.changed`). + /// This is the single mechanism behind Workstream C: the two names carry + /// identical `data`/`timestamp`/`source`, so a module can migrate to + /// `bread.hyprland.*` at its own pace without missing events either way. + fn emit_hyprland_dual( + &self, + legacy_event: &str, + data: Value, + raw: &RawEvent, + ) -> Vec { + let rest = legacy_event.strip_prefix("bread.").unwrap_or(legacy_event); + let namespaced_event = format!("bread.hyprland.{rest}"); + + let mut out = Vec::with_capacity(2); + if self.legacy_hyprland_event_names { + out.push(BreadEvent { + event: legacy_event.to_string(), + timestamp: raw.timestamp, + source: AdapterSource::Hyprland, + id: bread_shared::new_event_id(), + caused_by: None, + data: data.clone(), + }); + } + out.push(BreadEvent { + event: namespaced_event, + timestamp: raw.timestamp, + source: AdapterSource::Hyprland, + id: bread_shared::new_event_id(), + caused_by: None, + data, + }); + out + } + fn normalize_power(&self, raw: &RawEvent) -> Vec { let mut events = Vec::new(); @@ -272,6 +344,8 @@ impl EventNormalizer { }, timestamp: raw.timestamp, source: AdapterSource::Power, + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }); } @@ -294,6 +368,8 @@ impl EventNormalizer { event: event.to_string(), timestamp: raw.timestamp, source: AdapterSource::Power, + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }); } @@ -304,6 +380,8 @@ impl EventNormalizer { event: "bread.power.changed".to_string(), timestamp: raw.timestamp, source: AdapterSource::Power, + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }); } @@ -339,6 +417,8 @@ impl EventNormalizer { event: "bread.device.connected".to_string(), timestamp: raw.timestamp, source: AdapterSource::Bluetooth, + id: bread_shared::new_event_id(), + caused_by: None, data: json!({ "id": path, "device": "unknown", @@ -352,6 +432,8 @@ impl EventNormalizer { event: "bread.device.disconnected".to_string(), timestamp: raw.timestamp, source: AdapterSource::Bluetooth, + id: bread_shared::new_event_id(), + caused_by: None, data: json!({ "id": path, "device": "unknown", @@ -365,6 +447,8 @@ impl EventNormalizer { event: "bread.bluetooth.device.paired".to_string(), timestamp: raw.timestamp, source: AdapterSource::Bluetooth, + id: bread_shared::new_event_id(), + caused_by: None, data: json!({ "id": path, "name": name, @@ -377,6 +461,8 @@ impl EventNormalizer { event: "bread.bluetooth.device.unpaired".to_string(), timestamp: raw.timestamp, source: AdapterSource::Bluetooth, + id: bread_shared::new_event_id(), + caused_by: None, data: json!({ "id": path, "address": address, @@ -421,6 +507,8 @@ impl EventNormalizer { event: name.to_string(), timestamp: raw.timestamp, source: AdapterSource::Network, + id: bread_shared::new_event_id(), + caused_by: None, data, }] } @@ -435,6 +523,8 @@ impl EventNormalizer { event: format!("bread.terminal.{}", raw.kind), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -444,6 +534,8 @@ impl EventNormalizer { event: format!("bread.remote.{}", raw.kind), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -453,6 +545,8 @@ impl EventNormalizer { event: format!("bread.git.{}", raw.kind), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -462,6 +556,8 @@ impl EventNormalizer { event: format!("bread.project.{}", raw.kind), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -474,6 +570,8 @@ impl EventNormalizer { event: format!("bread.service.{suffix}"), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -490,6 +588,8 @@ impl EventNormalizer { event, timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -505,13 +605,18 @@ impl EventNormalizer { let AdapterSource::App(app) = &raw.source else { return vec![]; }; - if !validate_app_namespace(app, &raw.kind) { + // Own-namespace events plus well-formed commands to another known + // app (the command bus). Anything else — including spoofed adapter + // namespaces — is dropped here even if it somehow crossed IPC. + if !validate_app_namespace(app, &raw.kind) && !validate_command_event(&raw.kind) { return vec![]; } vec![BreadEvent { event: raw.kind.clone(), timestamp: raw.timestamp, source: raw.source.clone(), + id: bread_shared::new_event_id(), + caused_by: None, data: raw.payload.clone(), }] } @@ -710,6 +815,11 @@ mod tests { } // ─── Hyprland ───────────────────────────────────────────────────────── + // + // `EventNormalizer::new` defaults `legacy_hyprland_event_names` to `true` + // (mirrors `[compat]`'s documented default), so by default every mapped + // Hyprland kind dual-emits: the legacy flat name plus its namespaced + // `bread.hyprland.*` sibling. See `emit_hyprland_dual`. #[test] fn hyprland_workspace_change() { @@ -721,8 +831,11 @@ mod tests { 1, ); let out = n.normalize(&ev); - assert_eq!(out.len(), 1); - assert_eq!(out[0].event, "bread.workspace.changed"); + assert_eq!(out.len(), 2); + assert!(out.iter().any(|e| e.event == "bread.workspace.changed")); + assert!(out + .iter() + .any(|e| e.event == "bread.hyprland.workspace.changed")); } #[test] @@ -735,9 +848,14 @@ mod tests { 1, ); let out = n.normalize(&ev); - assert_eq!(out.len(), 1); - assert_eq!(out[0].event, "bread.window.focused"); - assert_eq!(out[0].data.get("address").unwrap(), "0xdeadbeef"); + assert_eq!(out.len(), 2); + assert!(out.iter().any(|e| e.event == "bread.window.focused")); + assert!(out + .iter() + .any(|e| e.event == "bread.hyprland.window.focused")); + for ev in &out { + assert_eq!(ev.data.get("address").unwrap(), "0xdeadbeef"); + } } #[test] @@ -750,17 +868,25 @@ mod tests { 1, ); let out = n.normalize(&ev); - assert_eq!(out.len(), 1); - assert_eq!(out[0].event, "bread.window.opened"); - let d = &out[0].data; - assert_eq!(d.get("address").unwrap(), "0xabc"); - assert_eq!(d.get("workspace").unwrap(), "2"); - assert_eq!(d.get("class").unwrap(), "firefox"); - assert_eq!(d.get("title").unwrap(), "Mozilla Firefox"); + assert_eq!(out.len(), 2); + assert!(out.iter().any(|e| e.event == "bread.window.opened")); + assert!(out + .iter() + .any(|e| e.event == "bread.hyprland.window.opened")); + for ev in &out { + let d = &ev.data; + assert_eq!(d.get("address").unwrap(), "0xabc"); + assert_eq!(d.get("workspace").unwrap(), "2"); + assert_eq!(d.get("class").unwrap(), "firefox"); + assert_eq!(d.get("title").unwrap(), "Mozilla Firefox"); + } } #[test] fn hyprland_unknown_kind_falls_through_to_generic_event() { + // The `bread.hyprland.event` fallback is already namespaced, so it's + // exempt from dual-emit — it never had a legacy flat name to begin + // with. let n = EventNormalizer::new(0); let ev = raw( AdapterSource::Hyprland, @@ -788,9 +914,283 @@ mod tests { json!({"kind": "monitorremoved", "data": "HDMI-A-1"}), 2, )); - assert_eq!(added[0].event, "bread.monitor.connected"); - assert_eq!(added[0].data.get("name").unwrap(), "HDMI-A-1"); - assert_eq!(removed[0].event, "bread.monitor.disconnected"); + assert_eq!(added.len(), 2); + assert!(added.iter().any(|e| e.event == "bread.monitor.connected")); + assert!(added + .iter() + .any(|e| e.event == "bread.hyprland.monitor.connected")); + for ev in &added { + assert_eq!(ev.data.get("name").unwrap(), "HDMI-A-1"); + } + + assert_eq!(removed.len(), 2); + assert!(removed + .iter() + .any(|e| e.event == "bread.monitor.disconnected")); + assert!(removed + .iter() + .any(|e| e.event == "bread.hyprland.monitor.disconnected")); + } + + /// (a) With the default config (`legacy_hyprland_event_names = true`), + /// every one of the 10 dual-emit mappings fires both its legacy flat + /// name and its namespaced `bread.hyprland.*` sibling, with identical + /// data on each. + #[test] + fn hyprland_dual_emit_covers_all_ten_mappings_by_default() { + let n = EventNormalizer::new(0); + let cases: &[(&str, &str, &str, &str)] = &[ + ( + "workspace", + "2", + "bread.workspace.changed", + "bread.hyprland.workspace.changed", + ), + ( + "workspacev2", + "2,name", + "bread.workspace.changed", + "bread.hyprland.workspace.changed", + ), + ( + "createworkspace", + "3", + "bread.workspace.created", + "bread.hyprland.workspace.created", + ), + ( + "destroyworkspace", + "3", + "bread.workspace.destroyed", + "bread.hyprland.workspace.destroyed", + ), + ( + "monitoradded", + "HDMI-A-1", + "bread.monitor.connected", + "bread.hyprland.monitor.connected", + ), + ( + "monitorremoved", + "HDMI-A-1", + "bread.monitor.disconnected", + "bread.hyprland.monitor.disconnected", + ), + ( + "activewindow", + "firefox,Mozilla Firefox", + "bread.window.focus.changed", + "bread.hyprland.window.focus.changed", + ), + ( + "activewindowv2", + "0xdead", + "bread.window.focused", + "bread.hyprland.window.focused", + ), + ( + "openwindow", + "0xabc>>2>>firefox>>Mozilla Firefox", + "bread.window.opened", + "bread.hyprland.window.opened", + ), + ( + "closewindow", + "0xabc", + "bread.window.closed", + "bread.hyprland.window.closed", + ), + ( + "movewindow", + "0xabc,2", + "bread.window.moved", + "bread.hyprland.window.moved", + ), + ]; + + for (kind, data, legacy_event, namespaced_event) in cases { + let ev = raw( + AdapterSource::Hyprland, + "hypr", + json!({"kind": kind, "data": data}), + 1, + ); + let out = n.normalize(&ev); + assert_eq!( + out.len(), + 2, + "kind {kind} should dual-emit exactly 2 events" + ); + assert!( + out.iter().any(|e| &e.event == legacy_event), + "kind {kind} missing legacy event {legacy_event}" + ); + assert!( + out.iter().any(|e| &e.event == namespaced_event), + "kind {kind} missing namespaced event {namespaced_event}" + ); + let legacy_data = out + .iter() + .find(|e| &e.event == legacy_event) + .unwrap() + .data + .clone(); + let namespaced_data = out + .iter() + .find(|e| &e.event == namespaced_event) + .unwrap() + .data + .clone(); + assert_eq!( + legacy_data, namespaced_data, + "kind {kind}: legacy and namespaced events should carry identical data" + ); + } + } + + /// (b) With `legacy_hyprland_event_names = false`, only the namespaced + /// `bread.hyprland.*` names fire — the legacy flat names are fully + /// suppressed, not just relegated to a secondary slot. + #[test] + fn hyprland_legacy_names_suppressed_when_compat_disabled() { + let n = EventNormalizer::new(0).with_legacy_hyprland_event_names(false); + let cases: &[(&str, &str, &str, &str)] = &[ + ( + "workspace", + "2", + "bread.workspace.changed", + "bread.hyprland.workspace.changed", + ), + ( + "createworkspace", + "3", + "bread.workspace.created", + "bread.hyprland.workspace.created", + ), + ( + "destroyworkspace", + "3", + "bread.workspace.destroyed", + "bread.hyprland.workspace.destroyed", + ), + ( + "monitoradded", + "HDMI-A-1", + "bread.monitor.connected", + "bread.hyprland.monitor.connected", + ), + ( + "monitorremoved", + "HDMI-A-1", + "bread.monitor.disconnected", + "bread.hyprland.monitor.disconnected", + ), + ( + "activewindow", + "firefox,Mozilla Firefox", + "bread.window.focus.changed", + "bread.hyprland.window.focus.changed", + ), + ( + "activewindowv2", + "0xdead", + "bread.window.focused", + "bread.hyprland.window.focused", + ), + ( + "openwindow", + "0xabc>>2>>firefox>>Mozilla Firefox", + "bread.window.opened", + "bread.hyprland.window.opened", + ), + ( + "closewindow", + "0xabc", + "bread.window.closed", + "bread.hyprland.window.closed", + ), + ( + "movewindow", + "0xabc,2", + "bread.window.moved", + "bread.hyprland.window.moved", + ), + ]; + + for (kind, data, legacy_event, namespaced_event) in cases { + let ev = raw( + AdapterSource::Hyprland, + "hypr", + json!({"kind": kind, "data": data}), + 1, + ); + let out = n.normalize(&ev); + assert_eq!( + out.len(), + 1, + "kind {kind} should emit exactly 1 event when legacy names are disabled" + ); + assert_eq!( + out[0].event, *namespaced_event, + "kind {kind} should emit only the namespaced event" + ); + assert!( + !out.iter().any(|e| &e.event == legacy_event), + "kind {kind} leaked legacy event {legacy_event} despite being disabled" + ); + } + + // The already-namespaced fallback is unaffected either way. + let fallback = n.normalize(&raw( + AdapterSource::Hyprland, + "hypr", + json!({"kind": "submap", "data": "resize"}), + 1, + )); + assert_eq!(fallback.len(), 1); + assert_eq!(fallback[0].event, "bread.hyprland.event"); + } + + /// (c) A module that subscribes only to `bread.hyprland.*` gets full + /// coverage of workspace, monitor, and window activity — regardless of + /// the `[compat]` setting — since the namespaced name is unconditional. + /// This is the actual promise Workstream C makes: "portable automation" + /// only means something if the namespaced form alone is a complete feed. + #[test] + fn hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat() { + let kinds_and_data: &[(&str, &str)] = &[ + ("workspace", "2"), + ("createworkspace", "3"), + ("destroyworkspace", "3"), + ("monitoradded", "HDMI-A-1"), + ("monitorremoved", "HDMI-A-1"), + ("activewindow", "firefox,Mozilla Firefox"), + ("activewindowv2", "0xdead"), + ("openwindow", "0xabc>>2>>firefox>>Mozilla Firefox"), + ("closewindow", "0xabc"), + ("movewindow", "0xabc,2"), + ]; + + for legacy_enabled in [true, false] { + let n = EventNormalizer::new(0).with_legacy_hyprland_event_names(legacy_enabled); + for (kind, data) in kinds_and_data { + let out = n.normalize(&raw( + AdapterSource::Hyprland, + "hypr", + json!({"kind": kind, "data": data}), + 1, + )); + let namespaced_hits = out + .iter() + .filter(|e| e.event.starts_with("bread.hyprland.")) + .count(); + assert_eq!( + namespaced_hits, 1, + "kind {kind} (legacy_enabled={legacy_enabled}) should always emit exactly \ + one bread.hyprland.* event, matching a bread.hyprland.* subscriber's view" + ); + } + } } // ─── Power ───────────────────────────────────────────────────────────── @@ -1053,9 +1453,14 @@ mod tests { json!({"kind": "workspace", "data": "2"}), 1100, ); - assert_eq!(n.normalize(&a).len(), 1); + // Hyprland's "workspace" kind dual-emits (legacy + namespaced name, + // see the Hyprland test section below), so each distinct payload + // produces 2 events rather than 1 — but the point of this test is + // that neither call is suppressed by dedup, since the payloads + // differ and thus so does the dedup key. + assert_eq!(n.normalize(&a).len(), 2); // Different payloads = different dedup key - assert_eq!(n.normalize(&b).len(), 1); + assert_eq!(n.normalize(&b).len(), 2); } #[test] @@ -1075,6 +1480,65 @@ mod tests { } } + // ─── App / command bus ───────────────────────────────────────────────── + + #[test] + fn app_own_namespace_passes_through() { + let n = EventNormalizer::new(0); + let out = n.normalize(&raw( + AdapterSource::App("clip".into()), + "bread.clip.copied", + json!({"len": 4}), + 1, + )); + assert_eq!(out.len(), 1); + assert_eq!(out[0].event, "bread.clip.copied"); + } + + #[test] + fn app_command_to_another_known_app_passes_through() { + let n = EventNormalizer::new(0); + let out = n.normalize(&raw( + AdapterSource::App("cast".into()), + "bread.command.clip.clear", + json!({}), + 1, + )); + assert_eq!(out.len(), 1); + assert_eq!(out[0].event, "bread.command.clip.clear"); + } + + #[test] + fn app_wrong_namespace_is_dropped() { + let n = EventNormalizer::new(0); + let out = n.normalize(&raw( + AdapterSource::App("cast".into()), + "bread.clip.copied", + json!({}), + 1, + )); + assert!(out.is_empty()); + } + + #[test] + fn app_command_to_unknown_or_reserved_target_is_dropped() { + let n = EventNormalizer::new(0); + let power = n.normalize(&raw( + AdapterSource::App("cast".into()), + "bread.command.power.off", + json!({}), + 1, + )); + assert!(power.is_empty()); + let spoof = n.normalize(&raw( + AdapterSource::App("cast".into()), + "bread.hyprland.workspace.changed", + json!({}), + 1, + )); + assert!(spoof.is_empty()); + } + // ─── Helper ──────────────────────────────────────────────────────────── #[test] diff --git a/breadd/src/core/rules.rs b/breadd/src/core/rules.rs new file mode 100644 index 0000000..338811c --- /dev/null +++ b/breadd/src/core/rules.rs @@ -0,0 +1,410 @@ +//! `rules.toml` — a declarative shortcut for the common "when event X +//! happens, do Y" case that otherwise requires hand-written Lua +//! (`bread.on(...)`, `bread.exec(...)`, etc). +//! +//! This module owns TOML parsing and validation only; it has no `mlua` +//! dependency so it can be unit-tested in isolation. The `bread.rules` +//! built-in Lua module (`breadd/src/lua/mod.rs`, `BUILTIN_RULES`) is the +//! other half — it takes the [`ParsedRule`]s this module produces and turns +//! each one into a real `bread.on()` subscription. +//! +//! Schema: +//! +//! ```toml +//! [[rule]] +//! on = "device.dock.connected" # matched against "bread." .. on, wildcards allowed +//! run = "~/.config/bread/scripts/dock-connected.sh" +//! +//! [[rule]] +//! on = "power.ac.disconnected" +//! notify = "Unplugged" +//! +//! [[rule]] +//! on = "device.keyboard.connected" +//! exec = "xset r rate 200 40" +//! ``` +//! +//! Exactly one of `run` / `notify` / `exec` must be set per rule. `run` and +//! `exec` both ultimately shell out via `bread.exec()`, but with distinct +//! semantics documented on [`RuleAction`]. + +use std::path::Path; + +use serde::Deserialize; + +#[derive(Debug, Default, Deserialize)] +struct RulesFile { + #[serde(default, rename = "rule")] + rule: Vec, +} + +#[derive(Debug, Default, Deserialize)] +struct RawRule { + on: Option, + run: Option, + notify: Option, + exec: Option, +} + +/// The action a validated rule fires when its event matches. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum RuleAction { + /// Path to a single script/executable. Treated as exactly one program — + /// tilde-expanded and shell-quoted as a whole before being handed to + /// `bread.exec()`, so a path containing spaces still runs as one file + /// rather than being word-split into a command plus arguments. + Run(String), + /// A raw shell command line, passed to `bread.exec()` verbatim (same as + /// calling `bread.exec()` from hand-written Lua) — you're responsible + /// for quoting/escaping exactly as if you'd typed it in a shell. + Exec(String), + /// A desktop notification message, passed to `bread.notify()`. + Notify(String), +} + +/// A `[[rule]]` entry that passed validation. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ParsedRule { + /// Event-name suffix, e.g. `"device.dock.connected"`. The real + /// subscription is `"bread." .. on` — wildcards (`*`, `**`, `?`) are + /// whatever `bread.on()` itself supports, since this is handed straight + /// through. + pub on: String, + pub action: RuleAction, +} + +/// A `[[rule]]` entry that failed validation — reported, not silently +/// dropped, so it shows up via `bread doctor` the same way a broken Lua +/// module would. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RuleIssue { + /// Zero-based position of the `[[rule]]` table in the file. + pub index: usize, + /// The rule's `on` value, if it had one (helps identify *which* rule in + /// a large file when `on` itself isn't the problem). + pub on: Option, + pub message: String, +} + +impl std::fmt::Display for RuleIssue { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match &self.on { + Some(on) => write!(f, "rule #{} (on = \"{}\"): {}", self.index, on, self.message), + None => write!(f, "rule #{}: {}", self.index, self.message), + } + } +} + +/// Result of attempting to load `rules.toml`. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum RulesLoadOutcome { + /// The file doesn't exist. Not an error — `rules.toml` is entirely + /// optional and purely additive alongside `init.lua`. + Absent, + /// The file exists but couldn't be read, or doesn't parse as TOML at + /// all — no rules could be recovered from it. + Fatal(String), + /// The file parsed as TOML. `rules` are the entries that passed + /// validation (register these); `issues` describes any `[[rule]]` + /// entries that didn't (report these, but they don't block the rest of + /// the file from working). + Loaded { + rules: Vec, + issues: Vec, + }, +} + +/// Location of `rules.toml` — re-exported from `core::config` (single +/// source of truth, colocated with `config_path()`'s identical +/// `XDG_CONFIG_HOME`-vs-`HOME` resolution for `breadd.toml`) so callers that +/// only care about rules loading can reach it as `rules::rules_path()`. +pub use crate::core::config::rules_path; + +/// Reads and validates `rules.toml` at `path`. Never panics — every failure +/// mode (missing file, unreadable file, invalid TOML, invalid individual +/// rules) is represented in the returned [`RulesLoadOutcome`]. +pub fn load_rules(path: &Path) -> RulesLoadOutcome { + if !path.exists() { + return RulesLoadOutcome::Absent; + } + + let raw = match std::fs::read_to_string(path) { + Ok(s) => s, + Err(e) => return RulesLoadOutcome::Fatal(format!("failed to read rules.toml: {e}")), + }; + + let parsed: RulesFile = match toml::from_str(&raw) { + Ok(v) => v, + Err(e) => return RulesLoadOutcome::Fatal(format!("failed to parse rules.toml: {e}")), + }; + + let mut rules = Vec::new(); + let mut issues = Vec::new(); + for (index, raw_rule) in parsed.rule.into_iter().enumerate() { + match validate_rule(index, raw_rule) { + Ok(rule) => rules.push(rule), + Err(issue) => issues.push(issue), + } + } + + RulesLoadOutcome::Loaded { rules, issues } +} + +fn validate_rule(index: usize, raw: RawRule) -> Result { + let on = raw.on.filter(|s| !s.trim().is_empty()); + + let mut present = Vec::new(); + if raw.run.is_some() { + present.push("run"); + } + if raw.notify.is_some() { + present.push("notify"); + } + if raw.exec.is_some() { + present.push("exec"); + } + + let Some(on) = on else { + return Err(RuleIssue { + index, + on: None, + message: "missing or empty `on`".to_string(), + }); + }; + + if present.is_empty() { + return Err(RuleIssue { + index, + on: Some(on), + message: "must set exactly one of `run`, `notify`, `exec` (none set)".to_string(), + }); + } + if present.len() > 1 { + return Err(RuleIssue { + index, + on: Some(on), + message: format!( + "must set exactly one of `run`, `notify`, `exec` (found: {})", + present.join(", ") + ), + }); + } + + let action = if let Some(v) = raw.run { + RuleAction::Run(v) + } else if let Some(v) = raw.notify { + RuleAction::Notify(v) + } else { + RuleAction::Exec(raw.exec.expect("exactly one action present")) + }; + + Ok(ParsedRule { on, action }) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Write; + use std::path::PathBuf; + + fn write_temp(contents: &str) -> (tempfile::TempDir, PathBuf) { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join("rules.toml"); + let mut f = std::fs::File::create(&path).expect("create rules.toml"); + f.write_all(contents.as_bytes()).expect("write rules.toml"); + (dir, path) + } + + #[test] + fn absent_file_is_not_an_error() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join("does-not-exist.toml"); + assert_eq!(load_rules(&path), RulesLoadOutcome::Absent); + } + + #[test] + fn invalid_toml_is_fatal() { + let (_dir, path) = write_temp("[[rule\nbroken"); + match load_rules(&path) { + RulesLoadOutcome::Fatal(msg) => assert!(msg.contains("failed to parse")), + other => panic!("expected Fatal, got {other:?}"), + } + } + + #[test] + fn empty_file_loads_with_no_rules() { + let (_dir, path) = write_temp(""); + assert_eq!( + load_rules(&path), + RulesLoadOutcome::Loaded { + rules: vec![], + issues: vec![], + } + ); + } + + #[test] + fn well_formed_rules_all_three_action_kinds_parse() { + let (_dir, path) = write_temp( + r#" +[[rule]] +on = "device.dock.connected" +run = "~/.config/bread/scripts/dock-connected.sh" + +[[rule]] +on = "power.ac.disconnected" +notify = "Unplugged" + +[[rule]] +on = "device.keyboard.connected" +exec = "xset r rate 200 40" +"#, + ); + let RulesLoadOutcome::Loaded { rules, issues } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert!(issues.is_empty()); + assert_eq!( + rules, + vec![ + ParsedRule { + on: "device.dock.connected".to_string(), + action: RuleAction::Run( + "~/.config/bread/scripts/dock-connected.sh".to_string() + ), + }, + ParsedRule { + on: "power.ac.disconnected".to_string(), + action: RuleAction::Notify("Unplugged".to_string()), + }, + ParsedRule { + on: "device.keyboard.connected".to_string(), + action: RuleAction::Exec("xset r rate 200 40".to_string()), + }, + ] + ); + } + + #[test] + fn wildcard_on_is_passed_through_unvalidated() { + let (_dir, path) = write_temp( + r#" +[[rule]] +on = "device.*.connected" +exec = "true" +"#, + ); + let RulesLoadOutcome::Loaded { rules, issues } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert!(issues.is_empty()); + assert_eq!(rules[0].on, "device.*.connected"); + } + + #[test] + fn missing_on_is_reported_with_index_and_no_on() { + let (_dir, path) = write_temp( + r#" +[[rule]] +exec = "true" +"#, + ); + let RulesLoadOutcome::Loaded { rules, issues } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert!(rules.is_empty()); + assert_eq!(issues.len(), 1); + assert_eq!(issues[0].index, 0); + assert_eq!(issues[0].on, None); + assert!(issues[0].message.contains("missing or empty")); + } + + #[test] + fn empty_on_is_treated_as_missing() { + let (_dir, path) = write_temp( + r#" +[[rule]] +on = " " +exec = "true" +"#, + ); + let RulesLoadOutcome::Loaded { issues, .. } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert_eq!(issues.len(), 1); + assert!(issues[0].message.contains("missing or empty")); + } + + #[test] + fn zero_action_keys_is_reported() { + let (_dir, path) = write_temp( + r#" +[[rule]] +on = "power.ac.disconnected" +"#, + ); + let RulesLoadOutcome::Loaded { rules, issues } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert!(rules.is_empty()); + assert_eq!(issues.len(), 1); + assert_eq!(issues[0].on.as_deref(), Some("power.ac.disconnected")); + assert!(issues[0].message.contains("none set")); + } + + #[test] + fn multiple_action_keys_is_reported() { + let (_dir, path) = write_temp( + r#" +[[rule]] +on = "power.ac.disconnected" +notify = "Unplugged" +exec = "true" +"#, + ); + let RulesLoadOutcome::Loaded { rules, issues } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert!(rules.is_empty()); + assert_eq!(issues.len(), 1); + assert!(issues[0].message.contains("notify")); + assert!(issues[0].message.contains("exec")); + } + + #[test] + fn one_bad_rule_does_not_block_other_valid_rules() { + let (_dir, path) = write_temp( + r#" +[[rule]] +on = "device.dock.connected" +exec = "true" + +[[rule]] +notify = "no on here" + +[[rule]] +on = "power.ac.disconnected" +notify = "Unplugged" +"#, + ); + let RulesLoadOutcome::Loaded { rules, issues } = load_rules(&path) else { + panic!("expected Loaded"); + }; + assert_eq!(rules.len(), 2); + assert_eq!(issues.len(), 1); + assert_eq!(issues[0].index, 1); + } + + #[test] + fn rule_issue_display_includes_index_and_on() { + let issue = RuleIssue { + index: 2, + on: Some("power.ac.disconnected".to_string()), + message: "must set exactly one of `run`, `notify`, `exec` (none set)".to_string(), + }; + assert_eq!( + issue.to_string(), + "rule #2 (on = \"power.ac.disconnected\"): must set exactly one of `run`, `notify`, `exec` (none set)" + ); + } +} diff --git a/breadd/src/core/state_engine.rs b/breadd/src/core/state_engine.rs index 5301a9d..060c0df 100644 --- a/breadd/src/core/state_engine.rs +++ b/breadd/src/core/state_engine.rs @@ -38,11 +38,13 @@ pub enum StateCommand { }, ClearSubscriptions, ClearModules, + ClearWidgets, SetModuleStatus { name: String, status: ModuleLoadState, last_error: Option, builtin: bool, + ungated: bool, }, SetProfile { name: String, @@ -117,18 +119,41 @@ impl StateHandle { let _ = self.command_tx.send(StateCommand::ClearModules); } + pub fn clear_widgets(&self) { + let _ = self.command_tx.send(StateCommand::ClearWidgets); + } + pub fn set_module_status( &self, name: String, status: ModuleLoadState, last_error: Option, builtin: bool, + ) { + self.set_module_status_ex(name, status, last_error, builtin, false); + } + + /// Same as [`set_module_status`](Self::set_module_status) but also + /// records whether the module is running with full, ungated `bread.*` + /// access (no `permissions` declared in its manifest). Kept as a + /// separate method rather than changing `set_module_status`'s signature + /// everywhere so call sites that don't yet know the answer (load + /// errors, disabled modules, etc.) don't have to thread a meaningless + /// value through. + pub fn set_module_status_ex( + &self, + name: String, + status: ModuleLoadState, + last_error: Option, + builtin: bool, + ungated: bool, ) { let _ = self.command_tx.send(StateCommand::SetModuleStatus { name, status, last_error, builtin, + ungated, }); } @@ -235,7 +260,7 @@ pub async fn run_state_engine( } if let (Some(before), Some(after)) = (before_snapshot, after_snapshot) { - for (_id, path) in watches.iter() { + for path in watches.values() { let old_val = value_at_path(&before, path).unwrap_or(Value::Null); let new_val = value_at_path(&after, path).unwrap_or(Value::Null); if old_val != new_val { @@ -290,23 +315,29 @@ async fn handle_command( StateCommand::ClearModules => { state.write().await.modules.clear(); } + StateCommand::ClearWidgets => { + state.write().await.widgets.clear(); + } StateCommand::SetModuleStatus { name, status, last_error, builtin, + ungated, } => { let mut guard = state.write().await; if let Some(existing) = guard.modules.iter_mut().find(|m| m.name == name) { existing.status = status; existing.last_error = last_error; existing.builtin = builtin; + existing.ungated = ungated; } else { guard.modules.push(crate::core::types::ModuleStatus { name, status, last_error, builtin, + ungated, store: HashMap::new(), }); } @@ -364,55 +395,180 @@ fn value_at_path(value: &Value, path: &str) -> Option { Some(current.clone()) } +/// Logical Hyprland state key: both the legacy flat name and its +/// `bread.hyprland.*` sibling collapse to the same suffix +/// (`monitor.connected`, `workspace.changed`, …). +fn hyprland_state_key(event: &str) -> Option<&str> { + if let Some(rest) = event.strip_prefix("bread.hyprland.") { + return Some(rest); + } + match event { + "bread.monitor.connected" => Some("monitor.connected"), + "bread.monitor.disconnected" => Some("monitor.disconnected"), + "bread.workspace.changed" => Some("workspace.changed"), + "bread.workspace.created" => Some("workspace.created"), + "bread.workspace.destroyed" => Some("workspace.destroyed"), + "bread.window.focus.changed" => Some("window.focus.changed"), + "bread.window.focused" => Some("window.focused"), + "bread.window.opened" => Some("window.opened"), + "bread.window.closed" => Some("window.closed"), + "bread.window.moved" => Some("window.moved"), + _ => None, + } +} + +fn json_stringish(value: Option<&Value>) -> Option { + let value = value?; + if let Some(s) = value.as_str() { + return Some(s.to_string()); + } + value.as_i64().map(|n| n.to_string()) +} + +fn workspace_id_from_data(data: &Value) -> Option { + json_stringish(data.get("workspace")) + .or_else(|| json_stringish(data.get("id"))) + .or_else(|| json_stringish(data.get("name"))) + .or_else(|| { + data.get("data") + .and_then(Value::as_str) + .map(|s| s.split(',').next().unwrap_or(s).trim().to_string()) + .filter(|s| !s.is_empty()) + }) +} + +fn active_window_from_data(data: &Value) -> Option { + json_stringish(data.get("window")) + .or_else(|| json_stringish(data.get("class"))) + .or_else(|| json_stringish(data.get("address"))) + .or_else(|| { + data.get("data") + .and_then(Value::as_str) + .map(|s| s.split(',').next().unwrap_or(s).trim().to_string()) + .filter(|s| !s.is_empty()) + }) +} + +fn upsert_monitor(state: &mut RuntimeState, data: &Value) { + let Some(name) = data.get("name").and_then(Value::as_str) else { + return; + }; + if let Some(m) = state.monitors.iter_mut().find(|m| m.name == name) { + m.connected = true; + if let Some(res) = data.get("resolution").and_then(Value::as_str) { + m.resolution = Some(res.to_string()); + } + if let Some(pos) = data.get("position").and_then(Value::as_str) { + m.position = Some(pos.to_string()); + } + } else { + state.monitors.push(crate::core::types::Monitor { + name: name.to_string(), + connected: true, + resolution: data + .get("resolution") + .and_then(Value::as_str) + .map(ToString::to_string), + position: data + .get("position") + .and_then(Value::as_str) + .map(ToString::to_string), + }); + } +} + +fn apply_hyprland_snapshot(state: &mut RuntimeState, data: &Value) { + if let Some(arr) = data.get("monitors").and_then(Value::as_array) { + state.monitors = arr + .iter() + .filter_map(|m| { + let name = m.get("name").and_then(Value::as_str)?; + let width = m.get("width").and_then(Value::as_u64); + let height = m.get("height").and_then(Value::as_u64); + let x = m.get("x").and_then(Value::as_i64); + let y = m.get("y").and_then(Value::as_i64); + let disabled = m.get("disabled").and_then(Value::as_bool).unwrap_or(false); + Some(crate::core::types::Monitor { + name: name.to_string(), + connected: !disabled, + resolution: match (width, height) { + (Some(w), Some(h)) => Some(format!("{w}x{h}")), + _ => None, + }, + position: match (x, y) { + (Some(x), Some(y)) => Some(format!("{x}x{y}")), + _ => None, + }, + }) + }) + .collect(); + } + if let Some(arr) = data.get("workspaces").and_then(Value::as_array) { + state.workspaces = arr + .iter() + .filter_map(|ws| { + let id = json_stringish(ws.get("id")).or_else(|| json_stringish(ws.get("name")))?; + Some(crate::core::types::Workspace { + id, + monitor: json_stringish(ws.get("monitor")), + }) + }) + .collect(); + } + if let Some(aw) = data.get("active_workspace") { + state.active_workspace = + json_stringish(aw.get("name")).or_else(|| json_stringish(aw.get("id"))); + } + if let Some(win) = data.get("active_window") { + state.active_window = json_stringish(win.get("address")) + .or_else(|| json_stringish(win.get("class"))) + .or_else(|| json_stringish(win.get("title"))); + } +} + fn apply_event_to_state(state: &mut RuntimeState, event: &BreadEvent) { + if event.event == "bread.hyprland.snapshot" { + apply_hyprland_snapshot(state, &event.data); + return; + } + + if let Some(key) = hyprland_state_key(event.event.as_str()) { + match key { + "monitor.connected" => upsert_monitor(state, &event.data), + "monitor.disconnected" => { + if let Some(name) = event.data.get("name").and_then(Value::as_str) { + if let Some(m) = state.monitors.iter_mut().find(|m| m.name == name) { + m.connected = false; + } + } + } + "workspace.changed" => { + state.active_workspace = workspace_id_from_data(&event.data); + } + "workspace.created" => { + if let Some(id) = workspace_id_from_data(&event.data) { + if !state.workspaces.iter().any(|w| w.id == id) { + state.workspaces.push(crate::core::types::Workspace { + id, + monitor: json_stringish(event.data.get("monitor")), + }); + } + } + } + "workspace.destroyed" => { + if let Some(id) = workspace_id_from_data(&event.data) { + state.workspaces.retain(|w| w.id != id); + } + } + "window.focus.changed" | "window.focused" => { + state.active_window = active_window_from_data(&event.data); + } + _ => {} + } + return; + } + match event.event.as_str() { - "bread.monitor.connected" => { - if let Some(name) = event.data.get("name").and_then(Value::as_str) { - if let Some(m) = state.monitors.iter_mut().find(|m| m.name == name) { - m.connected = true; - } else { - state.monitors.push(crate::core::types::Monitor { - name: name.to_string(), - connected: true, - resolution: event - .data - .get("resolution") - .and_then(Value::as_str) - .map(ToString::to_string), - position: event - .data - .get("position") - .and_then(Value::as_str) - .map(ToString::to_string), - }); - } - } - } - "bread.monitor.disconnected" => { - if let Some(name) = event.data.get("name").and_then(Value::as_str) { - if let Some(m) = state.monitors.iter_mut().find(|m| m.name == name) { - m.connected = false; - } - } - } - "bread.workspace.changed" => { - let ws = event - .data - .get("workspace") - .or_else(|| event.data.get("id")) - .and_then(Value::as_str) - .map(ToString::to_string); - state.active_workspace = ws; - } - "bread.window.focus.changed" | "bread.window.focused" => { - state.active_window = event - .data - .get("window") - .or_else(|| event.data.get("class")) - .or_else(|| event.data.get("address")) - .and_then(Value::as_str) - .map(ToString::to_string); - } "bread.device.connected" => { apply_device_change(state, &event.data, true); } @@ -648,6 +804,8 @@ mod tests { timestamp: 0, source: AdapterSource::System, data, + id: bread_shared::new_event_id(), + caused_by: None, } } @@ -754,6 +912,67 @@ mod tests { assert_eq!(state.active_window.as_deref(), Some("0xdeadbeef")); } + #[test] + fn namespaced_hyprland_events_update_the_same_state() { + let mut state = RuntimeState::default(); + apply_event_to_state( + &mut state, + &ev( + "bread.hyprland.monitor.connected", + json!({"name": "HDMI-A-1"}), + ), + ); + apply_event_to_state( + &mut state, + &ev("bread.hyprland.workspace.changed", json!({"id": 4})), + ); + apply_event_to_state( + &mut state, + &ev( + "bread.hyprland.window.focus.changed", + json!({"kind": "activewindow", "data": "kitty,foo"}), + ), + ); + apply_event_to_state( + &mut state, + &ev("bread.hyprland.workspace.created", json!({"workspace": "9"})), + ); + assert_eq!(state.monitors.len(), 1); + assert_eq!(state.monitors[0].name, "HDMI-A-1"); + assert_eq!(state.active_workspace.as_deref(), Some("4")); + assert_eq!(state.active_window.as_deref(), Some("kitty")); + assert_eq!(state.workspaces.len(), 1); + assert_eq!(state.workspaces[0].id, "9"); + } + + #[test] + fn hyprland_snapshot_replaces_topology() { + let mut state = RuntimeState::default(); + apply_event_to_state( + &mut state, + &ev("bread.monitor.connected", json!({"name": "stale"})), + ); + apply_event_to_state( + &mut state, + &ev( + "bread.hyprland.snapshot", + json!({ + "monitors": [{"name": "eDP-1", "width": 1920, "height": 1200, "x": 0, "y": 0}], + "workspaces": [{"id": 1, "name": "1", "monitor": "eDP-1"}], + "active_workspace": {"id": 1, "name": "1"}, + "active_window": {"address": "0xabc", "class": "kitty"} + }), + ), + ); + assert_eq!(state.monitors.len(), 1); + assert_eq!(state.monitors[0].name, "eDP-1"); + assert_eq!(state.monitors[0].resolution.as_deref(), Some("1920x1200")); + assert_eq!(state.workspaces.len(), 1); + assert_eq!(state.workspaces[0].id, "1"); + assert_eq!(state.active_workspace.as_deref(), Some("1")); + assert_eq!(state.active_window.as_deref(), Some("0xabc")); + } + // ─── apply_device_change ────────────────────────────────────────────── #[test] diff --git a/breadd/src/core/types.rs b/breadd/src/core/types.rs index a521cf6..ae58223 100644 --- a/breadd/src/core/types.rs +++ b/breadd/src/core/types.rs @@ -1,5 +1,6 @@ use std::collections::{BTreeMap, HashMap}; +use bread_shared::widget::WidgetSpec; use serde::{Deserialize, Serialize}; use serde_json::Value; @@ -15,6 +16,10 @@ pub struct RuntimeState { pub profile: ProfileState, pub modules: Vec, pub workflows: Vec, + /// Widgets registered via `bread.widget.register` from any Lua module, + /// keyed implicitly by `WidgetSpec.id` (fully-qualified `.`). + /// Surfaced via the `widgets.list` IPC method for breadbar to render. + pub widgets: Vec, } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -118,6 +123,15 @@ pub struct ModuleStatus { pub builtin: bool, #[serde(default)] pub store: HashMap, + /// `true` when this is a third-party module running with full, ungated + /// `bread.*` access because its `bread.module.toml` declares no + /// `permissions` at all (or the module has no manifest on disk). Always + /// `false` for builtin modules, which are never subject to capability + /// scoping in the first place — see the "Capability-scoped modules" + /// section of `Documentation.md`. `bread doctor` surfaces this as a + /// warning so an ungated module doesn't stay invisible forever. + #[serde(default)] + pub ungated: bool, } #[derive(Debug, Clone, Serialize, Deserialize)] diff --git a/breadd/src/ipc/mod.rs b/breadd/src/ipc/mod.rs index df0afa4..141b1a3 100644 --- a/breadd/src/ipc/mod.rs +++ b/breadd/src/ipc/mod.rs @@ -8,7 +8,9 @@ use std::sync::Arc; use std::time::Instant; use anyhow::{anyhow, Result}; -use bread_shared::apps::{is_known_app, validate_app_namespace}; +use bread_shared::apps::{ + event_domain, is_known_app, is_reserved_domain, validate_app_namespace, validate_command_event, +}; use bread_shared::{now_unix_ms, AdapterSource, BreadEvent, RawEvent}; use serde::{Deserialize, Serialize}; use serde_json::{json, Value}; @@ -20,6 +22,9 @@ use tracing::{error, info, warn}; use crate::adapters::AdapterStatus; use crate::core::state_engine::StateHandle; use crate::lua::RuntimeHandle; +use crate::module_host::ModuleHostRegistry; + +mod module_host_bridge; /// The Bread Automation API version (Lua API surface + IPC methods + event /// vocabulary + runtime-state schema), per `Documentation.md`'s "API @@ -27,7 +32,16 @@ use crate::lua::RuntimeHandle; /// something new-but-additive (a binding, an event, an IPC param); bump the /// major version only for a breaking change, which should not happen inside /// this daemon's v1 lifetime per that section's stated policy. -const API_VERSION: &str = "1.2.0"; +/// +/// *Since 1.6.0* — Workstream G's `module_host.*` methods (hello handshake +/// plus the RPC bridge a `bread-module-host` child uses in place of direct +/// in-process `bread.*` bindings). +/// *Since 1.7.0* — well-formed `bread.command..` is an +/// explicit exception to the reserved-domain reject on unsourced emit, and +/// sourced `AdapterSource::App` emit may publish commands to another known +/// app. `command` stays in `RESERVED_DOMAINS` so it cannot be claimed as +/// an app id. +const API_VERSION: &str = "1.7.1"; #[derive(Clone)] pub struct Server { @@ -42,6 +56,11 @@ pub struct Server { event_buffer: Arc>>, started_at: Instant, pid: u32, + /// Workstream G: token/identity bookkeeping for out-of-process module + /// hosts, shared with the Lua engine (which spawns them). See + /// `crate::module_host` and `module_host_bridge` (this module's + /// `module_host.*` method handling). + module_host_registry: ModuleHostRegistry, } #[derive(Debug, Deserialize)] @@ -62,7 +81,7 @@ struct IpcResponse { } impl Server { - // Server::new legitimately requires all 8 fields; a builder pattern here would be + // Server::new legitimately requires all 10 fields; a builder pattern here would be // over-engineering for a single-call-site constructor. #[allow(clippy::too_many_arguments)] pub fn new( @@ -75,6 +94,7 @@ impl Server { adapter_status: Arc>>, subscription_count: Arc, event_buffer: Arc>>, + module_host_registry: ModuleHostRegistry, ) -> Self { Self { socket_path, @@ -84,6 +104,7 @@ impl Server { emit_tx, raw_tx, adapter_status, + module_host_registry, subscription_count, event_buffer, started_at: Instant::now(), @@ -176,6 +197,20 @@ impl Server { return Ok(()); } + // Workstream G: a `bread-module-host` child's very first message + // presents its one-time spawn token. From here on this + // connection is a dedicated, bidirectional module-host bridge + // (RPC requests interleaved with async event/timer pushes) — + // see `module_host_bridge::handle_module_host_connection` — + // rather than a one-shot request/response exchange, so it takes + // over the rest of this connection's lifetime exactly like + // `events.subscribe` above does for a plain event stream. + if req.method == "module_host.hello" { + return self + .handle_module_host_connection(req, lines, write_half) + .await; + } + let response = match self.handle_request(req).await { Ok(res) => IpcResponse { id: res.0, @@ -222,6 +257,10 @@ impl Server { let full = self.state_handle.state_dump().await; Ok(full.get("workflows").cloned().unwrap_or_else(|| json!([]))) } + "widgets.list" => { + let full = self.state_handle.state_dump().await; + Ok(full.get("widgets").cloned().unwrap_or_else(|| json!([]))) + } "modules.reload" => { let started = Instant::now(); if let Err(err) = self.lua_runtime.reload().await { @@ -293,13 +332,17 @@ impl Server { }; // For a sibling-app source, `kind` is the full dotted event // name (e.g. "bread.clip.copied"), not a bare suffix — it - // must live inside that app's own namespace. + // must live inside that app's own namespace. Well-formed + // `bread.command..` is the one exception: + // an app may publish a command addressed to another known + // app (see `validate_command_event`). Adapter namespaces + // (`bread.power.*`, `bread.hyprland.*`, ...) stay rejected. if let AdapterSource::App(app) = &source { - if !validate_app_namespace(app, kind) { + if !validate_app_namespace(app, kind) && !validate_command_event(kind) { return Err(( id, format!( - "event '{kind}' is not in the '{app}' namespace (must start with 'bread.{app}.')" + "event '{kind}' is not in the '{app}' namespace (must start with 'bread.{app}.') and is not a well-formed command event" ), )); } @@ -319,17 +362,27 @@ impl Server { } Ok(json!({ "emitted": true })) } else { + // Unsourced emit: the manual-testing path ("bread emit + // ", used to poke Lua handlers without unplugging + // cables). Tagged `Manual`, never `System` — `System` is + // reserved for events the daemon originates itself in + // Rust code (e.g. `bread.system.startup` in `serve()` + // above), not for anything that arrived over the wire. + // A socket client can still name any custom/test event + // it likes, but not one whose top-level segment is a + // reserved, adapter-owned domain (`bread.power.*`, + // `bread.hyprland.*`, ...) — otherwise this path would + // let any same-UID process impersonate a real adapter + // event with nothing downstream able to tell the + // difference. Well-formed `bread.command..` + // is the documented exception: the command bus is + // supposed to be publishable by any module or + // `bread-emit` caller. Other reserved domains, and + // `bread.command..*`, stay rejected. let Some(event) = req.params.get("event").and_then(Value::as_str) else { return Err((id, "missing event name".to_string())); }; - if self - .emit_tx - .send(BreadEvent::new(event, AdapterSource::System, data)) - .is_err() - { - return Err((id, "emit channel closed".to_string())); - } - Ok(json!({ "emitted": true })) + self.manual_emit(event, data) } } "health" => { @@ -382,6 +435,31 @@ impl Server { } } + /// Unsourced-emit logic, factored out of `handle_request`'s `"emit"` + /// case so `module_host_bridge`'s `module_host.emit` (Workstream G) can + /// share the exact same reserved-domain guard rather than re-deriving + /// it — see the original inline comment (still above the one call site + /// in `handle_request`) for why the guard exists: a same-UID socket + /// client (or, now, a module-host child) must not be able to + /// impersonate a real adapter-owned event namespace. + fn manual_emit(&self, event: &str, data: Value) -> std::result::Result { + if let Some(domain) = event_domain(event) { + if is_reserved_domain(domain) && !validate_command_event(event) { + return Err(format!( + "event '{event}' claims the reserved '{domain}' domain — manual emit cannot impersonate an adapter-owned event; use a custom event name, a well-formed bread.command.., or a sourced emit if this should go through the normalizer" + )); + } + } + if self + .emit_tx + .send(BreadEvent::new(event, AdapterSource::Manual, data)) + .is_err() + { + return Err("emit channel closed".to_string()); + } + Ok(json!({ "emitted": true })) + } + async fn stream_events( &self, writer: &mut tokio::net::unix::OwnedWriteHalf, diff --git a/breadd/src/ipc/module_host_bridge.rs b/breadd/src/ipc/module_host_bridge.rs new file mode 100644 index 0000000..6674dc8 --- /dev/null +++ b/breadd/src/ipc/module_host_bridge.rs @@ -0,0 +1,721 @@ +//! The `module_host.*` side of the IPC protocol (Workstream G): once a +//! connection presents a valid one-time token via `module_host.hello`, this +//! module takes over its remaining lifetime as a bidirectional RPC bridge — +//! ordinary request/response lines interleaved with unsolicited +//! event/timer pushes — for exactly one `bread-module-host` child. +//! +//! # Wire shape +//! +//! Requests/responses reuse the existing `IpcRequest`/`IpcResponse` +//! envelope unchanged. Pushes are a separate, `"push"`-tagged envelope +//! (`bread_shared::ModuleHostPush`) that never collides with a response — +//! see that type's doc comment. A single `mpsc` channel (`out_tx`/`out_rx`) +//! feeds one writer task so both kinds of outgoing line interleave safely +//! on the one underlying socket without any extra locking. +//! +//! # Where the "belt" is, relative to the "suspenders" +//! +//! Every method here re-checks the module's granted `PermissionKind`s +//! before doing anything — `fs_read`/`fs_write`/`exec`/`exec_capture` +//! additionally check the manifest's `path`/`bin` scoping hint. This is +//! the belt; `module_host::apply_sandbox`'s Landlock ruleset (enforced by +//! the kernel on the child process directly, independent of whether the +//! child even uses this RPC bridge at all) is the suspenders. A module +//! that skips this bridge entirely and calls `os.execute`/`io.open` +//! directly from Lua bypasses every check in this file — that's the +//! scenario the sandbox exists for, not this file. +use std::collections::HashMap; +use std::path::{Component, Path, PathBuf}; +use std::time::Duration; + +use bread_shared::{glob, ModuleHostHello, ModuleHostPush, ModulePermission, PermissionKind}; +use serde_json::{json, Value}; +use tokio::io::{AsyncWriteExt, BufReader, Lines}; +use tokio::net::unix::{OwnedReadHalf, OwnedWriteHalf}; +use tokio::sync::{broadcast, mpsc}; +use tokio::task::JoinHandle; +use tracing::{error, info, warn}; +use uuid::Uuid; + +use crate::core::types::ModuleLoadState; +use crate::module_host::ModuleHostOutcome; + +use super::{IpcRequest, IpcResponse, Server, API_VERSION}; + +impl Server { + /// Authenticate a `module_host.hello` request against the pending-token + /// registry and, on success, run this connection's dedicated + /// request/response + push loop until it closes. Mirrors + /// `handle_connection`'s `events.subscribe` special-case in spirit + /// (taking over the rest of the connection's lifetime) but is + /// bidirectional rather than one-directional. + pub(super) async fn handle_module_host_connection( + &self, + hello_req: IpcRequest, + mut lines: Lines>, + write_half: OwnedWriteHalf, + ) -> anyhow::Result<()> { + let hello_id = hello_req.id.clone(); + let token = hello_req + .params + .get("token") + .and_then(Value::as_str) + .map(str::to_string); + + let (out_tx, mut out_rx) = mpsc::unbounded_channel::(); + let writer_task = tokio::spawn(async move { + let mut write_half = write_half; + while let Some(line) = out_rx.recv().await { + if write_half.write_all(line.as_bytes()).await.is_err() { + break; + } + } + }); + + let send = |resp: IpcResponse| -> anyhow::Result<()> { + let line = format!("{}\n", serde_json::to_string(&resp)?); + let _ = out_tx.send(line); + Ok(()) + }; + + let Some(token) = token else { + send(IpcResponse { + id: hello_id, + result: None, + error: Some("module_host.hello: missing token".to_string()), + })?; + drop(out_tx); + let _ = writer_task.await; + return Ok(()); + }; + + let Some(pending) = self.module_host_registry.take_pending(&token) else { + send(IpcResponse { + id: hello_id, + result: None, + error: Some("invalid or expired module-host token".to_string()), + })?; + drop(out_tx); + let _ = writer_task.await; + return Ok(()); + }; + + let module_name = pending.module_name.clone(); + let permissions = pending.permissions.clone(); + let mut outcome_tx = Some(pending.outcome_tx); + + let hello_result = ModuleHostHello { + module: module_name.clone(), + permissions: permissions.clone(), + api_version: API_VERSION.to_string(), + }; + send(IpcResponse { + id: hello_id, + result: Some(serde_json::to_value(&hello_result)?), + error: None, + })?; + + info!(module = %module_name, permissions = ?permissions, "module-host authenticated"); + + let mut subs: HashMap> = HashMap::new(); + let mut timers: HashMap> = HashMap::new(); + + loop { + let line = match lines.next_line().await { + Ok(Some(l)) => l, + Ok(None) => break, + Err(e) => { + warn!(module = %module_name, error = %e, "module-host connection read error"); + break; + } + }; + if line.trim().is_empty() { + continue; + } + let req: IpcRequest = match serde_json::from_str(&line) { + Ok(r) => r, + Err(e) => { + send(IpcResponse { + id: "?".to_string(), + result: None, + error: Some(format!("parse error: {e}")), + })?; + continue; + } + }; + let req_id = req.id.clone(); + let result = self + .dispatch_module_host_method( + &req, + &module_name, + &permissions, + &out_tx, + &mut subs, + &mut timers, + &mut outcome_tx, + ) + .await; + let resp = match result { + Ok(v) => IpcResponse { + id: req_id, + result: Some(v), + error: None, + }, + Err(e) => IpcResponse { + id: req_id, + result: None, + error: Some(e), + }, + }; + send(resp)?; + } + + for (_, h) in subs.drain() { + h.abort(); + } + for (_, h) in timers.drain() { + h.abort(); + } + drop(out_tx); + let _ = writer_task.await; + + // The connection dropped before the module ever reported + // load-success/load-failure (e.g. it crashed mid-`init.lua`, or + // never got that far) — unblock whatever's still waiting in + // `spawn_module_host` rather than leaving it to time out. + if let Some(tx) = outcome_tx.take() { + let _ = tx.send(ModuleHostOutcome::LoadError(format!( + "module-host connection for '{module_name}' closed before reporting ready" + ))); + } + + Ok(()) + } + + #[allow(clippy::too_many_arguments)] + async fn dispatch_module_host_method( + &self, + req: &IpcRequest, + module_name: &str, + permissions: &[ModulePermission], + out_tx: &mpsc::UnboundedSender, + subs: &mut HashMap>, + timers: &mut HashMap>, + outcome_tx: &mut Option>, + ) -> std::result::Result { + match req.method.as_str() { + "module_host.on" | "module_host.once" => { + let once = req.method == "module_host.once"; + let pattern = req + .params + .get("pattern") + .and_then(Value::as_str) + .ok_or("missing pattern")? + .to_string(); + let sub_id = Uuid::new_v4().to_string(); + let mut rx = self.event_tx.subscribe(); + let out_tx2 = out_tx.clone(); + let sid = sub_id.clone(); + let handle = tokio::spawn(async move { + loop { + match rx.recv().await { + Ok(evt) => { + if glob::matches_pattern(&pattern, &evt.event) { + let push = ModuleHostPush::Event { + subscription_id: sid.clone(), + event: evt, + }; + let Ok(line) = serde_json::to_string(&push) else { + continue; + }; + if out_tx2.send(format!("{line}\n")).is_err() { + break; + } + if once { + break; + } + } + } + Err(broadcast::error::RecvError::Lagged(_)) => continue, + Err(broadcast::error::RecvError::Closed) => break, + } + } + }); + subs.insert(sub_id.clone(), handle); + Ok(json!({ "subscription_id": sub_id })) + } + "module_host.off" => { + let id = req + .params + .get("id") + .and_then(Value::as_str) + .ok_or("missing id")? + .to_string(); + if let Some(h) = subs.remove(&id) { + h.abort(); + } + Ok(json!({ "ok": true })) + } + "module_host.after" | "module_host.every" => { + let every = req.method == "module_host.every"; + let key = if every { "interval_ms" } else { "delay_ms" }; + let ms = req + .params + .get(key) + .and_then(Value::as_u64) + .unwrap_or(0) + .max(1); + let timer_id = Uuid::new_v4().to_string(); + let out_tx2 = out_tx.clone(); + let tid = timer_id.clone(); + let handle = tokio::spawn(async move { + if every { + let mut iv = tokio::time::interval(Duration::from_millis(ms)); + iv.tick().await; // first tick fires immediately; consume it so the module's first callback fires after one full interval + loop { + iv.tick().await; + let push = ModuleHostPush::Timer { + timer_id: tid.clone(), + }; + let Ok(line) = serde_json::to_string(&push) else { + continue; + }; + if out_tx2.send(format!("{line}\n")).is_err() { + break; + } + } + } else { + tokio::time::sleep(Duration::from_millis(ms)).await; + let push = ModuleHostPush::Timer { timer_id: tid }; + if let Ok(line) = serde_json::to_string(&push) { + let _ = out_tx2.send(format!("{line}\n")); + } + } + }); + timers.insert(timer_id.clone(), handle); + Ok(json!({ "timer_id": timer_id })) + } + "module_host.cancel" => { + let id = req + .params + .get("id") + .and_then(Value::as_str) + .ok_or("missing id")? + .to_string(); + if let Some(h) = timers.remove(&id) { + h.abort(); + } + Ok(json!({ "ok": true })) + } + "module_host.state_get" => { + if !permissions + .iter() + .any(|p| p.kind == PermissionKind::StateRead) + { + return Err("state.read not granted to this module".to_string()); + } + let key = req + .params + .get("key") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + match self.state_handle.state_get(&key).await { + Some(v) => Ok(json!({ "value": v })), + None => Err("state path not found".to_string()), + } + } + "module_host.emit" => { + let event = req + .params + .get("event") + .and_then(Value::as_str) + .ok_or("missing event")? + .to_string(); + let data = req.params.get("data").cloned().unwrap_or_else(|| json!({})); + self.manual_emit(&event, data) + } + "module_host.log" | "module_host.warn" | "module_host.error" => { + let message = req + .params + .get("message") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + match req.method.as_str() { + "module_host.log" => info!(module = %module_name, "{message}"), + "module_host.warn" => warn!(module = %module_name, "{message}"), + _ => error!(module = %module_name, "{message}"), + } + Ok(json!({ "ok": true })) + } + "module_host.fs_read" => { + if !permissions.iter().any(|p| p.kind == PermissionKind::FsRead) { + return Err("fs.read not granted to this module".to_string()); + } + let path = req + .params + .get("path") + .and_then(Value::as_str) + .ok_or("missing path")? + .to_string(); + if !path_allowed(permissions, PermissionKind::FsRead, &path) { + return Err(format!( + "path '{path}' is outside this module's granted fs.read scope" + )); + } + let expanded = bread_shared::expand_path(&path); + let content = std::fs::read_to_string(&expanded).ok(); + Ok(json!({ "content": content })) + } + "module_host.fs_write" => { + if !permissions + .iter() + .any(|p| p.kind == PermissionKind::FsWrite) + { + return Err("fs.write not granted to this module".to_string()); + } + let path = req + .params + .get("path") + .and_then(Value::as_str) + .ok_or("missing path")? + .to_string(); + if !path_allowed(permissions, PermissionKind::FsWrite, &path) { + return Err(format!( + "path '{path}' is outside this module's granted fs.write scope" + )); + } + let content = req + .params + .get("content") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + let expanded = bread_shared::expand_path(&path); + if let Some(parent) = expanded.parent() { + let _ = std::fs::create_dir_all(parent); + } + std::fs::write(&expanded, content).map_err(|e| e.to_string())?; + Ok(json!({ "ok": true })) + } + "module_host.exec" => { + if !permissions.iter().any(|p| p.kind == PermissionKind::Exec) { + return Err("exec not granted to this module".to_string()); + } + let cmd = req + .params + .get("cmd") + .and_then(Value::as_str) + .ok_or("missing cmd")? + .to_string(); + let argv = exec_argv(permissions, &cmd)?; + tokio::task::spawn_blocking(move || { + match std::process::Command::new(&argv[0]) + .args(&argv[1..]) + .status() + { + Ok(status) if !status.success() => { + warn!(cmd = %argv[0], code = ?status.code(), "module_host.exec exited non-zero"); + } + Err(e) => { + error!(cmd = %argv[0], error = %e, "module_host.exec failed to spawn"); + } + _ => {} + } + }); + Ok(json!({ "ok": true })) + } + "module_host.exec_capture" => { + if !permissions.iter().any(|p| p.kind == PermissionKind::Exec) { + return Err("exec not granted to this module".to_string()); + } + let cmd = req + .params + .get("cmd") + .and_then(Value::as_str) + .ok_or("missing cmd")? + .to_string(); + let argv = exec_argv(permissions, &cmd)?; + let timeout_ms = req + .params + .get("timeout_ms") + .and_then(Value::as_u64) + .unwrap_or(2000); + let handle = tokio::task::spawn_blocking(move || { + std::process::Command::new(&argv[0]) + .args(&argv[1..]) + .output() + }); + match tokio::time::timeout(Duration::from_millis(timeout_ms + 500), handle).await { + Ok(Ok(Ok(out))) => Ok(json!({ + "ok": out.status.success(), + "stdout": String::from_utf8_lossy(&out.stdout), + })), + _ => Ok(json!({ "ok": false, "stdout": "" })), + } + } + "module_host.status" => { + let state = req + .params + .get("state") + .and_then(Value::as_str) + .unwrap_or("load_error"); + let error = req + .params + .get("error") + .and_then(Value::as_str) + .map(str::to_string); + let (load_state, outcome) = if state == "loaded" { + (ModuleLoadState::Loaded, ModuleHostOutcome::Ready) + } else { + ( + ModuleLoadState::LoadError, + ModuleHostOutcome::LoadError( + error + .clone() + .unwrap_or_else(|| "module load failed".to_string()), + ), + ) + }; + // Out-of-process modules are never "ungated": they only + // exist in this branch because they declared a manifest + // (see lua/mod.rs's load_module), so `ungated=false` + // unconditionally here is correct, not a placeholder. + self.state_handle.set_module_status_ex( + module_name.to_string(), + load_state, + error, + false, + false, + ); + if let Some(tx) = outcome_tx.take() { + let _ = tx.send(outcome); + } + Ok(json!({ "ok": true })) + } + other => Err(format!("unknown module_host method: {other}")), + } + } +} + +/// Belt-and-suspenders path scoping for `fs_read`/`fs_write`: if the +/// manifest declared a `path` hint for this permission kind, the requested +/// path (after `~`-expansion and canonicalize) must be a real descendant +/// of at least one granted prefix. No hint at all means this RPC-level +/// check stays permissive (matching Workstream D's existing "un-hinted +/// grant = ungated within that namespace" behavior) — Landlock's own +/// ruleset (built independently in `module_host::apply_sandbox`) does NOT +/// grant a filesystem rule for an un-hinted permission, so the direct +/// `os`/`io` escape hatch remains kernel-denied for that case regardless +/// of what this function returns. +fn path_allowed(permissions: &[ModulePermission], kind: PermissionKind, path: &str) -> bool { + let hints: Vec<&String> = permissions + .iter() + .filter(|p| p.kind == kind) + .filter_map(|p| p.path.as_ref()) + .collect(); + if hints.is_empty() { + return true; + } + let Some(requested) = resolve_scoped_path(path) else { + return false; + }; + hints.iter().any(|hint| { + let Some(granted) = resolve_scoped_path(hint) else { + return false; + }; + // Path::starts_with is component-wise; str::starts_with would let + // `/Wallpapers-evil` match a `/Wallpapers` grant. + requested.starts_with(&granted) + }) +} + +/// Canonicalize for containment: existing paths resolve symlinks and `..`; +/// new files canonicalize the parent then re-join the filename. Anything +/// that still contains `..` after lexical normalization is rejected. +fn resolve_scoped_path(path: &str) -> Option { + let expanded = bread_shared::expand_path(path); + if let Ok(canon) = expanded.canonicalize() { + return Some(canon); + } + let parent = expanded.parent().filter(|p| !p.as_os_str().is_empty()); + if let (Some(parent), Some(name)) = (parent, expanded.file_name()) { + if let Ok(parent_canon) = parent.canonicalize() { + return Some(parent_canon.join(name)); + } + } + lexical_abs(&expanded) +} + +fn lexical_abs(path: &Path) -> Option { + let abs = if path.is_absolute() { + path.to_path_buf() + } else { + std::path::absolute(path).ok()? + }; + let mut out = PathBuf::new(); + for c in abs.components() { + match c { + Component::CurDir => {} + Component::ParentDir => { + if !out.pop() { + return None; + } + } + rest => out.push(rest), + } + } + if out.components().any(|c| matches!(c, Component::ParentDir)) { + return None; + } + Some(out) +} + +/// Split `cmd` into argv without a shell. Metacharacters are rejected so a +/// hinted binary cannot smuggle extra commands (`hyprpaper; curl evil`). +fn parse_exec_argv(cmd: &str) -> Option> { + if cmd.chars().any(|c| { + matches!( + c, + '|' | ';' | '&' | '$' | '`' | '\n' | '\r' | '<' | '>' | '(' | ')' + ) + }) { + return None; + } + let argv: Vec = cmd.split_whitespace().map(str::to_string).collect(); + if argv.is_empty() { + None + } else { + Some(argv) + } +} + +/// Parse `cmd` and enforce the exec `bin` hint against argv[0]. +fn exec_argv(permissions: &[ModulePermission], cmd: &str) -> Result, String> { + let argv = parse_exec_argv(cmd) + .ok_or_else(|| "command contains shell metacharacters or is empty".to_string())?; + if !bin_allowed(permissions, &argv[0]) { + return Err("command is outside this module's granted exec bin scope".to_string()); + } + Ok(argv) +} + +/// Same idea as [`path_allowed`] for `exec`'s `bin` hint: compares argv[0] +/// by file name (so `bin = "hyprpaper"` matches `/usr/bin/hyprpaper` as +/// well as a bare `hyprpaper`) or an exact path match. +fn bin_allowed(permissions: &[ModulePermission], program: &str) -> bool { + let hints: Vec<&String> = permissions + .iter() + .filter(|p| p.kind == PermissionKind::Exec) + .filter_map(|p| p.bin.as_ref()) + .collect(); + if hints.is_empty() { + return true; + } + let cmd_leaf = Path::new(program) + .file_name() + .and_then(|f| f.to_str()) + .unwrap_or(program); + hints.iter().any(|hint| { + let hint_leaf = Path::new(hint.as_str()) + .file_name() + .and_then(|f| f.to_str()) + .unwrap_or(hint.as_str()); + cmd_leaf == hint_leaf || program == hint.as_str() + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn fs_grant(kind: PermissionKind, path: &str) -> Vec { + vec![ModulePermission { + kind, + path: Some(path.to_string()), + bin: None, + }] + } + + fn exec_grant(bin: &str) -> Vec { + vec![ModulePermission { + kind: PermissionKind::Exec, + path: None, + bin: Some(bin.to_string()), + }] + } + + #[test] + fn path_allowed_denies_dotdot_escape_from_granted_prefix() { + let tmp = tempfile::TempDir::new().unwrap(); + let wallpapers = tmp.path().join("Wallpapers"); + std::fs::create_dir(&wallpapers).unwrap(); + let granted = wallpapers.to_str().unwrap(); + let perms = fs_grant(PermissionKind::FsRead, granted); + + let escape = wallpapers.join("../../.ssh/id_rsa"); + assert!( + !path_allowed(&perms, PermissionKind::FsRead, escape.to_str().unwrap()), + "Wallpapers/../../.ssh/id_rsa must not match a Wallpapers grant" + ); + } + + #[test] + fn path_allowed_denies_string_prefix_sibling() { + let tmp = tempfile::TempDir::new().unwrap(); + let wallpapers = tmp.path().join("Wallpapers"); + let evil = tmp.path().join("Wallpapers-evil"); + std::fs::create_dir(&wallpapers).unwrap(); + std::fs::create_dir(&evil).unwrap(); + let secret = evil.join("secret"); + std::fs::write(&secret, "x").unwrap(); + let perms = fs_grant(PermissionKind::FsRead, wallpapers.to_str().unwrap()); + assert!(!path_allowed( + &perms, + PermissionKind::FsRead, + secret.to_str().unwrap() + )); + } + + #[test] + fn path_allowed_accepts_real_descendant_and_new_file() { + let tmp = tempfile::TempDir::new().unwrap(); + let wallpapers = tmp.path().join("Wallpapers"); + std::fs::create_dir(&wallpapers).unwrap(); + let existing = wallpapers.join("bg.png"); + std::fs::write(&existing, "x").unwrap(); + let perms = fs_grant(PermissionKind::FsWrite, wallpapers.to_str().unwrap()); + assert!(path_allowed( + &perms, + PermissionKind::FsWrite, + existing.to_str().unwrap() + )); + let new_file = wallpapers.join("new.png"); + assert!(path_allowed( + &perms, + PermissionKind::FsWrite, + new_file.to_str().unwrap() + )); + } + + #[test] + fn exec_argv_denies_shell_chaining_when_bin_hinted() { + let perms = exec_grant("hyprpaper"); + assert!(exec_argv(&perms, "hyprpaper; curl evil").is_err()); + assert!(exec_argv(&perms, "hyprpaper").is_ok()); + assert!(exec_argv(&perms, "/usr/bin/hyprpaper --config x").is_ok()); + assert!(exec_argv(&perms, "curl evil").is_err()); + } + + #[test] + fn parse_exec_argv_rejects_metacharacters() { + assert!(parse_exec_argv("hyprpaper; curl evil").is_none()); + assert!(parse_exec_argv("hyprpaper | curl evil").is_none()); + assert!(parse_exec_argv("hyprpaper && curl evil").is_none()); + assert_eq!( + parse_exec_argv("hyprpaper --config x"), + Some(vec!["hyprpaper".into(), "--config".into(), "x".into()]) + ); + } +} diff --git a/breadd/src/lua/mod.rs b/breadd/src/lua/mod.rs index 43ed598..e4bbdf5 100644 --- a/breadd/src/lua/mod.rs +++ b/breadd/src/lua/mod.rs @@ -8,9 +8,10 @@ use std::sync::{Arc, Mutex}; use std::time::Duration; use anyhow::{anyhow, Result}; -use bread_shared::{AdapterSource, BreadEvent}; +use bread_shared::widget::{WidgetNode, WidgetPlacement, WidgetSpec}; +use bread_shared::{AdapterSource, BreadEvent, ModulePermission, PermissionKind}; use mlua::{Error as LuaError, Function, Lua, LuaSerdeExt, RegistryKey, Table, Value}; -use serde::Serialize; +use serde::{Deserialize, Serialize}; use serde_json::Value as JsonValue; use tokio::sync::{mpsc, oneshot, watch, RwLock}; use tokio::task; @@ -18,11 +19,13 @@ use tokio::time::{interval_at, sleep, Instant}; use tracing::{error, info, warn}; use crate::core::config::{Config, ModulesConfig, NotificationsConfig}; +use crate::core::rules::{self, RuleAction, RulesLoadOutcome}; use crate::core::state_engine::StateHandle; use crate::core::subscriptions::SubscriptionId; use crate::core::types::{ DeviceRule, MatchCondition, ModuleLoadState, RuntimeState, WorkflowState, WorkflowStatus, }; +use crate::module_host::{self, ModuleHostOutcome, ModuleHostRegistry}; use bread_shared::now_unix_ms; pub enum LuaMessage { @@ -88,6 +91,7 @@ pub fn spawn_runtime( config: Config, state_handle: StateHandle, emit_tx: mpsc::UnboundedSender, + module_host_registry: ModuleHostRegistry, ) -> Result { let (tx, mut rx) = mpsc::unbounded_channel(); let recent_errors = Arc::new(Mutex::new(VecDeque::with_capacity(50))); @@ -112,6 +116,7 @@ pub fn spawn_runtime( emit_tx, thread_tx.clone(), recent_errors, + module_host_registry, ) { Ok(engine) => engine, Err(err) => { @@ -181,6 +186,11 @@ struct TimerEntry { callback: RegistryKey, repeating: bool, cancel_tx: watch::Sender, + /// The module active when `bread.after`/`bread.every` registered this + /// timer, so `handle_timer` can restore module context for the callback + /// (needed by module-scoped APIs like `bread.widget.*`) — same + /// `current_module` capture used for `bread.on`'s `HandlerEntry.module`. + module: Option, } #[derive(Clone)] @@ -191,6 +201,16 @@ struct ModuleDecl { path: PathBuf, source: Option<&'static str>, builtin: bool, + /// Declared `[[permissions]]` from this module's `bread.module.toml`, + /// read from disk alongside `path` for non-builtin modules (`None` for + /// builtins, which never go through manifest-based scoping at all). + /// + /// `None` here also covers the third-party, no-manifest-at-all and + /// manifest-with-no-permissions-key cases — both mean "not declared", + /// which `load_scoped_lua_file` treats as full, ungated access for + /// backward compatibility (see `Documentation.md`). `Some(vec![])` is a + /// deliberate "baseline only" declaration and is scoped down for real. + permissions: Option>, } struct ModuleInfo { @@ -205,6 +225,19 @@ struct LuaEngine { next_sub_id: Arc, next_timer_id: Arc, current_module: Arc>>, + /// The `id` of the `BreadEvent` whose subscriber callback is currently + /// executing, if any. Set immediately before invoking a handler in + /// `handle_event` and restored (not merely cleared) immediately after, + /// so nested/reentrant dispatch and a single event fan-out to multiple + /// subscriptions both see the correct parent id. Read synchronously by + /// `bread.emit()`'s binding to populate the outgoing event's + /// `caused_by`. The Lua engine runs single-threaded/cooperatively (one + /// engine instance processes `LuaMessage`s serially on a dedicated + /// thread), so a callback invocation and any `bread.emit()` inside it + /// happen synchronously within one `handle_event` call — no additional + /// synchronization beyond the existing `Mutex` (mirroring + /// `current_module` above) is needed. + current_dispatch_id: Arc>>, modules: Arc>>, module_decls: Arc>>, module_order: Arc>>, @@ -216,6 +249,11 @@ struct LuaEngine { modules_config: ModulesConfig, notifications_config: NotificationsConfig, recent_errors: Arc>>, + /// Workstream G: spawn/token bookkeeping for out-of-process module + /// hosts, shared with `ipc::Server` (which authenticates the spawned + /// children and serves their RPC calls). See `crate::module_host`. + module_host_registry: ModuleHostRegistry, + socket_path: PathBuf, } impl LuaEngine { @@ -225,7 +263,9 @@ impl LuaEngine { emit_tx: mpsc::UnboundedSender, lua_tx: mpsc::UnboundedSender, recent_errors: Arc>>, + module_host_registry: ModuleHostRegistry, ) -> Result { + let socket_path = config.socket_path(); Ok(Self { lua: Lua::new(), handlers: Arc::new(Mutex::new(HashMap::new())), @@ -234,12 +274,15 @@ impl LuaEngine { next_sub_id: Arc::new(AtomicU64::new(1)), next_timer_id: Arc::new(AtomicU64::new(1)), current_module: Arc::new(Mutex::new(None)), + current_dispatch_id: Arc::new(Mutex::new(None)), modules: Arc::new(Mutex::new(HashMap::new())), module_decls: Arc::new(Mutex::new(HashMap::new())), module_order: Arc::new(Mutex::new(Vec::new())), state_handle, emit_tx, lua_tx, + module_host_registry, + socket_path, entry_point: config.lua_entry_point(), module_path: config.lua_module_path(), modules_config: config.modules.clone(), @@ -253,6 +296,7 @@ impl LuaEngine { self.cancel_all_timers(); self.state_handle.clear_subscriptions(); self.state_handle.clear_modules(); + self.state_handle.clear_widgets(); self.lua = Lua::new(); self.handlers .lock() @@ -278,8 +322,24 @@ impl LuaEngine { self.install_api()?; self.load_device_rules()?; self.load_profiles()?; + self.load_rules_toml()?; self.load_init_and_modules()?; self.run_on_reload(); + + // clear_widgets() above is silent (no event) since it's just a state + // wipe ahead of modules re-registering. That's a problem when a + // module goes from "registered some widgets" to "disabled and + // skipped" across this reload: nothing re-registers, so no + // bread.widget.registered fires, and a renderer that only refetches + // on bread.widget.* events (see breadbar's widgets::client) never + // learns the registry emptied out. One definitive signal per reload, + // regardless of whether anything actually changed, closes that gap. + let _ = self.emit_tx.send(BreadEvent::new( + "bread.widget.cleared", + AdapterSource::System, + serde_json::json!({}), + )); + info!("lua runtime reloaded"); Ok(()) } @@ -416,6 +476,7 @@ impl LuaEngine { bread.set("off", off_fn)?; let emit_tx = self.emit_tx.clone(); + let current_dispatch_id = self.current_dispatch_id.clone(); let emit_fn = self.lua .create_function(move |lua, (event_name, payload): (String, Value)| { @@ -425,8 +486,19 @@ impl LuaEngine { .from_value::(other) .unwrap_or_else(|_| serde_json::json!({})), }; + // Daemon-internal emit — same trusted path as adapter/IPC + // construction, tagged System. If this runs synchronously + // inside a subscriber callback (see `handle_event`), thread + // the currently-dispatching event's id through as + // `caused_by` so the causality chain can be reconstructed. + let caused_by = current_dispatch_id + .lock() + .unwrap_or_else(|e| e.into_inner()) + .clone(); + let mut event = BreadEvent::new(event_name, AdapterSource::System, data); + event.caused_by = caused_by; emit_tx - .send(BreadEvent::new(event_name, AdapterSource::System, data)) + .send(event) .map_err(|_| LuaError::external("event channel closed"))?; Ok(()) })?; @@ -560,6 +632,43 @@ impl LuaEngine { })?; bread.set("exec", exec_fn)?; + // `bread.exec` is deliberately fire-and-forget (spawn_blocking, no + // result). This is the capturing counterpart for the common "run a + // fast local command and read its stdout back into Lua" case (e.g. + // `git -C rev-parse --abbrev-ref HEAD`). It blocks the calling + // Lua callback for real, so it's only appropriate for quick + // commands — hence the timeout. The subprocess itself runs on a + // plain std::thread (not spawn_blocking) so the Lua thread can wait + // on a channel with a deadline; `Command::output()` drains stdout + // internally as it reads, so a chatty command can't deadlock this by + // filling a pipe buffer while nobody's reading it. On timeout the + // spawned thread and its child are left to finish/exit on their own + // rather than force-killed — acceptable for the fast-command case + // this exists for, not worth the extra complexity for a rare hang. + let exec_capture_fn = + self.lua + .create_function(|_lua, (cmd, opts): (String, Option
)| { + let timeout_ms: u64 = opts + .as_ref() + .and_then(|o| o.get("timeout_ms").ok()) + .unwrap_or(2000); + + let (tx, rx) = std::sync::mpsc::channel(); + std::thread::spawn(move || { + let result = std::process::Command::new("sh").arg("-c").arg(&cmd).output(); + let _ = tx.send(result); + }); + + match rx.recv_timeout(std::time::Duration::from_millis(timeout_ms)) { + Ok(Ok(output)) => Ok(( + output.status.success(), + String::from_utf8_lossy(&output.stdout).to_string(), + )), + Ok(Err(_)) | Err(_) => Ok((false, String::new())), + } + })?; + bread.set("exec_capture", exec_capture_fn)?; + let notify_path = self.notifications_config.notify_send_path.clone(); let default_urgency = self.notifications_config.default_urgency.clone(); let default_timeout = self.notifications_config.default_timeout_ms; @@ -618,12 +727,17 @@ impl LuaEngine { let timers = self.timers.clone(); let next_timer_id = self.next_timer_id.clone(); let lua_tx = self.lua_tx.clone(); + let current_module = self.current_module.clone(); let after_fn = self.lua .create_function(move |lua, (delay_ms, callback): (u64, Function)| { let id = TimerId(next_timer_id.fetch_add(1, Ordering::Relaxed)); let key = lua.create_registry_value(callback)?; let (cancel_tx, mut cancel_rx) = watch::channel(false); + let module = current_module + .lock() + .map_err(|_| LuaError::external("module context lock poisoned"))? + .clone(); timers .lock() .map_err(|_| LuaError::external("timer lock poisoned"))? @@ -633,6 +747,7 @@ impl LuaEngine { callback: key, repeating: false, cancel_tx, + module, }, ); let lua_tx = lua_tx.clone(); @@ -653,12 +768,17 @@ impl LuaEngine { let timers = self.timers.clone(); let next_timer_id = self.next_timer_id.clone(); let lua_tx = self.lua_tx.clone(); + let current_module = self.current_module.clone(); let every_fn = self.lua .create_function(move |lua, (interval_ms, callback): (u64, Function)| { let id = TimerId(next_timer_id.fetch_add(1, Ordering::Relaxed)); let key = lua.create_registry_value(callback)?; let (cancel_tx, mut cancel_rx) = watch::channel(false); + let module = current_module + .lock() + .map_err(|_| LuaError::external("module context lock poisoned"))? + .clone(); timers .lock() .map_err(|_| LuaError::external("timer lock poisoned"))? @@ -668,6 +788,7 @@ impl LuaEngine { callback: key, repeating: true, cancel_tx, + module, }, ); let lua_tx = lua_tx.clone(); @@ -737,7 +858,7 @@ impl LuaEngine { .map_err(|e| LuaError::external(e.to_string()))?; let json: JsonValue = serde_json::from_str(&resp).map_err(|e| LuaError::external(e.to_string()))?; - lua.to_value(&json) + json_to_lua(lua, &json) .map_err(|e| LuaError::external(e.to_string())) })?; hyprland_tbl.set("active_window", active_window_fn)?; @@ -747,7 +868,7 @@ impl LuaEngine { hyprland_request("j/monitors").map_err(|e| LuaError::external(e.to_string()))?; let json: JsonValue = serde_json::from_str(&resp).map_err(|e| LuaError::external(e.to_string()))?; - lua.to_value(&json) + json_to_lua(lua, &json) .map_err(|e| LuaError::external(e.to_string())) })?; hyprland_tbl.set("monitors", monitors_fn)?; @@ -757,7 +878,7 @@ impl LuaEngine { hyprland_request("j/workspaces").map_err(|e| LuaError::external(e.to_string()))?; let json: JsonValue = serde_json::from_str(&resp).map_err(|e| LuaError::external(e.to_string()))?; - lua.to_value(&json) + json_to_lua(lua, &json) .map_err(|e| LuaError::external(e.to_string())) })?; hyprland_tbl.set("workspaces", workspaces_fn)?; @@ -767,7 +888,7 @@ impl LuaEngine { hyprland_request("j/clients").map_err(|e| LuaError::external(e.to_string()))?; let json: JsonValue = serde_json::from_str(&resp).map_err(|e| LuaError::external(e.to_string()))?; - lua.to_value(&json) + json_to_lua(lua, &json) .map_err(|e| LuaError::external(e.to_string())) })?; hyprland_tbl.set("clients", clients_fn)?; @@ -840,9 +961,7 @@ impl LuaEngine { let state_arc_get = state_arc.clone(); let get_fn = lua.create_function(move |lua, key: String| { if let Some(value) = module_store_get(&state_arc_get, &module_name, &key) { - return lua - .to_value(&value) - .map_err(|e| LuaError::external(e.to_string())); + return json_to_lua(lua, &value).map_err(|e| LuaError::external(e.to_string())); } Ok(Value::Nil) })?; @@ -875,6 +994,122 @@ impl LuaEngine { })?; bread.set("module", module_fn)?; + // bread.widget — declarative, live-updating widgets rendered by + // sibling bread* apps (breadbar) in their bar/popover free space. + // Follows the same Rust-backed-registry pattern as bread.workflow + // (see install_workflow_helpers / workflow_register below): + // mutate RuntimeState.widgets via the try_write spin-lock, then + // emit a bread.widget.* event so subscribers (and, indirectly, + // breadbar's events.subscribe stream) observe the change. + let widget_tbl = self.lua.create_table()?; + + let state_arc = self.state_handle.state_arc(); + let current_module = self.current_module.clone(); + let emit_tx = self.emit_tx.clone(); + let widget_register_fn = self.lua.create_function( + move |lua, spec_table: Table| -> mlua::Result<(bool, Option)> { + let module = current_module + .lock() + .map_err(|_| LuaError::external("module context lock poisoned"))? + .clone() + .ok_or_else(|| { + LuaError::external("bread.widget.register must be called from within a module") + })?; + let args: WidgetRegisterArgs = match lua.from_value(Value::Table(spec_table)) { + Ok(a) => a, + Err(e) => return Ok((false, Some(e.to_string()))), + }; + Ok(match widget_register(&state_arc, &module, args) { + Ok(spec) => { + let data = serde_json::to_value(&spec).unwrap_or_default(); + let _ = emit_tx.send(BreadEvent::new( + "bread.widget.registered", + AdapterSource::System, + data, + )); + (true, None) + } + Err(e) => (false, Some(e.to_string())), + }) + }, + )?; + widget_tbl.set("register", widget_register_fn)?; + + let state_arc = self.state_handle.state_arc(); + let current_module = self.current_module.clone(); + let emit_tx = self.emit_tx.clone(); + let widget_update_fn = self.lua.create_function( + move |lua, (local_id, patch): (String, Table)| -> mlua::Result<(bool, Option)> { + let module = current_module + .lock() + .map_err(|_| LuaError::external("module context lock poisoned"))? + .clone() + .ok_or_else(|| { + LuaError::external("bread.widget.update must be called from within a module") + })?; + let args: WidgetUpdateArgs = match lua.from_value(Value::Table(patch)) { + Ok(a) => a, + Err(e) => return Ok((false, Some(e.to_string()))), + }; + Ok(match widget_update(&state_arc, &module, &local_id, args) { + Ok(Some(spec)) => { + let data = serde_json::to_value(&spec).unwrap_or_default(); + let _ = emit_tx.send(BreadEvent::new( + "bread.widget.updated", + AdapterSource::System, + data, + )); + (true, None) + } + Ok(None) => (false, Some("no such widget".to_string())), + Err(e) => (false, Some(e.to_string())), + }) + }, + )?; + widget_tbl.set("update", widget_update_fn)?; + + let state_arc = self.state_handle.state_arc(); + let current_module = self.current_module.clone(); + let emit_tx = self.emit_tx.clone(); + let widget_remove_fn = self.lua.create_function(move |_lua, local_id: String| { + let module = current_module + .lock() + .map_err(|_| LuaError::external("module context lock poisoned"))? + .clone() + .ok_or_else(|| { + LuaError::external("bread.widget.remove must be called from within a module") + })?; + let full_id = format!("{module}.{local_id}"); + let removed = widget_remove(&state_arc, &module, &local_id); + if removed { + let _ = emit_tx.send(BreadEvent::new( + "bread.widget.removed", + AdapterSource::System, + serde_json::json!({ "id": full_id }), + )); + } + Ok(removed) + })?; + widget_tbl.set("remove", widget_remove_fn)?; + + let state_arc = self.state_handle.state_arc(); + let current_module = self.current_module.clone(); + let widget_list_fn = self.lua.create_function(move |lua, ()| { + let module = current_module + .lock() + .map_err(|_| LuaError::external("module context lock poisoned"))? + .clone() + .ok_or_else(|| { + LuaError::external("bread.widget.list must be called from within a module") + })?; + let json = widget_list_json(&state_arc, &module); + json_to_lua(lua, &json) + .map_err(|e| LuaError::external(e.to_string())) + })?; + widget_tbl.set("list", widget_list_fn)?; + + bread.set("widget", widget_tbl)?; + // bread.machine — hostname/tags; reads an optional, externally-managed // ~/.config/bread/sync.toml if present (bread does not create it) let machine_tbl = self.lua.create_table()?; @@ -930,6 +1165,19 @@ impl LuaEngine { .create_function(|_lua, path: String| Ok(lua_expand_path(&path).exists()))?; fs_tbl.set("exists", exists_fn)?; + // Distinct from `read`: `/proc//cwd` and friends are symlinks + // whose *target path* is the payload, not a file to open and read — + // `std::fs::read_to_string` on one of those fails with "Is a + // directory" (or reads the wrong thing for a symlink-to-file). + let readlink_fn = self.lua.create_function(|_lua, path: String| { + let expanded = lua_expand_path(&path); + match std::fs::read_link(&expanded) { + Ok(target) => Ok(Some(target.to_string_lossy().to_string())), + Err(_) => Ok(None), + } + })?; + fs_tbl.set("readlink", readlink_fn)?; + let expand_fn = self.lua.create_function(|_lua, path: String| { Ok(lua_expand_path(&path).to_string_lossy().to_string()) })?; @@ -937,6 +1185,21 @@ impl LuaEngine { bread.set("fs", fs_tbl)?; + // bread.json — for parsing output from things like `kitty @ ls` or + // any other JSON-emitting CLI invoked via bread.exec_capture. Uses + // the same null-handling as every other JSON entry point into Lua + // (json_to_lua, not a bare to_value) so `nil` behaves as Lua nil, + // not a sentinel. + let json_tbl = self.lua.create_table()?; + let decode_fn = self.lua.create_function(|lua, s: String| { + match serde_json::from_str::(&s) { + Ok(v) => json_to_lua(lua, &v).map(Some).or(Ok(None)), + Err(_) => Ok(None), + } + })?; + json_tbl.set("decode", decode_fn)?; + bread.set("json", json_tbl)?; + // bread.bluetooth — BlueZ control let bluetooth_tbl = self.lua.create_table()?; @@ -1106,6 +1369,70 @@ impl LuaEngine { .map_err(|e| anyhow!("profiles.lua error: {e}")) } + /// Reads and validates `rules.toml` (if present) and stashes the result + /// in Lua globals for `bread.rules`'s `on_load()` to pick up once + /// `load_init_and_modules()` loads that built-in module. See the + /// `BUILTIN_RULES` doc comment for why globals rather than generating + /// Lua source text: the rule data is dynamic (comes from a config file + /// parsed fresh each reload) while `ModuleDecl::source` is a + /// `&'static str`, so passing it as real Lua values via `mlua`'s Table + /// API sidesteps ever having to hand-escape a path or shell command + /// into a Lua string literal. + fn load_rules_toml(&self) -> Result<()> { + let path = rules::rules_path(); + match rules::load_rules(&path) { + RulesLoadOutcome::Absent => Ok(()), + RulesLoadOutcome::Fatal(msg) => { + self.lua.globals().set("__rules_fatal", msg)?; + Ok(()) + } + RulesLoadOutcome::Loaded { rules, issues } => { + let data = self.lua.create_table()?; + for (i, rule) in rules.iter().enumerate() { + let tbl = self.lua.create_table()?; + tbl.set("on", rule.on.clone())?; + match &rule.action { + // `run` names exactly one program: tilde-expand it + // the same way `bread.fs.*`/`bread.exec` callers + // would, then shell-quote the whole thing so a path + // containing spaces still runs as one file rather + // than being word-split by the `sh -c` that + // `bread.exec()` runs it through. + RuleAction::Run(path) => { + let expanded = lua_expand_path(path); + let quoted = shell_quote(&expanded.to_string_lossy()); + tbl.set("run", quoted)?; + } + // `exec` is a full shell command line — pass it + // through to `bread.exec()` verbatim, exactly like + // hand-written Lua calling `bread.exec()` directly. + RuleAction::Exec(cmd) => { + tbl.set("exec", cmd.clone())?; + } + RuleAction::Notify(message) => { + tbl.set("notify", message.clone())?; + } + } + data.set(i + 1, tbl)?; + } + self.lua.globals().set("__rules_data", data)?; + + if !issues.is_empty() { + let combined = issues + .iter() + .map(|issue| issue.to_string()) + .collect::>() + .join("; "); + self.lua + .globals() + .set("__rules_warning", format!("rules.toml: {combined}"))?; + } + + Ok(()) + } + } + } + fn load_init_and_modules(&self) -> Result<()> { self.load_lua_file(&self.entry_point, "init", false)?; @@ -1122,10 +1449,34 @@ impl LuaEngine { .into_iter() .filter(|p| !is_lib_path(&self.module_path, p)) { + let name = module_name_from_path(&self.module_path, &path); + // bos-settings' module picker writes filenames (e.g. + // "widget.lua") into `disable`, not the bare module name a file + // registers under via bread.module({name=...}) — match either + // form so both conventions work rather than requiring the UI + // and the daemon to agree on one exact string. + let filename = path.file_name().and_then(|f| f.to_str()).unwrap_or(""); + if disabled.contains(&name) || disabled.contains(filename) { + self.state_handle + .set_module_status(name, ModuleLoadState::Disabled, None, false); + continue; + } + match self.scan_module_decl(&path) { - Ok(decl) => decls.push(decl), + Ok(mut decl) => { + // Manifest lives beside the module's entry file + // (bread-cli's install_from_local always writes + // //{bread.module.toml,init.lua} — + // see bread-cli/src/modules_mgmt.rs). A hand-authored + // flat file with no sibling manifest (e.g. the + // "Your first module" walkthrough's modules/hello.lua) + // has no manifest to find at all, which read_module_permissions + // reports the same way as an existing-but-permissions-less + // one: None, i.e. full ungated backward-compat access. + decl.permissions = read_module_permissions(&path); + decls.push(decl); + } Err(err) => { - let name = module_name_from_path(&self.module_path, &path); self.state_handle.set_module_status( name, ModuleLoadState::LoadError, @@ -1153,21 +1504,28 @@ impl LuaEngine { let mut load_order = Vec::new(); for decl in ordered { load_order.push(decl.name.clone()); + // Static per-decl (not per-status-transition) property: whether + // this module is running with full, ungated bread.* access. Only + // ever true for a non-builtin module with no declared + // permissions — see ModuleDecl::permissions' doc comment. + let ungated = !decl.builtin && decl.permissions.is_none(); match self.load_module(&decl) { Ok(()) => { - self.state_handle.set_module_status( + self.state_handle.set_module_status_ex( decl.name.clone(), ModuleLoadState::Loaded, None, decl.builtin, + ungated, ); } Err(err) => { - self.state_handle.set_module_status( + self.state_handle.set_module_status_ex( decl.name.clone(), ModuleLoadState::LoadError, Some(err.to_string()), decl.builtin, + ungated, ); } } @@ -1179,11 +1537,37 @@ impl LuaEngine { } fn load_module(&self, decl: &ModuleDecl) -> Result<()> { + // Workstream G branch point: a third-party module that declared + // `[[permissions]]` (opted into the D capability-manifest system — + // `decl.permissions.is_some()`, including `Some(&[])`) gets spawned + // as a separate, OS-sandboxed `bread-module-host` process instead of + // being loaded into this Lua VM at all. Its Lua state, `bread.on` + // handlers, timers, etc. all live in that other process from here + // on — none of this engine's module-table/on_load bookkeeping below + // applies to it, hence the early return. + // + // `decl.permissions.is_none()` (no manifest, or a manifest with no + // `permissions` key) falls through to the unchanged in-process, + // unscoped path for backward compatibility — see + // `ModuleDecl::permissions`'s doc comment and `Documentation.md`'s + // "Workstream G" section for why this is a deliberate scope + // decision rather than an oversight: Landlock needs concrete rules + // to build from, and "no manifest at all" carries none. + if decl.source.is_none() { + if let Some(permissions) = decl.permissions.as_ref() { + return self.load_out_of_process_module(decl, permissions); + } + } + self.set_current_module(Some(decl.name.clone())); let result = if let Some(source) = decl.source { + // Builtins (bread.monitors/devices/workspaces/binds) — embedded + // source, always the full ambient bread table, never scoped. self.load_lua_source(source, &decl.name) } else { - self.load_lua_file(&decl.path, &decl.name, decl.builtin) + // Third-party, on-disk, no-manifest module: today's original + // behavior, unchanged (full ungated in-process access). + self.load_scoped_lua_file(&decl.path, &decl.name, None) }; self.set_current_module(None); result?; @@ -1192,10 +1576,39 @@ impl LuaEngine { return Err(anyhow!("module did not call bread.module")); } - self.run_on_load(&decl.name); - Ok(()) + self.run_on_load(&decl.name) } + /// Spawn (or respawn, on `bread reload`) a sandboxed `bread-module-host` + /// child for `decl` and block until it reports ready or fails — see + /// `crate::module_host::spawn_module_host`. Blocking here (rather than + /// making `load_module` async) keeps `load_module`'s existing + /// synchronous "a module either loaded or it didn't" contract intact + /// for callers like `load_init_and_modules` and the `modules.reload` + /// IPC method, which both expect to know Loaded-vs-LoadError before + /// they return. + fn load_out_of_process_module( + &self, + decl: &ModuleDecl, + permissions: &[ModulePermission], + ) -> Result<()> { + let outcome = module_host::spawn_module_host( + &self.module_host_registry, + &decl.name, + &decl.path, + permissions, + &self.socket_path, + &self.emit_tx, + )?; + match outcome { + ModuleHostOutcome::Ready => Ok(()), + ModuleHostOutcome::LoadError(err) => Err(anyhow!(err)), + } + } + + /// Load `init.lua` (the trusted entry point) or any other file that + /// should see the real, unscoped `bread` global exactly like today. + /// Not used for third-party modules — see [`load_scoped_lua_file`]. fn load_lua_file(&self, path: &Path, module_name: &str, builtin: bool) -> Result<()> { if !path.exists() { warn!(path = %path.display(), "lua file does not exist; skipping"); @@ -1216,6 +1629,207 @@ impl LuaEngine { Ok(()) } + /// Load a third-party module's `.lua` file, giving its chunk a + /// capability-scoped `_ENV` instead of the real shared globals. + /// + /// `permissions: None` means the module's manifest declared no + /// `permissions` at all (no manifest on disk, or a manifest predating + /// this field) — backward compat: full, ungated access, identical to + /// `load_lua_file`. `Some(perms)` (including `Some(&[])`) builds a fresh + /// `bread` table containing only the baseline bindings plus whatever + /// `perms` grants, and sets it as the chunk's environment. See + /// `build_scoped_env` for how `require`/stdlib stay reachable. + fn load_scoped_lua_file( + &self, + path: &Path, + module_name: &str, + permissions: Option<&[ModulePermission]>, + ) -> Result<()> { + if !path.exists() { + warn!(path = %path.display(), "lua file does not exist; skipping"); + self.state_handle.set_module_status( + module_name.to_string(), + ModuleLoadState::NotFound, + None, + false, + ); + return Ok(()); + } + + let src = fs::read_to_string(path)?; + let chunk = self.lua.load(&src).set_name(path.to_string_lossy().as_ref()); + + match permissions { + None => { + // No manifest / no permissions declared: today's behavior, + // unchanged. Do NOT call set_environment here at all (rather + // than passing globals() explicitly) so this stays + // byte-for-byte the same code path load_lua_file already + // uses and has always used. + chunk.exec()?; + } + Some(perms) => { + let env = self.build_scoped_env(perms)?; + chunk.set_environment(env).exec()?; + } + } + Ok(()) + } + + /// Build a fresh `_ENV` table for a capability-scoped module chunk. + /// + /// Shape: a table whose own `bread` key is a *new* table containing only + /// the baseline bindings (event subscription, timers, json, module/ + /// store, logging, and the pure-Lua sugar built on top of those — + /// debounce/spawn/wait*/workflow) plus whichever gated namespaces + /// `perms` grants (fs, exec, notify, machine, hyprland, widget, + /// bluetooth, state, profile — split at the granularity the manifest + /// schema exposes, e.g. `fs.read` without `fs.write` yields a `bread.fs` + /// table with `.read`/`.exists`/`.readlink`/`.expand` but no `.write`). + /// A permission that isn't granted means the corresponding key is + /// genuinely absent (`bread.fs == nil`), not present-but-erroring. + /// + /// Everything else — `pairs`, `string`, `table`, `math`, `pcall`, + /// `coroutine`, `require`, `package`, ... — is reached through a + /// metatable `__index` that falls back to the real global table, so + /// `require("bread.devices")` still works: `require` is the real global + /// function operating on the real global `package.loaded`, which + /// already contains `bread.devices`'s module table by the time any + /// third-party module loads (builtins load first). That module table's + /// own methods (`devices.on()` etc.) were themselves defined while + /// `bread.devices` was loaded unscoped, so they close over the *real* + /// `bread` table as an upvalue — Lua closures capture their defining + /// environment lexically, not the caller's — which is exactly why + /// `require("bread.devices")` keeps working from inside a scoped module + /// with no special-casing needed here. + /// + /// One deliberate hardening step beyond that: `_G` is explicitly + /// rebound to point at this same scoped table (self-referentially, the + /// same way stock Lua's base library self-references the real global + /// table under `_G`). Without that, `local G = _G; G.bread.fs...` would + /// walk straight past the whole mechanism, since `_G` is just an + /// ordinary global (not magic in Lua 5.2+) and would otherwise resolve + /// through the `__index` fallback to the *real* globals table. + /// + /// What this does **not** do: strip `os`/`io`/`debug` from the + /// fallback. Those remain reachable from a scoped module exactly as + /// they are from an unscoped one — `os.execute`/`io.open` bypass + /// `bread.exec`/`bread.fs` gating entirely if a module chooses to use + /// them directly. This mechanism gates the documented `bread.*` API + /// surface (so a well-behaved module naturally degrades, and an + /// accidental over-reach is caught), it is not a hard security boundary + /// against a deliberately malicious script — that's what the + /// out-of-process module sandboxing workstream this manifest schema + /// exists for is for. + fn build_scoped_env(&self, perms: &[ModulePermission]) -> Result> { + let globals = self.lua.globals(); + let real_bread: Table = globals.get("bread")?; + + let granted: HashSet = perms.iter().map(|p| p.kind).collect(); + + let scoped_bread = self.lua.create_table()?; + + // Baseline — always available, no manifest entry required. + const BASELINE_KEYS: &[&str] = &[ + "on", "once", "filter", "off", "emit", "after", "every", "cancel", "json", "module", + "log", "warn", "error", "debounce", "spawn", "wait", "wait_any", "wait_all", + "workflow", + ]; + for key in BASELINE_KEYS { + let v: Value = real_bread.get(*key)?; + if !matches!(v, Value::Nil) { + scoped_bread.set(*key, v)?; + } + } + + if granted.contains(&PermissionKind::StateRead) || granted.contains(&PermissionKind::StateWatch) + { + let real_state: Table = real_bread.get("state")?; + let scoped_state = self.lua.create_table()?; + if granted.contains(&PermissionKind::StateRead) { + for key in [ + "get", + "monitors", + "active_workspace", + "active_window", + "devices", + "power", + "network", + "profile", + ] { + let v: Value = real_state.get(key)?; + scoped_state.set(key, v)?; + } + } + if granted.contains(&PermissionKind::StateWatch) { + let v: Value = real_state.get("watch")?; + scoped_state.set("watch", v)?; + } + scoped_bread.set("state", scoped_state)?; + } + + if granted.contains(&PermissionKind::ProfileActivate) { + let v: Value = real_bread.get("profile")?; + scoped_bread.set("profile", v)?; + } + + if granted.contains(&PermissionKind::Exec) { + let exec: Value = real_bread.get("exec")?; + scoped_bread.set("exec", exec)?; + let exec_capture: Value = real_bread.get("exec_capture")?; + scoped_bread.set("exec_capture", exec_capture)?; + } + + if granted.contains(&PermissionKind::Notify) { + let v: Value = real_bread.get("notify")?; + scoped_bread.set("notify", v)?; + } + + if granted.contains(&PermissionKind::Machine) { + let v: Value = real_bread.get("machine")?; + scoped_bread.set("machine", v)?; + } + + if granted.contains(&PermissionKind::Hyprland) { + let v: Value = real_bread.get("hyprland")?; + scoped_bread.set("hyprland", v)?; + } + + if granted.contains(&PermissionKind::Widget) { + let v: Value = real_bread.get("widget")?; + scoped_bread.set("widget", v)?; + } + + if granted.contains(&PermissionKind::Bluetooth) { + let v: Value = real_bread.get("bluetooth")?; + scoped_bread.set("bluetooth", v)?; + } + + if granted.contains(&PermissionKind::FsRead) || granted.contains(&PermissionKind::FsWrite) { + let real_fs: Table = real_bread.get("fs")?; + let scoped_fs = self.lua.create_table()?; + if granted.contains(&PermissionKind::FsRead) { + for key in ["read", "exists", "readlink", "expand"] { + let v: Value = real_fs.get(key)?; + scoped_fs.set(key, v)?; + } + } + if granted.contains(&PermissionKind::FsWrite) { + let v: Value = real_fs.get("write")?; + scoped_fs.set("write", v)?; + } + scoped_bread.set("fs", scoped_fs)?; + } + + let env = self.lua.create_table()?; + let mt = self.lua.create_table()?; + mt.set("__index", self.lua.globals())?; + env.set_metatable(Some(mt)); + env.set("bread", scoped_bread)?; + env.set("_G", env.clone())?; + Ok(env) + } + fn load_lua_source(&self, source: &str, module_name: &str) -> Result<()> { self.lua .load(source) @@ -1257,26 +1871,36 @@ impl LuaEngine { } if let Some(filter) = filter { - let event_value = self.lua.to_value(&event)?; + let event_value = json_to_lua(&self.lua, &event)?; let allowed = filter.call::<_, bool>(event_value).unwrap_or(false); if !allowed { return Ok(()); } } + self.set_current_module(module.clone()); + // Every subscriber invocation triggered by this event should see the + // same parent id, and a `bread.emit()` call made synchronously + // inside the callback should attribute its `caused_by` to *this* + // event, not whatever was dispatching (if anything) before it. + let previous_dispatch_id = self.set_current_dispatch_id(Some(event.id.clone())); let result = match kind { HandlerKind::Event => { - let event_value = self.lua.to_value(&event)?; + let event_value = json_to_lua(&self.lua, &event)?; callback.call::<_, ()>(event_value) } HandlerKind::StateWatch => { let new_val = event.data.get("new").cloned().unwrap_or(JsonValue::Null); let old_val = event.data.get("old").cloned().unwrap_or(JsonValue::Null); - let new_lua = self.lua.to_value(&new_val)?; - let old_lua = self.lua.to_value(&old_val)?; + let new_lua = json_to_lua(&self.lua, &new_val)?; + let old_lua = json_to_lua(&self.lua, &old_val)?; callback.call::<_, ()>((new_lua, old_lua)) } }; + // Restore rather than clear, so this correctly unwinds if dispatch + // is ever reentrant (e.g. a callback that pumps messages itself). + self.set_current_dispatch_id(previous_dispatch_id); + self.set_current_module(None); if let Err(err) = result { error!(subscription = id.0, error = %err, "lua callback failed"); @@ -1286,15 +1910,18 @@ impl LuaEngine { } fn handle_timer(&self, id: TimerId) -> Result<()> { - let (callback, repeating) = { + let (callback, repeating, module) = { let timers = self.timers.lock().unwrap_or_else(|e| e.into_inner()); let Some(entry) = timers.get(&id) else { return Ok(()); }; let callback: Function = self.lua.registry_value(&entry.callback)?; - (callback, entry.repeating) + (callback, entry.repeating, entry.module.clone()) }; - if let Err(err) = callback.call::<_, ()>(()) { + self.set_current_module(module); + let result = callback.call::<_, ()>(()); + self.set_current_module(None); + if let Err(err) = result { error!(timer = id.0, error = %err, "lua timer callback failed"); } @@ -1312,19 +1939,24 @@ impl LuaEngine { } } - fn run_on_load(&self, name: &str) { + fn run_on_load(&self, name: &str) -> Result<()> { if let Some(hook) = self.get_module_hook(name, "on_load") { - if let Err(err) = hook.call::<_, ()>(()) { + self.set_current_module(Some(name.to_string())); + let result = hook.call::<_, ()>(()); + self.set_current_module(None); + if let Err(err) = result { error!(module = %name, error = %err, "module on_load failed"); - let builtin = self.module_is_builtin(name); - self.state_handle.set_module_status( - name.to_string(), - ModuleLoadState::LoadError, - Some(err.to_string()), - builtin, - ); + // Propagate rather than setting LoadError here directly: the + // caller (load_module, via load_init_and_modules) is the + // single place that decides Loaded vs LoadError for a + // module, so this failure isn't immediately clobbered back + // to Loaded by that outer Ok(()) branch — which is exactly + // what used to happen when this function swallowed the + // error and always returned successfully. + return Err(anyhow!(err.to_string())); } } + Ok(()) } fn run_on_reload(&self) { @@ -1335,14 +1967,18 @@ impl LuaEngine { .clone(); for name in order { if let Some(hook) = self.get_module_hook(&name, "on_reload") { - if let Err(err) = hook.call::<_, ()>(()) { + self.set_current_module(Some(name.clone())); + let result = hook.call::<_, ()>(()); + self.set_current_module(None); + if let Err(err) = result { error!(module = %name, error = %err, "module on_reload failed"); let builtin = self.module_is_builtin(&name); - self.state_handle.set_module_status( + self.state_handle.set_module_status_ex( name.to_string(), ModuleLoadState::Degraded, Some(err.to_string()), builtin, + self.module_ungated(&name), ); } } @@ -1357,14 +1993,18 @@ impl LuaEngine { .clone(); for name in order.into_iter().rev() { if let Some(hook) = self.get_module_hook(&name, "on_unload") { - if let Err(err) = hook.call::<_, ()>(()) { + self.set_current_module(Some(name.clone())); + let result = hook.call::<_, ()>(()); + self.set_current_module(None); + if let Err(err) = result { error!(module = %name, error = %err, "module on_unload failed"); let builtin = self.module_is_builtin(&name); - self.state_handle.set_module_status( + self.state_handle.set_module_status_ex( name.to_string(), ModuleLoadState::Degraded, Some(err.to_string()), builtin, + self.module_ungated(&name), ); } } @@ -1384,11 +2024,12 @@ impl LuaEngine { message: err.to_string(), }); } - self.state_handle.set_module_status( + self.state_handle.set_module_status_ex( module.to_string(), ModuleLoadState::Degraded, Some(err.to_string()), builtin, + self.module_ungated(module), ); if let Some(hook) = self.get_module_hook(module, "on_error") { match hook.call::<_, bool>(err.to_string()) { @@ -1432,12 +2073,39 @@ impl LuaEngine { .unwrap_or(false) } + /// Whether `name` is a third-party module running with full, ungated + /// `bread.*` access (no `permissions` declared). See + /// `ModuleDecl::permissions`'s doc comment for exactly what "declared" + /// means. Always `false` for builtins and for unknown module names. + fn module_ungated(&self, name: &str) -> bool { + self.module_decls + .lock() + .ok() + .and_then(|map| { + map.get(name) + .map(|d| !d.builtin && d.permissions.is_none()) + }) + .unwrap_or(false) + } + fn set_current_module(&self, name: Option) { if let Ok(mut guard) = self.current_module.lock() { *guard = name; } } + /// Set the "currently dispatching" event id, returning whatever id was + /// there before. Callers restore the previous value (rather than + /// clearing to `None`) when the handler invocation finishes, so nested/ + /// reentrant dispatch unwinds correctly — see `current_dispatch_id`'s + /// doc comment on the struct definition. + fn set_current_dispatch_id(&self, id: Option) -> Option { + match self.current_dispatch_id.lock() { + Ok(mut guard) => std::mem::replace(&mut *guard, id), + Err(poisoned) => std::mem::replace(&mut *poisoned.into_inner(), id), + } + } + fn cancel_all_timers(&self) { if let Ok(mut map) = self.timers.lock() { for (_, entry) in map.drain() { @@ -1556,6 +2224,10 @@ impl LuaEngine { path: module_path.clone(), source: None, builtin: false, + // Populated afterwards by the caller (load_init_and_modules), + // which reads bread.module.toml from disk — scan_module_decl + // only cares about the bread.module({...}) declaration itself. + permissions: None, }); Err(LuaError::RuntimeError(MODULE_DECL_ABORT.to_string())) })?; @@ -1741,9 +2413,7 @@ impl LuaEngine { let state_arc = self.state_handle.state_arc(); let status_fn = self.lua.create_function(move |lua, name: String| { match workflow_status_json(&state_arc, &name) { - Some(json) => lua - .to_value(&json) - .map_err(|e| LuaError::external(e.to_string())), + Some(json) => json_to_lua(lua, &json).map_err(|e| LuaError::external(e.to_string())), None => Ok(Value::Nil), } })?; @@ -1752,7 +2422,7 @@ impl LuaEngine { let state_arc = self.state_handle.state_arc(); let list_fn = self.lua.create_function(move |lua, ()| { let json = workflow_list_json(&state_arc); - lua.to_value(&json) + json_to_lua(lua, &json) .map_err(|e| LuaError::external(e.to_string())) })?; bread.set("__workflow_list", list_fn)?; @@ -2037,6 +2707,133 @@ fn workflow_list_json(state_arc: &Arc>) -> JsonValue { serde_json::to_value(&guard.workflows).unwrap_or_else(|_| JsonValue::Array(vec![])) } +/// Table shape accepted by `bread.widget.register`. Parsed directly from the +/// Lua table via mlua's serde bridge, so `root`'s nested `children` tables +/// deserialize straight into a `WidgetNode` tree without a manual walker. +#[derive(Debug, Deserialize)] +struct WidgetRegisterArgs { + id: String, + placement: WidgetPlacement, + #[serde(default)] + order: i32, + #[serde(default = "default_widget_visible")] + visible: bool, + #[serde(default)] + tooltip: Option, + root: WidgetNode, +} + +/// Table shape accepted by `bread.widget.update` — every field optional, so +/// a caller can patch just what changed (typically just `root` on a timer). +#[derive(Debug, Default, Deserialize)] +struct WidgetUpdateArgs { + #[serde(default)] + root: Option, + #[serde(default)] + tooltip: Option, + #[serde(default)] + visible: Option, + #[serde(default)] + order: Option, +} + +fn default_widget_visible() -> bool { + true +} + +fn widget_register( + state_arc: &Arc>, + module: &str, + args: WidgetRegisterArgs, +) -> std::result::Result { + args.root.validate()?; + let spec = WidgetSpec { + id: format!("{module}.{}", args.id), + module: module.to_string(), + placement: args.placement, + order: args.order, + visible: args.visible, + tooltip: args.tooltip, + root: args.root, + updated_at: now_unix_ms(), + }; + let mut guard = loop { + if let Ok(g) = state_arc.try_write() { + break g; + } + std::hint::spin_loop(); + std::thread::yield_now(); + }; + if let Some(existing) = guard.widgets.iter_mut().find(|w| w.id == spec.id) { + *existing = spec.clone(); + } else { + guard.widgets.push(spec.clone()); + } + Ok(spec) +} + +fn widget_update( + state_arc: &Arc>, + module: &str, + local_id: &str, + args: WidgetUpdateArgs, +) -> std::result::Result, bread_shared::widget::WidgetValidationError> { + if let Some(root) = &args.root { + root.validate()?; + } + let full_id = format!("{module}.{local_id}"); + let mut guard = loop { + if let Ok(g) = state_arc.try_write() { + break g; + } + std::hint::spin_loop(); + std::thread::yield_now(); + }; + let Some(entry) = guard.widgets.iter_mut().find(|w| w.id == full_id) else { + return Ok(None); + }; + if let Some(root) = args.root { + entry.root = root; + } + if let Some(tooltip) = args.tooltip { + entry.tooltip = Some(tooltip); + } + if let Some(visible) = args.visible { + entry.visible = visible; + } + if let Some(order) = args.order { + entry.order = order; + } + entry.updated_at = now_unix_ms(); + Ok(Some(entry.clone())) +} + +fn widget_remove(state_arc: &Arc>, module: &str, local_id: &str) -> bool { + let full_id = format!("{module}.{local_id}"); + let mut guard = loop { + if let Ok(g) = state_arc.try_write() { + break g; + } + std::hint::spin_loop(); + std::thread::yield_now(); + }; + let before = guard.widgets.len(); + guard.widgets.retain(|w| w.id != full_id); + before != guard.widgets.len() +} + +fn widget_list_json(state_arc: &Arc>, module: &str) -> JsonValue { + let guard = loop { + if let Ok(g) = state_arc.try_read() { + break g; + } + std::hint::spin_loop(); + std::thread::yield_now(); + }; + let mine: Vec<&WidgetSpec> = guard.widgets.iter().filter(|w| w.module == module).collect(); + serde_json::to_value(&mine).unwrap_or_else(|_| JsonValue::Array(vec![])) +} + fn order_module_decls(decls: Vec) -> (Vec, Vec<(String, String)>) { let mut errors = Vec::new(); let mut map: HashMap = HashMap::new(); @@ -2129,6 +2926,68 @@ fn is_lib_path(module_root: &Path, path: &Path) -> bool { .unwrap_or(false) } +/// Read the `permissions` declared in the `bread.module.toml` manifest +/// sibling to a third-party module's entry file, if any. +/// +/// `bread-cli`'s `install_from_local` always lays a module out as +/// `//{bread.module.toml,init.lua,...}` (see +/// `bread-cli/src/modules_mgmt.rs`), so the manifest is always the entry +/// file's parent directory + `bread.module.toml`. Returns `None` — meaning +/// "not declared", handled as full ungated backward-compat access by +/// `load_scoped_lua_file` — whenever: the module has no directory-level +/// manifest at all (a hand-authored flat file, e.g. the "Your first +/// module" walkthrough's `modules/hello.lua`); the manifest exists but has +/// no `permissions` key; or the manifest fails to parse (logged, not +/// treated as a load error — a broken manifest shouldn't also break the +/// module load path it's unrelated to). +fn read_module_permissions(module_file: &Path) -> Option> { + #[derive(serde::Deserialize)] + struct PermissionsOnly { + #[serde(default)] + permissions: Option>, + } + + let manifest_path = module_file.parent()?.join("bread.module.toml"); + if !manifest_path.exists() { + return None; + } + let raw = match fs::read_to_string(&manifest_path) { + Ok(raw) => raw, + Err(err) => { + warn!(path = %manifest_path.display(), error = %err, "failed to read bread.module.toml"); + return None; + } + }; + match toml::from_str::(&raw) { + Ok(parsed) => parsed.permissions, + Err(err) => { + warn!(path = %manifest_path.display(), error = %err, "failed to parse bread.module.toml; treating as no permissions declared"); + None + } + } +} + +/// `lua.to_value()`'s default `Options` map JSON null / Rust `Option::None` +/// to a distinct `lua.null()` sentinel rather than real Lua `nil`, to +/// preserve JSON round-trip fidelity — but bread never round-trips a Lua +/// value back into JSON through mlua, so that distinction buys nothing here +/// and only sets a trap for the ordinary Lua idiom `if not value then ...`, +/// which silently doesn't catch the sentinel (found via a module crashing +/// on `#value` when `active_window` was null: `not ` is `false`, +/// same as any other non-nil value). Every JSON/state value handed to Lua +/// goes through this instead of a bare `to_value` call. +fn json_to_lua<'lua, T>(lua: &'lua Lua, value: &T) -> mlua::Result> +where + T: Serialize + ?Sized, +{ + lua.to_value_with( + value, + mlua::SerializeOptions::new() + .serialize_none_to_null(false) + .serialize_unit_to_null(false), + ) +} + fn state_value_to_lua<'lua>( lua: &'lua Lua, state_arc: &Arc>, @@ -2147,9 +3006,7 @@ fn state_value_to_lua<'lua>( let mut value = serde_json::to_value(&*snapshot).map_err(|e| LuaError::external(e.to_string()))?; if path.is_empty() { - return lua - .to_value(&value) - .map_err(|e| LuaError::external(e.to_string())); + return json_to_lua(lua, &value).map_err(|e| LuaError::external(e.to_string())); } for part in path.split('.') { value = value @@ -2157,8 +3014,7 @@ fn state_value_to_lua<'lua>( .cloned() .ok_or_else(|| LuaError::external("state path not found"))?; } - lua.to_value(&value) - .map_err(|e| LuaError::external(e.to_string())) + json_to_lua(lua, &value).map_err(|e| LuaError::external(e.to_string())) } fn module_store_get( @@ -2202,6 +3058,10 @@ fn module_store_set( status: ModuleLoadState::Loaded, last_error: None, builtin: false, + // Placeholder until the real load-time status (with the correct + // ungated value) lands via set_module_status_ex; this fallback only + // fires if a module's own store is written before that happens. + ungated: false, store, }); } @@ -2219,6 +3079,15 @@ fn lua_expand_path(path: &str) -> std::path::PathBuf { std::path::PathBuf::from(path) } +/// POSIX single-quotes `s` for safe embedding as one token in a `sh -c` +/// command line — used for `rules.toml`'s `run = " + + + +
+ + + + + \ No newline at end of file diff --git a/graphify-out/graph.json b/graphify-out/graph.json new file mode 100644 index 0000000..b4e3ae1 --- /dev/null +++ b/graphify-out/graph.json @@ -0,0 +1,56082 @@ +{ + "directed": false, + "multigraph": false, + "graph": { + "hyperedges": [ + { + "name": "event_normalization_flow", + "nodes": [ + "adapter_udev", + "adapter_hyprland", + "adapter_power", + "sys_bread_daemon", + "api_bread_on", + "sys_lua_runtime" + ], + "relation": "implements", + "description": "Event normalization flow: raw signals from adapters \u2192 daemon normalizer \u2192 semantic events \u2192 Lua subscriptions" + }, + { + "name": "module_lifecycle", + "nodes": [ + "config_init_lua", + "config_modules_dir", + "pattern_module_skeleton", + "api_bread_on", + "sys_lua_runtime" + ], + "relation": "orchestrates", + "description": "Module lifecycle: init.lua runs first \u2192 modules/ auto-discovered \u2192 skeleton pattern \u2192 subscriptions registered on_load" + }, + { + "name": "workflow_execution_flow", + "nodes": [ + "api_bread_workflow", + "api_bread_spawn", + "api_bread_wait", + "example_dock_workflow", + "api_bread_notify" + ], + "relation": "enables", + "description": "Workflow execution: define body \u2192 start workflow \u2192 spawn coroutine \u2192 wait for events \u2192 step tracking \u2192 completion" + }, + { + "name": "widget_rendering_flow", + "nodes": [ + "api_bread_widget", + "api_bread_every", + "example_widget_cpu_temp", + "api_bread_state_watch" + ], + "relation": "enables", + "description": "Widget rendering: register widget with typed tree \u2192 update on timer or state change \u2192 breadbar renders live" + } + ] + }, + "nodes": [ + { + "label": "hooks_git.rs", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_cli_src_hooks_git", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "hooks_git.rs" + }, + { + "label": "HookOutcome", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L38", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_hookoutcome", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "hookoutcome" + }, + { + "label": "install_git()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L49", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_install_git", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "install_git()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_rs_result", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "result" + }, + { + "label": "install_one_hook()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L85", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_install_one_hook", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "install_one_hook()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_rs_path", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "path" + }, + { + "label": "is_bread_managed()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L115", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_is_bread_managed", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "is_bread_managed()" + }, + { + "label": "branch_changed_emit_line()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L122", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_branch_changed_emit_line", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "branch_changed_emit_line()" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_rs_string", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "string" + }, + { + "label": "emit_line_for()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L131", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_emit_line_for", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "emit_line_for()" + }, + { + "label": "commit_created_emit_line()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L140", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_commit_created_emit_line", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "commit_created_emit_line()" + }, + { + "label": "hook_script()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L152", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_hook_script", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "hook_script()" + }, + { + "label": "git_dir()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L187", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_git_dir", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "git_dir()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_rs_pathbuf", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "pathbuf" + }, + { + "label": "show_toplevel()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L204", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_show_toplevel", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "show_toplevel()" + }, + { + "label": "hooks_path_override()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L215", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_hooks_path_override", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "hooks_path_override()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_rs_option", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "option" + }, + { + "label": "print_hooks_path_warning()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L235", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_print_hooks_path_warning", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "print_hooks_path_warning()" + }, + { + "label": "print_summary()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L250", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_print_summary", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "print_summary()" + }, + { + "label": "run_git()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L270", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_run_git", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "run_git()" + }, + { + "label": "detects_own_marker()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L288", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_detects_own_marker", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "detects_own_marker()" + }, + { + "label": "does_not_falsely_detect_marker()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L294", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_does_not_falsely_detect_marker", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "does_not_falsely_detect_marker()" + }, + { + "label": "marker_must_match_whole_trimmed_line()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L300", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_marker_must_match_whole_trimmed_line", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "marker_must_match_whole_trimmed_line()" + }, + { + "label": "empty_file_is_not_managed()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L308", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_empty_file_is_not_managed", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "empty_file_is_not_managed()" + }, + { + "label": "all_hook_scripts_start_with_shebang_and_marker()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L313", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_all_hook_scripts_start_with_shebang_and_marker", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "all_hook_scripts_start_with_shebang_and_marker()" + }, + { + "label": "all_hook_scripts_exit_0_unconditionally()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L323", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_all_hook_scripts_exit_0_unconditionally", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "all_hook_scripts_exit_0_unconditionally()" + }, + { + "label": "post_commit_and_post_merge_emit_commit_created()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L334", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_post_commit_and_post_merge_emit_commit_created", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "post_commit_and_post_merge_emit_commit_created()" + }, + { + "label": "post_checkout_only_emits_on_branch_checkout()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L345", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_post_checkout_only_emits_on_branch_checkout", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "post_checkout_only_emits_on_branch_checkout()" + }, + { + "label": "hook_script_rejects_unknown_name()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L353", + "_origin": "ast", + "id": "bread_cli_src_hooks_git_hook_script_rejects_unknown_name", + "community": 12, + "community_name": "hooks_git.rs", + "norm_label": "hook_script_rejects_unknown_name()" + }, + { + "label": "hooks_shell.rs", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "hooks_shell.rs" + }, + { + "label": "TargetShell", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L52", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_targetshell", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "targetshell" + }, + { + "label": ".parse()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L62", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_targetshell_parse", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": ".parse()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_rs_result", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "result" + }, + { + "label": ".detect_from_env()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L78", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_targetshell_detect_from_env", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": ".detect_from_env()" + }, + { + "label": "hooks_dir()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L96", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_hooks_dir", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "hooks_dir()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_rs_pathbuf", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "pathbuf" + }, + { + "label": "install_shell()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L114", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_install_shell", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "install_shell()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_rs_option", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_rs_string", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "string" + }, + { + "label": "write_hook_file()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L164", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_write_hook_file", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "write_hook_file()" + }, + { + "label": "parse_accepts_known_shells()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L431", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_parse_accepts_known_shells", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "parse_accepts_known_shells()" + }, + { + "label": "parse_rejects_unknown_shell()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L438", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_parse_rejects_unknown_shell", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "parse_rejects_unknown_shell()" + }, + { + "label": "detect_from_env_reads_shell_basename()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L444", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_detect_from_env_reads_shell_basename", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "detect_from_env_reads_shell_basename()" + }, + { + "label": "hook_scripts_reference_bread_emit_not_bread_emit_cli()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L462", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_hook_scripts_reference_bread_emit_not_bread_emit_cli", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "hook_scripts_reference_bread_emit_not_bread_emit_cli()" + }, + { + "label": "hook_scripts_background_every_emit_call()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L472", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_hook_scripts_background_every_emit_call", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "hook_scripts_background_every_emit_call()" + }, + { + "label": "join_line_continuations()", + "file_type": "code", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L494", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_join_line_continuations", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "join_line_continuations()" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_hooks_shell_rs_vec", + "community": 18, + "community_name": "hooks_shell.rs", + "norm_label": "vec" + }, + { + "label": "bread-cli/src/lib.rs", + "file_type": "code", + "source_file": "bread-cli/src/lib.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_cli_src_lib", + "community": 55, + "community_name": "bread-cli/src/lib.rs", + "norm_label": "bread-cli/src/lib.rs" + }, + { + "label": "bread-cli/src/main.rs", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_cli_src_main", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "bread-cli/src/main.rs" + }, + { + "label": "Cli", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L24", + "_origin": "ast", + "id": "bread_cli_src_main_cli", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "cli" + }, + { + "label": "Commands", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L30", + "_origin": "ast", + "id": "bread_cli_src_main_commands", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "commands" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_option", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_string", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "string" + }, + { + "label": "HooksCommand", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L105", + "_origin": "ast", + "id": "bread_cli_src_main_hookscommand", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "hookscommand" + }, + { + "label": "ModulesCommand", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L118", + "_origin": "ast", + "id": "bread_cli_src_main_modulescommand", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "modulescommand" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L141", + "_origin": "ast", + "id": "bread_cli_src_main_main", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "main()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_result", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "result" + }, + { + "label": "handle_modules_cmd()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L236", + "_origin": "ast", + "id": "bread_cli_src_main_handle_modules_cmd", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "handle_modules_cmd()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_path", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "path" + }, + { + "label": "install_module()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L371", + "_origin": "ast", + "id": "bread_cli_src_main_install_module", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "install_module()" + }, + { + "label": "try_daemon_reload()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L380", + "_origin": "ast", + "id": "bread_cli_src_main_try_daemon_reload", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "try_daemon_reload()" + }, + { + "label": "daemon_socket_path()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L393", + "_origin": "ast", + "id": "bread_cli_src_main_daemon_socket_path", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "daemon_socket_path()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_pathbuf", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "pathbuf" + }, + { + "label": "send_request()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L400", + "_origin": "ast", + "id": "bread_cli_src_main_send_request", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "send_request()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_value", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "value" + }, + { + "label": "stream_events()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L435", + "_origin": "ast", + "id": "bread_cli_src_main_stream_events", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "stream_events()" + }, + { + "label": "CausalityTracker", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L516", + "_origin": "ast", + "id": "bread_cli_src_main_causalitytracker", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "causalitytracker" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_main_rs_hashmap", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "hashmap" + }, + { + "label": ".depth()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L524", + "_origin": "ast", + "id": "bread_cli_src_main_causalitytracker_depth", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": ".depth()" + }, + { + "label": ".print()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L538", + "_origin": "ast", + "id": "bread_cli_src_main_causalitytracker_print", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": ".print()" + }, + { + "label": "print_json()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L566", + "_origin": "ast", + "id": "bread_cli_src_main_print_json", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "print_json()" + }, + { + "label": "print_state_formatted()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L571", + "_origin": "ast", + "id": "bread_cli_src_main_print_state_formatted", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "print_state_formatted()" + }, + { + "label": "print_value()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L578", + "_origin": "ast", + "id": "bread_cli_src_main_print_value", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "print_value()" + }, + { + "label": "print_event()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L599", + "_origin": "ast", + "id": "bread_cli_src_main_print_event", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "print_event()" + }, + { + "label": "format_timestamp()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L625", + "_origin": "ast", + "id": "bread_cli_src_main_format_timestamp", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "format_timestamp()" + }, + { + "label": "print_reload()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L644", + "_origin": "ast", + "id": "bread_cli_src_main_print_reload", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "print_reload()" + }, + { + "label": "watch_reload()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L661", + "_origin": "ast", + "id": "bread_cli_src_main_watch_reload", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "watch_reload()" + }, + { + "label": "print_doctor()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L686", + "_origin": "ast", + "id": "bread_cli_src_main_print_doctor", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "print_doctor()" + }, + { + "label": "render_doctor()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L702", + "_origin": "ast", + "id": "bread_cli_src_main_render_doctor", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "render_doctor()" + }, + { + "label": "config_directory()", + "file_type": "code", + "source_file": "bread-cli/src/main.rs", + "source_location": "L780", + "_origin": "ast", + "id": "bread_cli_src_main_config_directory", + "community": 13, + "community_name": "bread-cli/src/main.rs", + "norm_label": "config_directory()" + }, + { + "label": "modules_mgmt.rs", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "modules_mgmt.rs" + }, + { + "label": "ModuleManifest", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L10", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_modulemanifest", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "modulemanifest" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_string", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "string" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_option", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "option" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_vec", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "vec" + }, + { + "label": "parse_source()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L35", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_parse_source", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "parse_source()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_result", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "result" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_pathbuf", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "pathbuf" + }, + { + "label": "validate_module_name()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L68", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_validate_module_name", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "validate_module_name()" + }, + { + "label": "resolve_module_dir()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L97", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_resolve_module_dir", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "resolve_module_dir()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_path", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "path" + }, + { + "label": "install_from_local()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L122", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_install_from_local", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "install_from_local()" + }, + { + "label": "remove_module()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L159", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_remove_module", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "remove_module()" + }, + { + "label": "list_modules()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L169", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_list_modules", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "list_modules()" + }, + { + "label": "read_module_manifest()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L191", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_read_module_manifest", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "read_module_manifest()" + }, + { + "label": "read_manifest_file()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L201", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_read_manifest_file", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "read_manifest_file()" + }, + { + "label": "modules_dir()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L208", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_modules_dir", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "modules_dir()" + }, + { + "label": "copy_dir()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L221", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_copy_dir", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "copy_dir()" + }, + { + "label": "audit_module()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L259", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_audit_module", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "audit_module()" + }, + { + "label": "render_permissions_toml()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L274", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_render_permissions_toml", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "render_permissions_toml()" + }, + { + "label": "collect_lua_files()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L283", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_collect_lua_files", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "collect_lua_files()" + }, + { + "label": "scan_lua_source()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L303", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_scan_lua_source", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "scan_lua_source()" + }, + { + "label": "BTreeMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_rs_btreemap", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "btreemap" + }, + { + "label": "classify_call_site()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L321", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_classify_call_site", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "classify_call_site()" + }, + { + "label": "extract_first_string_arg()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L370", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_extract_first_string_arg", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "extract_first_string_arg()" + }, + { + "label": "audit_detects_fs_read_and_widget_from_cpu_temp_widget_style_module()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L386", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_audit_detects_fs_read_and_widget_from_cpu_temp_widget_style_module", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "audit_detects_fs_read_and_widget_from_cpu_temp_widget_style_module()" + }, + { + "label": "audit_extracts_exec_bin_hint_and_ignores_baseline_calls()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L419", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_audit_extracts_exec_bin_hint_and_ignores_baseline_calls", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "audit_extracts_exec_bin_hint_and_ignores_baseline_calls()" + }, + { + "label": "audit_scans_required_sibling_files_in_module_directory()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L443", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_audit_scans_required_sibling_files_in_module_directory", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "audit_scans_required_sibling_files_in_module_directory()" + }, + { + "label": "render_permissions_toml_produces_pastable_block()", + "file_type": "code", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L461", + "_origin": "ast", + "id": "bread_cli_src_modules_mgmt_render_permissions_toml_produces_pastable_block", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "render_permissions_toml_produces_pastable_block()" + }, + { + "label": "modules.rs", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_cli_tests_modules", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "modules.rs" + }, + { + "label": "make_module_dir()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L6", + "_origin": "ast", + "id": "bread_cli_tests_modules_make_module_dir", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "make_module_dir()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_tests_modules_rs_path", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "path" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_cli_tests_modules_rs_pathbuf", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "pathbuf" + }, + { + "label": "install_from_local_succeeds_with_manifest()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L24", + "_origin": "ast", + "id": "bread_cli_tests_modules_install_from_local_succeeds_with_manifest", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "install_from_local_succeeds_with_manifest()" + }, + { + "label": "install_from_local_fails_without_manifest()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L49", + "_origin": "ast", + "id": "bread_cli_tests_modules_install_from_local_fails_without_manifest", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "install_from_local_fails_without_manifest()" + }, + { + "label": "remove_deletes_module_directory()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L67", + "_origin": "ast", + "id": "bread_cli_tests_modules_remove_deletes_module_directory", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "remove_deletes_module_directory()" + }, + { + "label": "remove_nonexistent_errors()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L80", + "_origin": "ast", + "id": "bread_cli_tests_modules_remove_nonexistent_errors", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "remove_nonexistent_errors()" + }, + { + "label": "list_reads_manifests_from_disk()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L92", + "_origin": "ast", + "id": "bread_cli_tests_modules_list_reads_manifests_from_disk", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "list_reads_manifests_from_disk()" + }, + { + "label": "remove_rejects_path_traversal_name()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L107", + "_origin": "ast", + "id": "bread_cli_tests_modules_remove_rejects_path_traversal_name", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "remove_rejects_path_traversal_name()" + }, + { + "label": "remove_rejects_absolute_path_name()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L123", + "_origin": "ast", + "id": "bread_cli_tests_modules_remove_rejects_absolute_path_name", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "remove_rejects_absolute_path_name()" + }, + { + "label": "remove_rejects_name_with_slash()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L130", + "_origin": "ast", + "id": "bread_cli_tests_modules_remove_rejects_name_with_slash", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "remove_rejects_name_with_slash()" + }, + { + "label": "install_rejects_manifest_with_path_traversal_name()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L140", + "_origin": "ast", + "id": "bread_cli_tests_modules_install_rejects_manifest_with_path_traversal_name", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "install_rejects_manifest_with_path_traversal_name()" + }, + { + "label": "manifest_written_correctly_on_install()", + "file_type": "code", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L164", + "_origin": "ast", + "id": "bread_cli_tests_modules_manifest_written_correctly_on_install", + "community": 10, + "community_name": "modules_mgmt.rs", + "norm_label": "manifest_written_correctly_on_install()" + }, + { + "label": "bread-emit/src/main.rs", + "file_type": "code", + "source_file": "bread-emit/src/main.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_emit_src_main", + "community": 30, + "community_name": "TestHarness", + "norm_label": "bread-emit/src/main.rs" + }, + { + "label": "parse_args()", + "file_type": "code", + "source_file": "bread-emit/src/main.rs", + "source_location": "L15", + "_origin": "ast", + "id": "bread_emit_src_main_parse_args", + "community": 30, + "community_name": "TestHarness", + "norm_label": "parse_args()" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_emit_src_main_rs_string", + "community": 30, + "community_name": "TestHarness", + "norm_label": "string" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_emit_src_main_rs_option", + "community": 30, + "community_name": "TestHarness", + "norm_label": "option" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "bread-emit/src/main.rs", + "source_location": "L48", + "_origin": "ast", + "id": "bread_emit_src_main_main", + "community": 30, + "community_name": "TestHarness", + "norm_label": "main()" + }, + { + "label": "io.rs", + "file_type": "code", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_module_host_src_io", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "io.rs" + }, + { + "label": "IoCommand", + "file_type": "code", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L28", + "_origin": "ast", + "id": "bread_module_host_src_io_iocommand", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "iocommand" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_string", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "string" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_value", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "value" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_sender", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_result", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "result" + }, + { + "label": "HostMessage", + "file_type": "code", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L39", + "_origin": "ast", + "id": "bread_module_host_src_io_hostmessage", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "hostmessage" + }, + { + "label": "RpcResponse", + "file_type": "code", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L45", + "_origin": "ast", + "id": "bread_module_host_src_io_rpcresponse", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "rpcresponse" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_option", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "option" + }, + { + "label": "run()", + "file_type": "code", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "_origin": "ast", + "id": "bread_module_host_src_io_run", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "run()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_pathbuf", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "pathbuf" + }, + { + "label": "Receiver", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_receiver", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "receiver" + }, + { + "label": "call()", + "file_type": "code", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "_origin": "ast", + "id": "bread_module_host_src_io_call", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "call()" + }, + { + "label": "Duration", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_io_rs_duration", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "duration" + }, + { + "label": "lua_env.rs", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_module_host_src_lua_env", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "lua_env.rs" + }, + { + "label": "json_to_lua()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L90", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_json_to_lua", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "json_to_lua()" + }, + { + "label": "Lua", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_lua", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "lua" + }, + { + "label": "JsonValue", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_jsonvalue", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "jsonvalue" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_result", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "result" + }, + { + "label": "LuaValue", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "luavalue", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "luavalue" + }, + { + "label": "ModuleHostLua", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L122", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "modulehostlua" + }, + { + "label": "Rc", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "rc", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "rc" + }, + { + "label": "RefCell", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "refcell", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "refcell" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_hashmap", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "hashmap" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_string", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "string" + }, + { + "label": "RegistryKey", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_registrykey", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "registrykey" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_option", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "option" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_new", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".new()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_sender", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "sender" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_vec", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "vec" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_self", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "self" + }, + { + "label": ".install_module_fn()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_module_fn()" + }, + { + "label": "Table", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_table", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "table" + }, + { + "label": ".install_logging()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_logging()" + }, + { + "label": ".install_json()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L241", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_json", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_json()" + }, + { + "label": ".install_events()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_events", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_events()" + }, + { + "label": ".install_timers()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_timers()" + }, + { + "label": ".install_emit()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_emit()" + }, + { + "label": ".install_state()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_state", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_state()" + }, + { + "label": "HashSet", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_hashset", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "hashset" + }, + { + "label": ".install_fs()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_fs()" + }, + { + "label": ".install_exec()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".install_exec()" + }, + { + "label": ".load_entry()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L462", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_load_entry", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".load_entry()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_path", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "path" + }, + { + "label": ".run_on_load()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L477", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_run_on_load", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".run_on_load()" + }, + { + "label": ".dispatch_event()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L495", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_dispatch_event", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".dispatch_event()" + }, + { + "label": ".dispatch_timer()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L504", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_dispatch_timer", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".dispatch_timer()" + }, + { + "label": ".lookup()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L513", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_lookup", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".lookup()" + }, + { + "label": "Function", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_rs_function", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "function" + }, + { + "label": ".call_event_handler()", + "file_type": "code", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L519", + "_origin": "ast", + "id": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": ".call_event_handler()" + }, + { + "label": "bread-module-host/src/main.rs", + "file_type": "code", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_module_host_src_main", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "bread-module-host/src/main.rs" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L48", + "_origin": "ast", + "id": "bread_module_host_src_main_main", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "main()" + }, + { + "label": "report_status()", + "file_type": "code", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L157", + "_origin": "ast", + "id": "bread_module_host_src_main_report_status", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "report_status()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_main_rs_sender", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "sender" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_main_rs_option", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_module_host_src_main_rs_string", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "string" + }, + { + "label": "apps.rs", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_shared_src_apps", + "community": 3, + "community_name": "Server", + "norm_label": "apps.rs" + }, + { + "label": "is_known_app()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L59", + "_origin": "ast", + "id": "bread_shared_src_apps_is_known_app", + "community": 3, + "community_name": "Server", + "norm_label": "is_known_app()" + }, + { + "label": "is_reserved_domain()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L65", + "_origin": "ast", + "id": "bread_shared_src_apps_is_reserved_domain", + "community": 3, + "community_name": "Server", + "norm_label": "is_reserved_domain()" + }, + { + "label": "validate_app_namespace()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L75", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_app_namespace", + "community": 3, + "community_name": "Server", + "norm_label": "validate_app_namespace()" + }, + { + "label": "is_command_event()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L82", + "_origin": "ast", + "id": "bread_shared_src_apps_is_command_event", + "community": 3, + "community_name": "Server", + "norm_label": "is_command_event()" + }, + { + "label": "command_target()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L89", + "_origin": "ast", + "id": "bread_shared_src_apps_command_target", + "community": 3, + "community_name": "Server", + "norm_label": "command_target()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_apps_rs_option", + "community": 3, + "community_name": "Server", + "norm_label": "option" + }, + { + "label": "validate_command_event()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L109", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_command_event", + "community": 3, + "community_name": "Server", + "norm_label": "validate_command_event()" + }, + { + "label": "event_domain()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L125", + "_origin": "ast", + "id": "bread_shared_src_apps_event_domain", + "community": 3, + "community_name": "Server", + "norm_label": "event_domain()" + }, + { + "label": "known_apps_are_recognized()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L134", + "_origin": "ast", + "id": "bread_shared_src_apps_known_apps_are_recognized", + "community": 3, + "community_name": "Server", + "norm_label": "known_apps_are_recognized()" + }, + { + "label": "unknown_app_is_not_recognized()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L140", + "_origin": "ast", + "id": "bread_shared_src_apps_unknown_app_is_not_recognized", + "community": 3, + "community_name": "Server", + "norm_label": "unknown_app_is_not_recognized()" + }, + { + "label": "reserved_domains_are_never_known_apps()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L146", + "_origin": "ast", + "id": "bread_shared_src_apps_reserved_domains_are_never_known_apps", + "community": 3, + "community_name": "Server", + "norm_label": "reserved_domains_are_never_known_apps()" + }, + { + "label": "reserved_domains_are_recognized()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L156", + "_origin": "ast", + "id": "bread_shared_src_apps_reserved_domains_are_recognized", + "community": 3, + "community_name": "Server", + "norm_label": "reserved_domains_are_recognized()" + }, + { + "label": "reserved_domains_cover_every_adapter_owned_event_family()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L163", + "_origin": "ast", + "id": "bread_shared_src_apps_reserved_domains_cover_every_adapter_owned_event_family", + "community": 3, + "community_name": "Server", + "norm_label": "reserved_domains_cover_every_adapter_owned_event_family()" + }, + { + "label": "event_domain_extracts_top_level_segment()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L186", + "_origin": "ast", + "id": "bread_shared_src_apps_event_domain_extracts_top_level_segment", + "community": 3, + "community_name": "Server", + "norm_label": "event_domain_extracts_top_level_segment()" + }, + { + "label": "event_domain_is_none_without_bread_prefix()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L193", + "_origin": "ast", + "id": "bread_shared_src_apps_event_domain_is_none_without_bread_prefix", + "community": 3, + "community_name": "Server", + "norm_label": "event_domain_is_none_without_bread_prefix()" + }, + { + "label": "validate_app_namespace_accepts_own_namespace()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L199", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_app_namespace_accepts_own_namespace", + "community": 3, + "community_name": "Server", + "norm_label": "validate_app_namespace_accepts_own_namespace()" + }, + { + "label": "validate_app_namespace_rejects_other_namespaces()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L208", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_app_namespace_rejects_other_namespaces", + "community": 3, + "community_name": "Server", + "norm_label": "validate_app_namespace_rejects_other_namespaces()" + }, + { + "label": "validate_app_namespace_rejects_bare_prefix_without_trailing_dot()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L215", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_app_namespace_rejects_bare_prefix_without_trailing_dot", + "community": 3, + "community_name": "Server", + "norm_label": "validate_app_namespace_rejects_bare_prefix_without_trailing_dot()" + }, + { + "label": "is_command_event_requires_command_prefix()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L222", + "_origin": "ast", + "id": "bread_shared_src_apps_is_command_event_requires_command_prefix", + "community": 3, + "community_name": "Server", + "norm_label": "is_command_event_requires_command_prefix()" + }, + { + "label": "command_target_extracts_app_id()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L231", + "_origin": "ast", + "id": "bread_shared_src_apps_command_target_extracts_app_id", + "community": 3, + "community_name": "Server", + "norm_label": "command_target_extracts_app_id()" + }, + { + "label": "validate_command_event_accepts_known_app_with_verb()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L240", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_command_event_accepts_known_app_with_verb", + "community": 3, + "community_name": "Server", + "norm_label": "validate_command_event_accepts_known_app_with_verb()" + }, + { + "label": "validate_command_event_rejects_unknown_target_or_missing_verb()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L247", + "_origin": "ast", + "id": "bread_shared_src_apps_validate_command_event_rejects_unknown_target_or_missing_verb", + "community": 3, + "community_name": "Server", + "norm_label": "validate_command_event_rejects_unknown_target_or_missing_verb()" + }, + { + "label": "command_stays_reserved_and_is_not_a_known_app()", + "file_type": "code", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L258", + "_origin": "ast", + "id": "bread_shared_src_apps_command_stays_reserved_and_is_not_a_known_app", + "community": 3, + "community_name": "Server", + "norm_label": "command_stays_reserved_and_is_not_a_known_app()" + }, + { + "label": "glob.rs", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_shared_src_glob", + "community": 21, + "community_name": "glob.rs", + "norm_label": "glob.rs" + }, + { + "label": "matches_pattern()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L16", + "_origin": "ast", + "id": "bread_shared_src_glob_matches_pattern", + "community": 21, + "community_name": "glob.rs", + "norm_label": "matches_pattern()" + }, + { + "label": "matches_glob()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L26", + "_origin": "ast", + "id": "bread_shared_src_glob_matches_glob", + "community": 21, + "community_name": "glob.rs", + "norm_label": "matches_glob()" + }, + { + "label": "exact_match()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L82", + "_origin": "ast", + "id": "bread_shared_src_glob_exact_match", + "community": 21, + "community_name": "glob.rs", + "norm_label": "exact_match()" + }, + { + "label": "single_segment_wildcard()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L94", + "_origin": "ast", + "id": "bread_shared_src_glob_single_segment_wildcard", + "community": 21, + "community_name": "glob.rs", + "norm_label": "single_segment_wildcard()" + }, + { + "label": "recursive_wildcard()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L104", + "_origin": "ast", + "id": "bread_shared_src_glob_recursive_wildcard", + "community": 21, + "community_name": "glob.rs", + "norm_label": "recursive_wildcard()" + }, + { + "label": "single_char_wildcard()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L114", + "_origin": "ast", + "id": "bread_shared_src_glob_single_char_wildcard", + "community": 21, + "community_name": "glob.rs", + "norm_label": "single_char_wildcard()" + }, + { + "label": "star_does_not_cross_dot_segments()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L121", + "_origin": "ast", + "id": "bread_shared_src_glob_star_does_not_cross_dot_segments", + "community": 21, + "community_name": "glob.rs", + "norm_label": "star_does_not_cross_dot_segments()" + }, + { + "label": "double_star_matches_zero_or_more_segments()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L133", + "_origin": "ast", + "id": "bread_shared_src_glob_double_star_matches_zero_or_more_segments", + "community": 21, + "community_name": "glob.rs", + "norm_label": "double_star_matches_zero_or_more_segments()" + }, + { + "label": "empty_pattern_matches_only_empty_text()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L139", + "_origin": "ast", + "id": "bread_shared_src_glob_empty_pattern_matches_only_empty_text", + "community": 21, + "community_name": "glob.rs", + "norm_label": "empty_pattern_matches_only_empty_text()" + }, + { + "label": "empty_text_only_matches_wildcards()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L145", + "_origin": "ast", + "id": "bread_shared_src_glob_empty_text_only_matches_wildcards", + "community": 21, + "community_name": "glob.rs", + "norm_label": "empty_text_only_matches_wildcards()" + }, + { + "label": "dot_double_star_matches_exact_prefix_with_zero_segments()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L151", + "_origin": "ast", + "id": "bread_shared_src_glob_dot_double_star_matches_exact_prefix_with_zero_segments", + "community": 21, + "community_name": "glob.rs", + "norm_label": "dot_double_star_matches_exact_prefix_with_zero_segments()" + }, + { + "label": "dot_double_star_does_not_match_sibling_prefix()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L156", + "_origin": "ast", + "id": "bread_shared_src_glob_dot_double_star_does_not_match_sibling_prefix", + "community": 21, + "community_name": "glob.rs", + "norm_label": "dot_double_star_does_not_match_sibling_prefix()" + }, + { + "label": "mid_pattern_star_does_not_cross_dots()", + "file_type": "code", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L165", + "_origin": "ast", + "id": "bread_shared_src_glob_mid_pattern_star_does_not_cross_dots", + "community": 21, + "community_name": "glob.rs", + "norm_label": "mid_pattern_star_does_not_cross_dots()" + }, + { + "label": "bread-shared/src/lib.rs", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_shared_src_lib", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bread-shared/src/lib.rs" + }, + { + "label": "AdapterSource", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L31", + "_origin": "ast", + "id": "bread_shared_src_lib_adaptersource", + "community": 1, + "community_name": "RawEvent", + "norm_label": "adaptersource" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_lib_rs_string", + "community": 1, + "community_name": "RawEvent", + "norm_label": "string" + }, + { + "label": "RawEvent", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L87", + "_origin": "ast", + "id": "bread_shared_src_lib_rawevent", + "community": 1, + "community_name": "RawEvent", + "norm_label": "rawevent" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_lib_rs_value", + "community": 1, + "community_name": "RawEvent", + "norm_label": "value" + }, + { + "label": "BreadEvent", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L105", + "_origin": "ast", + "id": "bread_shared_src_lib_breadevent", + "community": 1, + "community_name": "RawEvent", + "norm_label": "breadevent" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_lib_rs_option", + "community": 1, + "community_name": "RawEvent", + "norm_label": "option" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "_origin": "ast", + "id": "bread_shared_src_lib_breadevent_new", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".new()" + }, + { + "label": "Into", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "into", + "community": 1, + "community_name": "RawEvent", + "norm_label": "into" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_lib_rs_self", + "community": 1, + "community_name": "RawEvent", + "norm_label": "self" + }, + { + "label": ".with_timestamp()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "_origin": "ast", + "id": "bread_shared_src_lib_breadevent_with_timestamp", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".with_timestamp()" + }, + { + "label": "new_event_id()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L169", + "_origin": "ast", + "id": "bread_shared_src_lib_new_event_id", + "community": 1, + "community_name": "RawEvent", + "norm_label": "new_event_id()" + }, + { + "label": "now_unix_ms()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L177", + "_origin": "ast", + "id": "bread_shared_src_lib_now_unix_ms", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "now_unix_ms()" + }, + { + "label": "DaemonSection", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L185", + "_origin": "ast", + "id": "bread_shared_src_lib_daemonsection", + "community": 1, + "community_name": "RawEvent", + "norm_label": "daemonsection" + }, + { + "label": "SocketPathConfig", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L191", + "_origin": "ast", + "id": "bread_shared_src_lib_socketpathconfig", + "community": 1, + "community_name": "RawEvent", + "norm_label": "socketpathconfig" + }, + { + "label": "resolve_socket_path()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L204", + "_origin": "ast", + "id": "bread_shared_src_lib_resolve_socket_path", + "community": 1, + "community_name": "RawEvent", + "norm_label": "resolve_socket_path()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_lib_rs_pathbuf", + "community": 1, + "community_name": "RawEvent", + "norm_label": "pathbuf" + }, + { + "label": "expand_path()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L227", + "_origin": "ast", + "id": "bread_shared_src_lib_expand_path", + "community": 1, + "community_name": "RawEvent", + "norm_label": "expand_path()" + }, + { + "label": "expand_path_leaves_non_tilde_paths_unchanged()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L248", + "_origin": "ast", + "id": "bread_shared_src_lib_expand_path_leaves_non_tilde_paths_unchanged", + "community": 1, + "community_name": "RawEvent", + "norm_label": "expand_path_leaves_non_tilde_paths_unchanged()" + }, + { + "label": "expand_path_expands_leading_tilde()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L258", + "_origin": "ast", + "id": "bread_shared_src_lib_expand_path_expands_leading_tilde", + "community": 1, + "community_name": "RawEvent", + "norm_label": "expand_path_expands_leading_tilde()" + }, + { + "label": "adapter_source_serializes_as_snake_case()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L270", + "_origin": "ast", + "id": "bread_shared_src_lib_adapter_source_serializes_as_snake_case", + "community": 1, + "community_name": "RawEvent", + "norm_label": "adapter_source_serializes_as_snake_case()" + }, + { + "label": "adapter_source_app_serializes_as_externally_tagged_object()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L326", + "_origin": "ast", + "id": "bread_shared_src_lib_adapter_source_app_serializes_as_externally_tagged_object", + "community": 1, + "community_name": "RawEvent", + "norm_label": "adapter_source_app_serializes_as_externally_tagged_object()" + }, + { + "label": "adapter_source_round_trips_through_json()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L334", + "_origin": "ast", + "id": "bread_shared_src_lib_adapter_source_round_trips_through_json", + "community": 1, + "community_name": "RawEvent", + "norm_label": "adapter_source_round_trips_through_json()" + }, + { + "label": "adapter_source_rejects_unknown_variant()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L358", + "_origin": "ast", + "id": "bread_shared_src_lib_adapter_source_rejects_unknown_variant", + "community": 1, + "community_name": "RawEvent", + "norm_label": "adapter_source_rejects_unknown_variant()" + }, + { + "label": "bread_event_new_sets_current_timestamp()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L364", + "_origin": "ast", + "id": "bread_shared_src_lib_bread_event_new_sets_current_timestamp", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bread_event_new_sets_current_timestamp()" + }, + { + "label": "bread_event_new_accepts_owned_and_borrowed_names()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L376", + "_origin": "ast", + "id": "bread_shared_src_lib_bread_event_new_accepts_owned_and_borrowed_names", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bread_event_new_accepts_owned_and_borrowed_names()" + }, + { + "label": "bread_event_round_trips_through_json()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L384", + "_origin": "ast", + "id": "bread_shared_src_lib_bread_event_round_trips_through_json", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bread_event_round_trips_through_json()" + }, + { + "label": "bread_event_new_assigns_unique_id_and_no_cause()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L405", + "_origin": "ast", + "id": "bread_shared_src_lib_bread_event_new_assigns_unique_id_and_no_cause", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bread_event_new_assigns_unique_id_and_no_cause()" + }, + { + "label": "bread_event_with_timestamp_preserves_timestamp_and_assigns_id()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L414", + "_origin": "ast", + "id": "bread_shared_src_lib_bread_event_with_timestamp_preserves_timestamp_and_assigns_id", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bread_event_with_timestamp_preserves_timestamp_and_assigns_id()" + }, + { + "label": "raw_event_round_trips_through_json()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L427", + "_origin": "ast", + "id": "bread_shared_src_lib_raw_event_round_trips_through_json", + "community": 1, + "community_name": "RawEvent", + "norm_label": "raw_event_round_trips_through_json()" + }, + { + "label": "now_unix_ms_is_monotonically_non_decreasing_across_calls()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L444", + "_origin": "ast", + "id": "bread_shared_src_lib_now_unix_ms_is_monotonically_non_decreasing_across_calls", + "community": 1, + "community_name": "RawEvent", + "norm_label": "now_unix_ms_is_monotonically_non_decreasing_across_calls()" + }, + { + "label": "adapter_source_is_hashable_and_eq()", + "file_type": "code", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L451", + "_origin": "ast", + "id": "bread_shared_src_lib_adapter_source_is_hashable_and_eq", + "community": 1, + "community_name": "RawEvent", + "norm_label": "adapter_source_is_hashable_and_eq()" + }, + { + "label": "module_host_ipc.rs", + "file_type": "code", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc", + "community": 1, + "community_name": "RawEvent", + "norm_label": "module_host_ipc.rs" + }, + { + "label": "ModuleHostHello", + "file_type": "code", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L33", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_modulehosthello", + "community": 1, + "community_name": "RawEvent", + "norm_label": "modulehosthello" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_rs_string", + "community": 1, + "community_name": "RawEvent", + "norm_label": "string" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_rs_vec", + "community": 1, + "community_name": "RawEvent", + "norm_label": "vec" + }, + { + "label": "ModuleHostPush", + "file_type": "code", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L47", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_modulehostpush", + "community": 1, + "community_name": "RawEvent", + "norm_label": "modulehostpush" + }, + { + "label": "hello_round_trips()", + "file_type": "code", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L67", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_hello_round_trips", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hello_round_trips()" + }, + { + "label": "push_event_tag_is_distinguishable_from_a_response_envelope()", + "file_type": "code", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L84", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_push_event_tag_is_distinguishable_from_a_response_envelope", + "community": 1, + "community_name": "RawEvent", + "norm_label": "push_event_tag_is_distinguishable_from_a_response_envelope()" + }, + { + "label": "push_timer_round_trips()", + "file_type": "code", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L97", + "_origin": "ast", + "id": "bread_shared_src_module_host_ipc_push_timer_round_trips", + "community": 1, + "community_name": "RawEvent", + "norm_label": "push_timer_round_trips()" + }, + { + "label": "permissions.rs", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_shared_src_permissions", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "permissions.rs" + }, + { + "label": "ModulePermission", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L31", + "_origin": "ast", + "id": "bread_shared_src_permissions_modulepermission", + "community": 33, + "community_name": ".new", + "norm_label": "modulepermission" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_permissions_rs_option", + "community": 33, + "community_name": ".new", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_permissions_rs_string", + "community": 33, + "community_name": ".new", + "norm_label": "string" + }, + { + "label": "PermissionKind", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L60", + "_origin": "ast", + "id": "bread_shared_src_permissions_permissionkind", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "permissionkind" + }, + { + "label": "permission_round_trips_through_toml_with_dotted_type_names()", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L111", + "_origin": "ast", + "id": "bread_shared_src_permissions_permission_round_trips_through_toml_with_dotted_type_names", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "permission_round_trips_through_toml_with_dotted_type_names()" + }, + { + "label": "exec_permission_with_bin_round_trips()", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L123", + "_origin": "ast", + "id": "bread_shared_src_permissions_exec_permission_with_bin_round_trips", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "exec_permission_with_bin_round_trips()" + }, + { + "label": "permission_list_round_trips_as_array_of_tables()", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L134", + "_origin": "ast", + "id": "bread_shared_src_permissions_permission_list_round_trips_as_array_of_tables", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "permission_list_round_trips_as_array_of_tables()" + }, + { + "label": "missing_permissions_field_deserializes_to_none()", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L165", + "_origin": "ast", + "id": "bread_shared_src_permissions_missing_permissions_field_deserializes_to_none", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "missing_permissions_field_deserializes_to_none()" + }, + { + "label": "explicit_empty_permissions_deserializes_to_some_empty()", + "file_type": "code", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L177", + "_origin": "ast", + "id": "bread_shared_src_permissions_explicit_empty_permissions_deserializes_to_some_empty", + "community": 64, + "community_name": "ModuleHostLua", + "norm_label": "explicit_empty_permissions_deserializes_to_some_empty()" + }, + { + "label": "widget.rs", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L1", + "_origin": "ast", + "id": "bread_shared_src_widget", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widget.rs" + }, + { + "label": "Orientation", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L19", + "_origin": "ast", + "id": "bread_shared_src_widget_orientation", + "community": 4, + "community_name": "widget.rs", + "norm_label": "orientation" + }, + { + "label": "WidgetNode", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L27", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widgetnode" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_option", + "community": 4, + "community_name": "widget.rs", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_string", + "community": 4, + "community_name": "widget.rs", + "norm_label": "string" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_value", + "community": 4, + "community_name": "widget.rs", + "norm_label": "value" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_vec", + "community": 4, + "community_name": "widget.rs", + "norm_label": "vec" + }, + { + "label": "default_orientation()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L76", + "_origin": "ast", + "id": "bread_shared_src_widget_default_orientation", + "community": 4, + "community_name": "widget.rs", + "norm_label": "default_orientation()" + }, + { + "label": "WidgetStyle", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L90", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetstyle", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widgetstyle" + }, + { + "label": "SemanticColor", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L105", + "_origin": "ast", + "id": "bread_shared_src_widget_semanticcolor", + "community": 4, + "community_name": "widget.rs", + "norm_label": "semanticcolor" + }, + { + "label": "FontWeight", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L121", + "_origin": "ast", + "id": "bread_shared_src_widget_fontweight", + "community": 4, + "community_name": "widget.rs", + "norm_label": "fontweight" + }, + { + "label": "TextSize", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L133", + "_origin": "ast", + "id": "bread_shared_src_widget_textsize", + "community": 4, + "community_name": "widget.rs", + "norm_label": "textsize" + }, + { + "label": "Align", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L143", + "_origin": "ast", + "id": "bread_shared_src_widget_align", + "community": 4, + "community_name": "widget.rs", + "norm_label": "align" + }, + { + "label": "Background", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L151", + "_origin": "ast", + "id": "bread_shared_src_widget_background", + "community": 4, + "community_name": "widget.rs", + "norm_label": "background" + }, + { + "label": "Radius", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L161", + "_origin": "ast", + "id": "bread_shared_src_widget_radius", + "community": 4, + "community_name": "widget.rs", + "norm_label": "radius" + }, + { + "label": "Padding", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L171", + "_origin": "ast", + "id": "bread_shared_src_widget_padding", + "community": 4, + "community_name": "widget.rs", + "norm_label": "padding" + }, + { + "label": "WidgetPlacement", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L183", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetplacement", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widgetplacement" + }, + { + "label": "WidgetSpec", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L200", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetspec", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widgetspec" + }, + { + "label": "default_visible()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L218", + "_origin": "ast", + "id": "bread_shared_src_widget_default_visible", + "community": 4, + "community_name": "widget.rs", + "norm_label": "default_visible()" + }, + { + "label": "WidgetValidationError", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L224", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetvalidationerror", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widgetvalidationerror" + }, + { + "label": "Display", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_display", + "community": 4, + "community_name": "widget.rs", + "norm_label": "display" + }, + { + "label": ".fmt()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L231", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetvalidationerror_fmt", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".fmt()" + }, + { + "label": "Formatter", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_formatter", + "community": 4, + "community_name": "widget.rs", + "norm_label": "formatter" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bread_shared_src_widget_rs_result", + "community": 4, + "community_name": "widget.rs", + "norm_label": "result" + }, + { + "label": "Error", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "error", + "community": 4, + "community_name": "widget.rs", + "norm_label": "error" + }, + { + "label": "is_valid_class()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L250", + "_origin": "ast", + "id": "bread_shared_src_widget_is_valid_class", + "community": 4, + "community_name": "widget.rs", + "norm_label": "is_valid_class()" + }, + { + "label": ".class()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L265", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode_class", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".class()" + }, + { + "label": ".style()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L277", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode_style", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".style()" + }, + { + "label": ".on_click()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L289", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode_on_click", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".on_click()" + }, + { + "label": ".children()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L298", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode_children", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".children()" + }, + { + "label": ".validate()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L307", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode_validate", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".validate()" + }, + { + "label": ".validate_inner()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L312", + "_origin": "ast", + "id": "bread_shared_src_widget_widgetnode_validate_inner", + "community": 4, + "community_name": "widget.rs", + "norm_label": ".validate_inner()" + }, + { + "label": "label()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L343", + "_origin": "ast", + "id": "bread_shared_src_widget_label", + "community": 4, + "community_name": "widget.rs", + "norm_label": "label()" + }, + { + "label": "box_of()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L352", + "_origin": "ast", + "id": "bread_shared_src_widget_box_of", + "community": 4, + "community_name": "widget.rs", + "norm_label": "box_of()" + }, + { + "label": "simple_label_is_valid()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L364", + "_origin": "ast", + "id": "bread_shared_src_widget_simple_label_is_valid", + "community": 4, + "community_name": "widget.rs", + "norm_label": "simple_label_is_valid()" + }, + { + "label": "rejects_invalid_class_characters()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L369", + "_origin": "ast", + "id": "bread_shared_src_widget_rejects_invalid_class_characters", + "community": 4, + "community_name": "widget.rs", + "norm_label": "rejects_invalid_class_characters()" + }, + { + "label": "rejects_class_starting_with_digit()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L379", + "_origin": "ast", + "id": "bread_shared_src_widget_rejects_class_starting_with_digit", + "community": 4, + "community_name": "widget.rs", + "norm_label": "rejects_class_starting_with_digit()" + }, + { + "label": "rejects_empty_class()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L384", + "_origin": "ast", + "id": "bread_shared_src_widget_rejects_empty_class", + "community": 4, + "community_name": "widget.rs", + "norm_label": "rejects_empty_class()" + }, + { + "label": "accepts_class_with_underscore_and_hyphen()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L389", + "_origin": "ast", + "id": "bread_shared_src_widget_accepts_class_with_underscore_and_hyphen", + "community": 4, + "community_name": "widget.rs", + "norm_label": "accepts_class_with_underscore_and_hyphen()" + }, + { + "label": "rejects_tree_deeper_than_max()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L394", + "_origin": "ast", + "id": "bread_shared_src_widget_rejects_tree_deeper_than_max", + "community": 4, + "community_name": "widget.rs", + "norm_label": "rejects_tree_deeper_than_max()" + }, + { + "label": "accepts_tree_at_max_depth()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L404", + "_origin": "ast", + "id": "bread_shared_src_widget_accepts_tree_at_max_depth", + "community": 4, + "community_name": "widget.rs", + "norm_label": "accepts_tree_at_max_depth()" + }, + { + "label": "rejects_too_many_nodes()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L411", + "_origin": "ast", + "id": "bread_shared_src_widget_rejects_too_many_nodes", + "community": 4, + "community_name": "widget.rs", + "norm_label": "rejects_too_many_nodes()" + }, + { + "label": "accepts_node_count_at_max()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L421", + "_origin": "ast", + "id": "bread_shared_src_widget_accepts_node_count_at_max", + "community": 4, + "community_name": "widget.rs", + "norm_label": "accepts_node_count_at_max()" + }, + { + "label": "widget_spec_round_trips_through_json()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L428", + "_origin": "ast", + "id": "bread_shared_src_widget_widget_spec_round_trips_through_json", + "community": 4, + "community_name": "widget.rs", + "norm_label": "widget_spec_round_trips_through_json()" + }, + { + "label": "placement_serializes_as_snake_case()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L465", + "_origin": "ast", + "id": "bread_shared_src_widget_placement_serializes_as_snake_case", + "community": 4, + "community_name": "widget.rs", + "norm_label": "placement_serializes_as_snake_case()" + }, + { + "label": "node_serializes_with_type_tag()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L489", + "_origin": "ast", + "id": "bread_shared_src_widget_node_serializes_with_type_tag", + "community": 4, + "community_name": "widget.rs", + "norm_label": "node_serializes_with_type_tag()" + }, + { + "label": "node_without_style_omits_it_when_serialized_and_back()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L497", + "_origin": "ast", + "id": "bread_shared_src_widget_node_without_style_omits_it_when_serialized_and_back", + "community": 4, + "community_name": "widget.rs", + "norm_label": "node_without_style_omits_it_when_serialized_and_back()" + }, + { + "label": "style_field_is_optional_when_absent_from_json()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L506", + "_origin": "ast", + "id": "bread_shared_src_widget_style_field_is_optional_when_absent_from_json", + "community": 4, + "community_name": "widget.rs", + "norm_label": "style_field_is_optional_when_absent_from_json()" + }, + { + "label": "style_round_trips_through_json()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L513", + "_origin": "ast", + "id": "bread_shared_src_widget_style_round_trips_through_json", + "community": 4, + "community_name": "widget.rs", + "norm_label": "style_round_trips_through_json()" + }, + { + "label": "style_enums_serialize_as_snake_case()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L541", + "_origin": "ast", + "id": "bread_shared_src_widget_style_enums_serialize_as_snake_case", + "community": 4, + "community_name": "widget.rs", + "norm_label": "style_enums_serialize_as_snake_case()" + }, + { + "label": "invalid_style_color_fails_to_deserialize()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L551", + "_origin": "ast", + "id": "bread_shared_src_widget_invalid_style_color_fails_to_deserialize", + "community": 4, + "community_name": "widget.rs", + "norm_label": "invalid_style_color_fails_to_deserialize()" + }, + { + "label": "style_with_all_fields_none_is_equivalent_to_default()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L557", + "_origin": "ast", + "id": "bread_shared_src_widget_style_with_all_fields_none_is_equivalent_to_default", + "community": 4, + "community_name": "widget.rs", + "norm_label": "style_with_all_fields_none_is_equivalent_to_default()" + }, + { + "label": "style_does_not_affect_validation()", + "file_type": "code", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L568", + "_origin": "ast", + "id": "bread_shared_src_widget_style_does_not_affect_validation", + "community": 4, + "community_name": "widget.rs", + "norm_label": "style_does_not_affect_validation()" + }, + { + "label": "bluetooth.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "bluetooth.rs" + }, + { + "label": "BluetoothAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L15", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_bluetoothadapter", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "bluetoothadapter" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L18", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_bluetoothadapter_new", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_rs_self", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "self" + }, + { + "label": ".enumerate_existing()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L24", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_bluetoothadapter_enumerate_existing", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": ".enumerate_existing()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_rs_sender", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "sender" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L34", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_bluetoothadapter_name", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L38", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_bluetoothadapter_run", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": ".run()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_rs_result", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "result" + }, + { + "label": "try_enumerate()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L63", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_try_enumerate", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "try_enumerate()" + }, + { + "label": "parse_bluetooth_message()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L123", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "parse_bluetooth_message()" + }, + { + "label": "Message", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_rs_message", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "message" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_rs_option", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "option" + }, + { + "label": "address_from_path()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L226", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_address_from_path", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "address_from_path()" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_rs_string", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "string" + }, + { + "label": "address_from_path_parses_standard_bluez_path()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L239", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_address_from_path_parses_standard_bluez_path", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "address_from_path_parses_standard_bluez_path()" + }, + { + "label": "address_from_path_returns_empty_for_adapter_path()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L247", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_address_from_path_returns_empty_for_adapter_path", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "address_from_path_returns_empty_for_adapter_path()" + }, + { + "label": "address_from_path_returns_empty_for_root()", + "file_type": "code", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L252", + "_origin": "ast", + "id": "breadd_src_adapters_bluetooth_address_from_path_returns_empty_for_root", + "community": 19, + "community_name": "bluetooth.rs", + "norm_label": "address_from_path_returns_empty_for_root()" + }, + { + "label": "filesystem.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "filesystem.rs" + }, + { + "label": "FilesystemAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L34", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_filesystemadapter", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "filesystemadapter" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_vec", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "vec" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_string", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "string" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L40", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_filesystemadapter_new", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_self", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "self" + }, + { + "label": ".resolve_roots()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L47", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": ".resolve_roots()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_pathbuf", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "pathbuf" + }, + { + "label": ".enumerate_existing()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L60", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": ".enumerate_existing()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_sender", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "sender" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L92", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_filesystemadapter_name", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L96", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_filesystemadapter_run", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": ".run()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_result", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "result" + }, + { + "label": "run_watch()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_run_watch", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "run_watch()" + }, + { + "label": "classify()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_path", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "path" + }, + { + "label": "EventKind", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "eventkind", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "eventkind" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_hashmap", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "hashmap" + }, + { + "label": "Instant", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_instant", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "instant" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_rs_option", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "option" + }, + { + "label": "excluded_dir_component()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L235", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_excluded_dir_component", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "excluded_dir_component()" + }, + { + "label": "detect_markers()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L249", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_detect_markers", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "detect_markers()" + }, + { + "label": "expand_glob()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L261", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_expand_glob", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "expand_glob()" + }, + { + "label": "excluded_dir_component_finds_git_at_top_level()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L300", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_excluded_dir_component_finds_git_at_top_level", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "excluded_dir_component_finds_git_at_top_level()" + }, + { + "label": "excluded_dir_component_finds_target_nested_deeply()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L305", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_excluded_dir_component_finds_target_nested_deeply", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "excluded_dir_component_finds_target_nested_deeply()" + }, + { + "label": "excluded_dir_component_finds_node_modules()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L313", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_excluded_dir_component_finds_node_modules", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "excluded_dir_component_finds_node_modules()" + }, + { + "label": "excluded_dir_component_none_for_ordinary_source_file()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L321", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_excluded_dir_component_none_for_ordinary_source_file", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "excluded_dir_component_none_for_ordinary_source_file()" + }, + { + "label": "classify_silent_under_git()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L326", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify_silent_under_git", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify_silent_under_git()" + }, + { + "label": "classify_silent_under_node_modules()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L340", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify_silent_under_node_modules", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify_silent_under_node_modules()" + }, + { + "label": "classify_build_artifact_created_in_target()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L354", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify_build_artifact_created_in_target", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify_build_artifact_created_in_target()" + }, + { + "label": "classify_silent_for_modify_in_target_not_create()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L371", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify_silent_for_modify_in_target_not_create", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify_silent_for_modify_in_target_not_create()" + }, + { + "label": "classify_file_changed_for_ordinary_source_file()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L387", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify_file_changed_for_ordinary_source_file", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify_file_changed_for_ordinary_source_file()" + }, + { + "label": "classify_debounces_rapid_repeat_events_for_same_path()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L404", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_classify_debounces_rapid_repeat_events_for_same_path", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "classify_debounces_rapid_repeat_events_for_same_path()" + }, + { + "label": "detect_markers_finds_cargo_toml()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L418", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_detect_markers_finds_cargo_toml", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "detect_markers_finds_cargo_toml()" + }, + { + "label": "detect_markers_finds_multiple()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L426", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_detect_markers_finds_multiple", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "detect_markers_finds_multiple()" + }, + { + "label": "detect_markers_empty_for_plain_directory()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L438", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_detect_markers_empty_for_plain_directory", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "detect_markers_empty_for_plain_directory()" + }, + { + "label": "expand_glob_returns_single_path_unchanged_without_star()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L444", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_expand_glob_returns_single_path_unchanged_without_star", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "expand_glob_returns_single_path_unchanged_without_star()" + }, + { + "label": "expand_glob_expands_star_to_subdirectories()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L450", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_expand_glob_expands_star_to_subdirectories", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "expand_glob_expands_star_to_subdirectories()" + }, + { + "label": "expand_glob_returns_empty_for_nonexistent_parent()", + "file_type": "code", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L466", + "_origin": "ast", + "id": "breadd_src_adapters_filesystem_expand_glob_returns_empty_for_nonexistent_parent", + "community": 6, + "community_name": "filesystem.rs", + "norm_label": "expand_glob_returns_empty_for_nonexistent_parent()" + }, + { + "label": "git.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_git", + "community": 7, + "community_name": "git.rs", + "norm_label": "git.rs" + }, + { + "label": "GitAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L65", + "_origin": "ast", + "id": "breadd_src_adapters_git_gitadapter", + "community": 7, + "community_name": "git.rs", + "norm_label": "gitadapter" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_vec", + "community": 7, + "community_name": "git.rs", + "norm_label": "vec" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_string", + "community": 7, + "community_name": "git.rs", + "norm_label": "string" + }, + { + "label": "Duration", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_duration", + "community": 7, + "community_name": "git.rs", + "norm_label": "duration" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L72", + "_origin": "ast", + "id": "breadd_src_adapters_git_gitadapter_new", + "community": 7, + "community_name": "git.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_self", + "community": 7, + "community_name": "git.rs", + "norm_label": "self" + }, + { + "label": ".with_interval()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L82", + "_origin": "ast", + "id": "breadd_src_adapters_git_gitadapter_with_interval", + "community": 7, + "community_name": "git.rs", + "norm_label": ".with_interval()" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L92", + "_origin": "ast", + "id": "breadd_src_adapters_git_gitadapter_name", + "community": 7, + "community_name": "git.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L96", + "_origin": "ast", + "id": "breadd_src_adapters_git_gitadapter_run", + "community": 7, + "community_name": "git.rs", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_sender", + "community": 7, + "community_name": "git.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_result", + "community": 7, + "community_name": "git.rs", + "norm_label": "result" + }, + { + "label": "RepoTrack", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L202", + "_origin": "ast", + "id": "breadd_src_adapters_git_repotrack", + "community": 7, + "community_name": "git.rs", + "norm_label": "repotrack" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_pathbuf", + "community": 7, + "community_name": "git.rs", + "norm_label": "pathbuf" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_option", + "community": 7, + "community_name": "git.rs", + "norm_label": "option" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L211", + "_origin": "ast", + "id": "breadd_src_adapters_git_repotrack_new", + "community": 7, + "community_name": "git.rs", + "norm_label": ".new()" + }, + { + "label": "discover_repos()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L225", + "_origin": "ast", + "id": "breadd_src_adapters_git_discover_repos", + "community": 7, + "community_name": "git.rs", + "norm_label": "discover_repos()" + }, + { + "label": "expand_roots()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L243", + "_origin": "ast", + "id": "breadd_src_adapters_git_expand_roots", + "community": 7, + "community_name": "git.rs", + "norm_label": "expand_roots()" + }, + { + "label": "resolve_git_dir()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L278", + "_origin": "ast", + "id": "breadd_src_adapters_git_resolve_git_dir", + "community": 7, + "community_name": "git.rs", + "norm_label": "resolve_git_dir()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_git_rs_path", + "community": 7, + "community_name": "git.rs", + "norm_label": "path" + }, + { + "label": "parse_gitdir_file()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L304", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_gitdir_file", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_gitdir_file()" + }, + { + "label": "check_dirty()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L313", + "_origin": "ast", + "id": "breadd_src_adapters_git_check_dirty", + "community": 7, + "community_name": "git.rs", + "norm_label": "check_dirty()" + }, + { + "label": "check_ahead_behind()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L339", + "_origin": "ast", + "id": "breadd_src_adapters_git_check_ahead_behind", + "community": 7, + "community_name": "git.rs", + "norm_label": "check_ahead_behind()" + }, + { + "label": "parse_ahead_behind()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L384", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_ahead_behind", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_ahead_behind()" + }, + { + "label": "parse_ahead_behind_parses_tab_separated_counts()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L398", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_ahead_behind_parses_tab_separated_counts", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_ahead_behind_parses_tab_separated_counts()" + }, + { + "label": "parse_ahead_behind_parses_space_separated_counts()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L403", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_ahead_behind_parses_space_separated_counts", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_ahead_behind_parses_space_separated_counts()" + }, + { + "label": "parse_ahead_behind_handles_zero_zero()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L408", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_ahead_behind_handles_zero_zero", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_ahead_behind_handles_zero_zero()" + }, + { + "label": "parse_ahead_behind_rejects_malformed_output()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L413", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_ahead_behind_rejects_malformed_output", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_ahead_behind_rejects_malformed_output()" + }, + { + "label": "parse_gitdir_file_extracts_path()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L422", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_gitdir_file_extracts_path", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_gitdir_file_extracts_path()" + }, + { + "label": "parse_gitdir_file_trims_whitespace()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L430", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_gitdir_file_trims_whitespace", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_gitdir_file_trims_whitespace()" + }, + { + "label": "parse_gitdir_file_rejects_unrecognized_content()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L438", + "_origin": "ast", + "id": "breadd_src_adapters_git_parse_gitdir_file_rejects_unrecognized_content", + "community": 7, + "community_name": "git.rs", + "norm_label": "parse_gitdir_file_rejects_unrecognized_content()" + }, + { + "label": "expand_roots_uses_literal_path_without_trailing_star()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L446", + "_origin": "ast", + "id": "breadd_src_adapters_git_expand_roots_uses_literal_path_without_trailing_star", + "community": 7, + "community_name": "git.rs", + "norm_label": "expand_roots_uses_literal_path_without_trailing_star()" + }, + { + "label": "expand_roots_globs_single_trailing_star()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L458", + "_origin": "ast", + "id": "breadd_src_adapters_git_expand_roots_globs_single_trailing_star", + "community": 7, + "community_name": "git.rs", + "norm_label": "expand_roots_globs_single_trailing_star()" + }, + { + "label": "expand_roots_skips_unreadable_glob_parent_without_panicking()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L477", + "_origin": "ast", + "id": "breadd_src_adapters_git_expand_roots_skips_unreadable_glob_parent_without_panicking", + "community": 7, + "community_name": "git.rs", + "norm_label": "expand_roots_skips_unreadable_glob_parent_without_panicking()" + }, + { + "label": "resolve_git_dir_finds_standard_directory_git()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L486", + "_origin": "ast", + "id": "breadd_src_adapters_git_resolve_git_dir_finds_standard_directory_git", + "community": 7, + "community_name": "git.rs", + "norm_label": "resolve_git_dir_finds_standard_directory_git()" + }, + { + "label": "resolve_git_dir_resolves_worktree_style_git_file()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L496", + "_origin": "ast", + "id": "breadd_src_adapters_git_resolve_git_dir_resolves_worktree_style_git_file", + "community": 7, + "community_name": "git.rs", + "norm_label": "resolve_git_dir_resolves_worktree_style_git_file()" + }, + { + "label": "resolve_git_dir_returns_none_for_non_repo()", + "file_type": "code", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L517", + "_origin": "ast", + "id": "breadd_src_adapters_git_resolve_git_dir_returns_none_for_non_repo", + "community": 7, + "community_name": "git.rs", + "norm_label": "resolve_git_dir_returns_none_for_non_repo()" + }, + { + "label": "hyprland.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "hyprland.rs" + }, + { + "label": "HyprlandAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L15", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_hyprlandadapter", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "hyprlandadapter" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L19", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_hyprlandadapter_name", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L23", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_rs_sender", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_rs_result", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "result" + }, + { + "label": "hyprland_event_socket()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L57", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_hyprland_event_socket", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "hyprland_event_socket()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_rs_pathbuf", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "pathbuf" + }, + { + "label": "hyprland_request_socket()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L94", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_hyprland_request_socket", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "hyprland_request_socket()" + }, + { + "label": "hyprland_request_json()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L102", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_hyprland_request_json", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "hyprland_request_json()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_rs_value", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "value" + }, + { + "label": "emit_topology_snapshot()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L116", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "emit_topology_snapshot()" + }, + { + "label": "parse_hyprland_line()", + "file_type": "code", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L140", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_parse_hyprland_line", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "parse_hyprland_line()" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_hyprland_rs_string", + "community": 26, + "community_name": "hyprland.rs", + "norm_label": "string" + }, + { + "label": "adapters/mod.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_mod", + "community": 3, + "community_name": "Server", + "norm_label": "adapters/mod.rs" + }, + { + "label": "AdapterStatus", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L27", + "_origin": "ast", + "id": "breadd_src_adapters_mod_adapterstatus", + "community": 3, + "community_name": "Server", + "norm_label": "adapterstatus" + }, + { + "label": "Adapter", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L33", + "_origin": "ast", + "id": "breadd_src_adapters_mod_adapter", + "community": 23, + "community_name": "Adapter", + "norm_label": "adapter" + }, + { + "label": "Send", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "send", + "community": 23, + "community_name": "Adapter", + "norm_label": "send" + }, + { + "label": "Sync", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "sync", + "community": 31, + "community_name": "Sync", + "norm_label": "sync" + }, + { + "label": "Manager", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L44", + "_origin": "ast", + "id": "breadd_src_adapters_mod_manager", + "community": 3, + "community_name": "Server", + "norm_label": "manager" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_sender", + "community": 3, + "community_name": "Server", + "norm_label": "sender" + }, + { + "label": "Receiver", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_receiver", + "community": 3, + "community_name": "Server", + "norm_label": "receiver" + }, + { + "label": "Arc", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_arc", + "community": 3, + "community_name": "Server", + "norm_label": "arc" + }, + { + "label": "RwLock", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_rwlock", + "community": 3, + "community_name": "Server", + "norm_label": "rwlock" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_hashmap", + "community": 3, + "community_name": "Server", + "norm_label": "hashmap" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_string", + "community": 3, + "community_name": "Server", + "norm_label": "string" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "_origin": "ast", + "id": "breadd_src_adapters_mod_manager_new", + "community": 3, + "community_name": "Server", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_self", + "community": 3, + "community_name": "Server", + "norm_label": "self" + }, + { + "label": ".status_handle()", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "_origin": "ast", + "id": "breadd_src_adapters_mod_manager_status_handle", + "community": 3, + "community_name": "Server", + "norm_label": ".status_handle()" + }, + { + "label": ".start_all()", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L69", + "_origin": "ast", + "id": "breadd_src_adapters_mod_manager_start_all", + "community": 3, + "community_name": "Server", + "norm_label": ".start_all()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_mod_rs_result", + "community": 3, + "community_name": "Server", + "norm_label": "result" + }, + { + "label": ".spawn_adapter()", + "file_type": "code", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L140", + "_origin": "ast", + "id": "breadd_src_adapters_mod_manager_spawn_adapter", + "community": 3, + "community_name": "Server", + "norm_label": ".spawn_adapter()" + }, + { + "label": "A", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "a", + "community": 3, + "community_name": "Server", + "norm_label": "a" + }, + { + "label": "network.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_network", + "community": 24, + "community_name": "network.rs", + "norm_label": "network.rs" + }, + { + "label": "NetworkAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L14", + "_origin": "ast", + "id": "breadd_src_adapters_network_networkadapter", + "community": 24, + "community_name": "network.rs", + "norm_label": "networkadapter" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L18", + "_origin": "ast", + "id": "breadd_src_adapters_network_networkadapter_name", + "community": 24, + "community_name": "network.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L22", + "_origin": "ast", + "id": "breadd_src_adapters_network_networkadapter_run", + "community": 24, + "community_name": "network.rs", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rs_sender", + "community": 24, + "community_name": "network.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rs_result", + "community": 24, + "community_name": "network.rs", + "norm_label": "result" + }, + { + "label": "NetworkSnapshot", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L39", + "_origin": "ast", + "id": "breadd_src_adapters_network_networksnapshot", + "community": 24, + "community_name": "network.rs", + "norm_label": "networksnapshot" + }, + { + "label": "BTreeMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rs_btreemap", + "community": 24, + "community_name": "network.rs", + "norm_label": "btreemap" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rs_string", + "community": 24, + "community_name": "network.rs", + "norm_label": "string" + }, + { + "label": "network_raw_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L44", + "_origin": "ast", + "id": "breadd_src_adapters_network_network_raw_event", + "community": 24, + "community_name": "network.rs", + "norm_label": "network_raw_event()" + }, + { + "label": "read_network_state()", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L62", + "_origin": "ast", + "id": "breadd_src_adapters_network_read_network_state", + "community": 24, + "community_name": "network.rs", + "norm_label": "read_network_state()" + }, + { + "label": "has_default_route()", + "file_type": "code", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L82", + "_origin": "ast", + "id": "breadd_src_adapters_network_has_default_route", + "community": 24, + "community_name": "network.rs", + "norm_label": "has_default_route()" + }, + { + "label": "network_rtnetlink.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink", + "community": 23, + "community_name": "Adapter", + "norm_label": "network_rtnetlink.rs" + }, + { + "label": "RtnetlinkAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L15", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter", + "community": 23, + "community_name": "Adapter", + "norm_label": "rtnetlinkadapter" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L18", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_new", + "community": 23, + "community_name": "Adapter", + "norm_label": ".new()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rs_result", + "community": 23, + "community_name": "Adapter", + "norm_label": "result" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rs_self", + "community": 23, + "community_name": "Adapter", + "norm_label": "self" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L27", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_name", + "community": 23, + "community_name": "Adapter", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L31", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_run", + "community": 23, + "community_name": "Adapter", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rs_sender", + "community": 23, + "community_name": "Adapter", + "norm_label": "sender" + }, + { + "label": "ip_from_bytes()", + "file_type": "code", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L179", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_ip_from_bytes", + "community": 23, + "community_name": "Adapter", + "norm_label": "ip_from_bytes()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rs_option", + "community": 23, + "community_name": "Adapter", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_network_rtnetlink_rs_string", + "community": 23, + "community_name": "Adapter", + "norm_label": "string" + }, + { + "label": "podman.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_podman", + "community": 15, + "community_name": "podman.rs", + "norm_label": "podman.rs" + }, + { + "label": "PodmanAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L21", + "_origin": "ast", + "id": "breadd_src_adapters_podman_podmanadapter", + "community": 15, + "community_name": "podman.rs", + "norm_label": "podmanadapter" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L24", + "_origin": "ast", + "id": "breadd_src_adapters_podman_podmanadapter_new", + "community": 15, + "community_name": "podman.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_self", + "community": 15, + "community_name": "podman.rs", + "norm_label": "self" + }, + { + "label": "Default", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_default", + "community": 15, + "community_name": "podman.rs", + "norm_label": "default" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L30", + "_origin": "ast", + "id": "breadd_src_adapters_podman_podmanadapter_default", + "community": 15, + "community_name": "podman.rs", + "norm_label": ".default()" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L37", + "_origin": "ast", + "id": "breadd_src_adapters_podman_podmanadapter_name", + "community": 15, + "community_name": "podman.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L41", + "_origin": "ast", + "id": "breadd_src_adapters_podman_podmanadapter_run", + "community": 15, + "community_name": "podman.rs", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_sender", + "community": 15, + "community_name": "podman.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_result", + "community": 15, + "community_name": "podman.rs", + "norm_label": "result" + }, + { + "label": "map_podman_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L140", + "_origin": "ast", + "id": "breadd_src_adapters_podman_map_podman_event", + "community": 15, + "community_name": "podman.rs", + "norm_label": "map_podman_event()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_value", + "community": 15, + "community_name": "podman.rs", + "norm_label": "value" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_option", + "community": 15, + "community_name": "podman.rs", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_podman_rs_string", + "community": 15, + "community_name": "podman.rs", + "norm_label": "string" + }, + { + "label": "container_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L209", + "_origin": "ast", + "id": "breadd_src_adapters_podman_container_event", + "community": 15, + "community_name": "podman.rs", + "norm_label": "container_event()" + }, + { + "label": "maps_start_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L235", + "_origin": "ast", + "id": "breadd_src_adapters_podman_maps_start_event", + "community": 15, + "community_name": "podman.rs", + "norm_label": "maps_start_event()" + }, + { + "label": "maps_died_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L245", + "_origin": "ast", + "id": "breadd_src_adapters_podman_maps_died_event", + "community": 15, + "community_name": "podman.rs", + "norm_label": "maps_died_event()" + }, + { + "label": "ignores_stop_event_to_avoid_double_emit_with_died()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L254", + "_origin": "ast", + "id": "breadd_src_adapters_podman_ignores_stop_event_to_avoid_double_emit_with_died", + "community": 15, + "community_name": "podman.rs", + "norm_label": "ignores_stop_event_to_avoid_double_emit_with_died()" + }, + { + "label": "ignores_remove_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L260", + "_origin": "ast", + "id": "breadd_src_adapters_podman_ignores_remove_event", + "community": 15, + "community_name": "podman.rs", + "norm_label": "ignores_remove_event()" + }, + { + "label": "maps_health_status_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L266", + "_origin": "ast", + "id": "breadd_src_adapters_podman_maps_health_status_event", + "community": 15, + "community_name": "podman.rs", + "norm_label": "maps_health_status_event()" + }, + { + "label": "ignores_unknown_action()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L276", + "_origin": "ast", + "id": "breadd_src_adapters_podman_ignores_unknown_action", + "community": 15, + "community_name": "podman.rs", + "norm_label": "ignores_unknown_action()" + }, + { + "label": "ignores_non_container_type()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L282", + "_origin": "ast", + "id": "breadd_src_adapters_podman_ignores_non_container_type", + "community": 15, + "community_name": "podman.rs", + "norm_label": "ignores_non_container_type()" + }, + { + "label": "missing_fields_fall_back_to_unknown()", + "file_type": "code", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L292", + "_origin": "ast", + "id": "breadd_src_adapters_podman_missing_fields_fall_back_to_unknown", + "community": 15, + "community_name": "podman.rs", + "norm_label": "missing_fields_fall_back_to_unknown()" + }, + { + "label": "power.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_power", + "community": 25, + "community_name": "power.rs", + "norm_label": "power.rs" + }, + { + "label": "PowerAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L14", + "_origin": "ast", + "id": "breadd_src_adapters_power_poweradapter", + "community": 25, + "community_name": "power.rs", + "norm_label": "poweradapter" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L19", + "_origin": "ast", + "id": "breadd_src_adapters_power_poweradapter_new", + "community": 25, + "community_name": "power.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_rs_self", + "community": 25, + "community_name": "power.rs", + "norm_label": "self" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L26", + "_origin": "ast", + "id": "breadd_src_adapters_power_poweradapter_name", + "community": 25, + "community_name": "power.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L30", + "_origin": "ast", + "id": "breadd_src_adapters_power_poweradapter_run", + "community": 25, + "community_name": "power.rs", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_rs_sender", + "community": 25, + "community_name": "power.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_rs_result", + "community": 25, + "community_name": "power.rs", + "norm_label": "result" + }, + { + "label": "PowerSnapshot", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L48", + "_origin": "ast", + "id": "breadd_src_adapters_power_powersnapshot", + "community": 25, + "community_name": "power.rs", + "norm_label": "powersnapshot" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_rs_option", + "community": 25, + "community_name": "power.rs", + "norm_label": "option" + }, + { + "label": "power_raw_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L53", + "_origin": "ast", + "id": "breadd_src_adapters_power_power_raw_event", + "community": 25, + "community_name": "power.rs", + "norm_label": "power_raw_event()" + }, + { + "label": "read_power_state()", + "file_type": "code", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L65", + "_origin": "ast", + "id": "breadd_src_adapters_power_read_power_state", + "community": 25, + "community_name": "power.rs", + "norm_label": "read_power_state()" + }, + { + "label": "power_upower.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "power_upower.rs" + }, + { + "label": "UPowerAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L15", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_upoweradapter", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "upoweradapter" + }, + { + "label": ".probe()", + "file_type": "code", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L19", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_upoweradapter_probe", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": ".probe()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_rs_result", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "result" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_rs_self", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "self" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L29", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_upoweradapter_name", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L33", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_upoweradapter_run", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_rs_sender", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "sender" + }, + { + "label": "parse_upower_message()", + "file_type": "code", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L76", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_parse_upower_message", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "parse_upower_message()" + }, + { + "label": "Message", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_power_upower_rs_message", + "community": 27, + "community_name": "parse_upower_message", + "norm_label": "message" + }, + { + "label": "systemd.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_systemd", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "systemd.rs" + }, + { + "label": "SystemdAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L27", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_systemdadapter", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "systemdadapter" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_vec", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "vec" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_string", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "string" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L32", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_systemdadapter_new", + "community": 11, + "community_name": "systemd.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_self", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "self" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L39", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_systemdadapter_name", + "community": 11, + "community_name": "systemd.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L43", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_systemdadapter_run", + "community": 11, + "community_name": "systemd.rs", + "norm_label": ".run()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_sender", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_result", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "result" + }, + { + "label": "get_unit_path()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L103", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_get_unit_path", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "get_unit_path()" + }, + { + "label": "Connection", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_connection", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "connection" + }, + { + "label": "query_active_state()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L119", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_query_active_state", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "query_active_state()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_option", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "option" + }, + { + "label": "handle_message()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_handle_message", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "handle_message()" + }, + { + "label": "Message", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_message", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "message" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_hashmap", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "hashmap" + }, + { + "label": "active_state_to_kind()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L206", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_active_state_to_kind", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "active_state_to_kind()" + }, + { + "label": "is_failed_transition()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L216", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_is_failed_transition", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "is_failed_transition()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_rs_value", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "value" + }, + { + "label": "failure_result()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L226", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_failure_result", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "failure_result()" + }, + { + "label": "active_state_to_kind_maps_active_to_started()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L238", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_active_state_to_kind_maps_active_to_started", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "active_state_to_kind_maps_active_to_started()" + }, + { + "label": "active_state_to_kind_maps_inactive_and_dead_to_stopped()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L243", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_active_state_to_kind_maps_inactive_and_dead_to_stopped", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "active_state_to_kind_maps_inactive_and_dead_to_stopped()" + }, + { + "label": "active_state_to_kind_excludes_failed()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L249", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_active_state_to_kind_excludes_failed", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "active_state_to_kind_excludes_failed()" + }, + { + "label": "active_state_to_kind_ignores_transitional_states()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L256", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_active_state_to_kind_ignores_transitional_states", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "active_state_to_kind_ignores_transitional_states()" + }, + { + "label": "is_failed_transition_detects_failed_active_state()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L263", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_is_failed_transition_detects_failed_active_state", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "is_failed_transition_detects_failed_active_state()" + }, + { + "label": "is_failed_transition_ignores_other_active_states()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L269", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_is_failed_transition_ignores_other_active_states", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "is_failed_transition_ignores_other_active_states()" + }, + { + "label": "is_failed_transition_ignores_unrelated_property_changes()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L275", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_is_failed_transition_ignores_unrelated_property_changes", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "is_failed_transition_ignores_unrelated_property_changes()" + }, + { + "label": "failure_result_extracts_reason_when_present()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L283", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_failure_result_extracts_reason_when_present", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "failure_result_extracts_reason_when_present()" + }, + { + "label": "failure_result_is_none_when_absent()", + "file_type": "code", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L289", + "_origin": "ast", + "id": "breadd_src_adapters_systemd_failure_result_is_none_when_absent", + "community": 11, + "community_name": "systemd.rs", + "norm_label": "failure_result_is_none_when_absent()" + }, + { + "label": "udev.rs", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_adapters_udev", + "community": 71, + "community_name": "udev.rs", + "norm_label": "udev.rs" + }, + { + "label": "UdevAdapter", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L12", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevadapter", + "community": 71, + "community_name": "udev.rs", + "norm_label": "udevadapter" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_vec", + "community": 71, + "community_name": "udev.rs", + "norm_label": "vec" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_string", + "community": 71, + "community_name": "udev.rs", + "norm_label": "string" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L17", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevadapter_new", + "community": 71, + "community_name": "udev.rs", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_self", + "community": 71, + "community_name": "udev.rs", + "norm_label": "self" + }, + { + "label": ".enumerate_existing()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L21", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "community": 71, + "community_name": "udev.rs", + "norm_label": ".enumerate_existing()" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_sender", + "community": 71, + "community_name": "udev.rs", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_result", + "community": 71, + "community_name": "udev.rs", + "norm_label": "result" + }, + { + "label": ".name()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L36", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevadapter_name", + "community": 71, + "community_name": "udev.rs", + "norm_label": ".name()" + }, + { + "label": ".run()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L40", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevadapter_run", + "community": 71, + "community_name": "udev.rs", + "norm_label": ".run()" + }, + { + "label": "run_udev_monitor()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "_origin": "ast", + "id": "breadd_src_adapters_udev_run_udev_monitor", + "community": 71, + "community_name": "udev.rs", + "norm_label": "run_udev_monitor()" + }, + { + "label": "build_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L95", + "_origin": "ast", + "id": "breadd_src_adapters_udev_build_event", + "community": 71, + "community_name": "udev.rs", + "norm_label": "build_event()" + }, + { + "label": "Event", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "event", + "community": 71, + "community_name": "udev.rs", + "norm_label": "event" + }, + { + "label": "build_device_event()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L107", + "_origin": "ast", + "id": "breadd_src_adapters_udev_build_device_event", + "community": 71, + "community_name": "udev.rs", + "norm_label": "build_device_event()" + }, + { + "label": "UdevClassification", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L137", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevclassification", + "community": 71, + "community_name": "udev.rs", + "norm_label": "udevclassification" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_option", + "community": 71, + "community_name": "udev.rs", + "norm_label": "option" + }, + { + "label": ".from_device()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L152", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udevclassification_from_device", + "community": 71, + "community_name": "udev.rs", + "norm_label": ".from_device()" + }, + { + "label": "udev_event_payload()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L169", + "_origin": "ast", + "id": "breadd_src_adapters_udev_udev_event_payload", + "community": 71, + "community_name": "udev.rs", + "norm_label": "udev_event_payload()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_adapters_udev_rs_value", + "community": 71, + "community_name": "udev.rs", + "norm_label": "value" + }, + { + "label": "prop_bool()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L195", + "_origin": "ast", + "id": "breadd_src_adapters_udev_prop_bool", + "community": 71, + "community_name": "udev.rs", + "norm_label": "prop_bool()" + }, + { + "label": "prop_str()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L203", + "_origin": "ast", + "id": "breadd_src_adapters_udev_prop_str", + "community": 71, + "community_name": "udev.rs", + "norm_label": "prop_str()" + }, + { + "label": "enumerate_payload_includes_classification_fields()", + "file_type": "code", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L214", + "_origin": "ast", + "id": "breadd_src_adapters_udev_enumerate_payload_includes_classification_fields", + "community": 71, + "community_name": "udev.rs", + "norm_label": "enumerate_payload_includes_classification_fields()" + }, + { + "label": "config.rs", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_config", + "community": 2, + "community_name": "config.rs", + "norm_label": "config.rs" + }, + { + "label": "Config", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L9", + "_origin": "ast", + "id": "breadd_src_core_config_config", + "community": 2, + "community_name": "config.rs", + "norm_label": "config" + }, + { + "label": "DaemonConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L27", + "_origin": "ast", + "id": "breadd_src_core_config_daemonconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "daemonconfig" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_string", + "community": 2, + "community_name": "config.rs", + "norm_label": "string" + }, + { + "label": "LuaConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L35", + "_origin": "ast", + "id": "breadd_src_core_config_luaconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "luaconfig" + }, + { + "label": "ModulesConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L43", + "_origin": "ast", + "id": "breadd_src_core_config_modulesconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "modulesconfig" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_vec", + "community": 2, + "community_name": "config.rs", + "norm_label": "vec" + }, + { + "label": "AdaptersConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L51", + "_origin": "ast", + "id": "breadd_src_core_config_adaptersconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "adaptersconfig" + }, + { + "label": "AdapterToggle", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L73", + "_origin": "ast", + "id": "breadd_src_core_config_adaptertoggle", + "community": 2, + "community_name": "config.rs", + "norm_label": "adaptertoggle" + }, + { + "label": "UdevConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L79", + "_origin": "ast", + "id": "breadd_src_core_config_udevconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "udevconfig" + }, + { + "label": "PowerConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L87", + "_origin": "ast", + "id": "breadd_src_core_config_powerconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "powerconfig" + }, + { + "label": "RootsConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L100", + "_origin": "ast", + "id": "breadd_src_core_config_rootsconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "rootsconfig" + }, + { + "label": "SystemdConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L108", + "_origin": "ast", + "id": "breadd_src_core_config_systemdconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "systemdconfig" + }, + { + "label": "EventsConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L119", + "_origin": "ast", + "id": "breadd_src_core_config_eventsconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "eventsconfig" + }, + { + "label": "CompatConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L128", + "_origin": "ast", + "id": "breadd_src_core_config_compatconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "compatconfig" + }, + { + "label": "NotificationsConfig", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L141", + "_origin": "ast", + "id": "breadd_src_core_config_notificationsconfig", + "community": 2, + "community_name": "config.rs", + "norm_label": "notificationsconfig" + }, + { + "label": "Default", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_default", + "community": 2, + "community_name": "config.rs", + "norm_label": "default" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L151", + "_origin": "ast", + "id": "breadd_src_core_config_daemonconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_self", + "community": 2, + "community_name": "config.rs", + "norm_label": "self" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L160", + "_origin": "ast", + "id": "breadd_src_core_config_luaconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L169", + "_origin": "ast", + "id": "breadd_src_core_config_modulesconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L178", + "_origin": "ast", + "id": "breadd_src_core_config_adaptertoggle_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L186", + "_origin": "ast", + "id": "breadd_src_core_config_udevconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L195", + "_origin": "ast", + "id": "breadd_src_core_config_powerconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L204", + "_origin": "ast", + "id": "breadd_src_core_config_rootsconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L213", + "_origin": "ast", + "id": "breadd_src_core_config_systemdconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L222", + "_origin": "ast", + "id": "breadd_src_core_config_eventsconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L230", + "_origin": "ast", + "id": "breadd_src_core_config_notificationsconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L240", + "_origin": "ast", + "id": "breadd_src_core_config_compatconfig_default", + "community": 2, + "community_name": "config.rs", + "norm_label": ".default()" + }, + { + "label": ".load()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L248", + "_origin": "ast", + "id": "breadd_src_core_config_config_load", + "community": 2, + "community_name": "config.rs", + "norm_label": ".load()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_result", + "community": 2, + "community_name": "config.rs", + "norm_label": "result" + }, + { + "label": ".socket_path()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L259", + "_origin": "ast", + "id": "breadd_src_core_config_config_socket_path", + "community": 2, + "community_name": "config.rs", + "norm_label": ".socket_path()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_pathbuf", + "community": 2, + "community_name": "config.rs", + "norm_label": "pathbuf" + }, + { + "label": ".lua_entry_point()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L268", + "_origin": "ast", + "id": "breadd_src_core_config_config_lua_entry_point", + "community": 2, + "community_name": "config.rs", + "norm_label": ".lua_entry_point()" + }, + { + "label": ".lua_module_path()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L272", + "_origin": "ast", + "id": "breadd_src_core_config_config_lua_module_path", + "community": 2, + "community_name": "config.rs", + "norm_label": ".lua_module_path()" + }, + { + "label": "config_path()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L277", + "_origin": "ast", + "id": "breadd_src_core_config_config_path", + "community": 2, + "community_name": "config.rs", + "norm_label": "config_path()" + }, + { + "label": "rules_path()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L290", + "_origin": "ast", + "id": "breadd_src_core_config_rules_path", + "community": 2, + "community_name": "config.rs", + "norm_label": "rules_path()" + }, + { + "label": "expand_home()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L306", + "_origin": "ast", + "id": "breadd_src_core_config_expand_home", + "community": 2, + "community_name": "config.rs", + "norm_label": "expand_home()" + }, + { + "label": "default_log_level()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L320", + "_origin": "ast", + "id": "breadd_src_core_config_default_log_level", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_log_level()" + }, + { + "label": "default_lua_entry()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L324", + "_origin": "ast", + "id": "breadd_src_core_config_default_lua_entry", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_lua_entry()" + }, + { + "label": "default_lua_modules()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L328", + "_origin": "ast", + "id": "breadd_src_core_config_default_lua_modules", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_lua_modules()" + }, + { + "label": "default_true()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L332", + "_origin": "ast", + "id": "breadd_src_core_config_default_true", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_true()" + }, + { + "label": "default_poll_interval()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L336", + "_origin": "ast", + "id": "breadd_src_core_config_default_poll_interval", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_poll_interval()" + }, + { + "label": "default_dedup_window()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L340", + "_origin": "ast", + "id": "breadd_src_core_config_default_dedup_window", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_dedup_window()" + }, + { + "label": "default_notify_timeout()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L344", + "_origin": "ast", + "id": "breadd_src_core_config_default_notify_timeout", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_notify_timeout()" + }, + { + "label": "default_notify_urgency()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L348", + "_origin": "ast", + "id": "breadd_src_core_config_default_notify_urgency", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_notify_urgency()" + }, + { + "label": "default_notify_path()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L352", + "_origin": "ast", + "id": "breadd_src_core_config_default_notify_path", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_notify_path()" + }, + { + "label": "default_udev_subsystems()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L356", + "_origin": "ast", + "id": "breadd_src_core_config_default_udev_subsystems", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_udev_subsystems()" + }, + { + "label": "EnvGuard", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L375", + "_origin": "ast", + "id": "breadd_src_core_config_envguard", + "community": 2, + "community_name": "config.rs", + "norm_label": "envguard" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_option", + "community": 2, + "community_name": "config.rs", + "norm_label": "option" + }, + { + "label": "MutexGuard", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "mutexguard", + "community": 2, + "community_name": "config.rs", + "norm_label": "mutexguard" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L381", + "_origin": "ast", + "id": "breadd_src_core_config_envguard_new", + "community": 2, + "community_name": "config.rs", + "norm_label": ".new()" + }, + { + "label": "Drop", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_config_rs_drop", + "community": 2, + "community_name": "config.rs", + "norm_label": "drop" + }, + { + "label": ".drop()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L392", + "_origin": "ast", + "id": "breadd_src_core_config_envguard_drop", + "community": 2, + "community_name": "config.rs", + "norm_label": ".drop()" + }, + { + "label": "default_config_uses_documented_defaults()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L403", + "_origin": "ast", + "id": "breadd_src_core_config_default_config_uses_documented_defaults", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_config_uses_documented_defaults()" + }, + { + "label": "default_udev_subsystems_match_documented_list()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L425", + "_origin": "ast", + "id": "breadd_src_core_config_default_udev_subsystems_match_documented_list", + "community": 2, + "community_name": "config.rs", + "norm_label": "default_udev_subsystems_match_documented_list()" + }, + { + "label": "parse_empty_toml_yields_defaults()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L433", + "_origin": "ast", + "id": "breadd_src_core_config_parse_empty_toml_yields_defaults", + "community": 2, + "community_name": "config.rs", + "norm_label": "parse_empty_toml_yields_defaults()" + }, + { + "label": "parse_full_toml_overrides_all_values()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L441", + "_origin": "ast", + "id": "breadd_src_core_config_parse_full_toml_overrides_all_values", + "community": 2, + "community_name": "config.rs", + "norm_label": "parse_full_toml_overrides_all_values()" + }, + { + "label": "parse_partial_toml_fills_missing_with_defaults()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L504", + "_origin": "ast", + "id": "breadd_src_core_config_parse_partial_toml_fills_missing_with_defaults", + "community": 2, + "community_name": "config.rs", + "norm_label": "parse_partial_toml_fills_missing_with_defaults()" + }, + { + "label": "compat_section_defaults_legacy_hyprland_names_to_true()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L518", + "_origin": "ast", + "id": "breadd_src_core_config_compat_section_defaults_legacy_hyprland_names_to_true", + "community": 2, + "community_name": "config.rs", + "norm_label": "compat_section_defaults_legacy_hyprland_names_to_true()" + }, + { + "label": "compat_section_can_disable_legacy_hyprland_names()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L524", + "_origin": "ast", + "id": "breadd_src_core_config_compat_section_can_disable_legacy_hyprland_names", + "community": 2, + "community_name": "config.rs", + "norm_label": "compat_section_can_disable_legacy_hyprland_names()" + }, + { + "label": "invalid_toml_returns_error()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L534", + "_origin": "ast", + "id": "breadd_src_core_config_invalid_toml_returns_error", + "community": 2, + "community_name": "config.rs", + "norm_label": "invalid_toml_returns_error()" + }, + { + "label": "socket_path_uses_explicit_path_verbatim()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L540", + "_origin": "ast", + "id": "breadd_src_core_config_socket_path_uses_explicit_path_verbatim", + "community": 2, + "community_name": "config.rs", + "norm_label": "socket_path_uses_explicit_path_verbatim()" + }, + { + "label": "socket_path_expands_tilde_when_explicit()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L547", + "_origin": "ast", + "id": "breadd_src_core_config_socket_path_expands_tilde_when_explicit", + "community": 2, + "community_name": "config.rs", + "norm_label": "socket_path_expands_tilde_when_explicit()" + }, + { + "label": "socket_path_falls_back_to_xdg_runtime_dir()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L559", + "_origin": "ast", + "id": "breadd_src_core_config_socket_path_falls_back_to_xdg_runtime_dir", + "community": 2, + "community_name": "config.rs", + "norm_label": "socket_path_falls_back_to_xdg_runtime_dir()" + }, + { + "label": "socket_path_uses_tmp_when_no_xdg_runtime_dir()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L570", + "_origin": "ast", + "id": "breadd_src_core_config_socket_path_uses_tmp_when_no_xdg_runtime_dir", + "community": 2, + "community_name": "config.rs", + "norm_label": "socket_path_uses_tmp_when_no_xdg_runtime_dir()" + }, + { + "label": "lua_entry_point_and_module_path_expand_tilde()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L578", + "_origin": "ast", + "id": "breadd_src_core_config_lua_entry_point_and_module_path_expand_tilde", + "community": 2, + "community_name": "config.rs", + "norm_label": "lua_entry_point_and_module_path_expand_tilde()" + }, + { + "label": "lua_entry_point_and_module_path_prefer_xdg_config_home_when_set()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L594", + "_origin": "ast", + "id": "breadd_src_core_config_lua_entry_point_and_module_path_prefer_xdg_config_home_when_set", + "community": 2, + "community_name": "config.rs", + "norm_label": "lua_entry_point_and_module_path_prefer_xdg_config_home_when_set()" + }, + { + "label": "lua_entry_point_returns_absolute_path_unchanged()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L615", + "_origin": "ast", + "id": "breadd_src_core_config_lua_entry_point_returns_absolute_path_unchanged", + "community": 2, + "community_name": "config.rs", + "norm_label": "lua_entry_point_returns_absolute_path_unchanged()" + }, + { + "label": "expand_home_handles_missing_home_env()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L622", + "_origin": "ast", + "id": "breadd_src_core_config_expand_home_handles_missing_home_env", + "community": 2, + "community_name": "config.rs", + "norm_label": "expand_home_handles_missing_home_env()" + }, + { + "label": "config_path_respects_xdg_config_home()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L632", + "_origin": "ast", + "id": "breadd_src_core_config_config_path_respects_xdg_config_home", + "community": 2, + "community_name": "config.rs", + "norm_label": "config_path_respects_xdg_config_home()" + }, + { + "label": "config_path_falls_back_to_home_when_no_xdg()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L642", + "_origin": "ast", + "id": "breadd_src_core_config_config_path_falls_back_to_home_when_no_xdg", + "community": 2, + "community_name": "config.rs", + "norm_label": "config_path_falls_back_to_home_when_no_xdg()" + }, + { + "label": "rules_path_respects_xdg_config_home()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L653", + "_origin": "ast", + "id": "breadd_src_core_config_rules_path_respects_xdg_config_home", + "community": 2, + "community_name": "config.rs", + "norm_label": "rules_path_respects_xdg_config_home()" + }, + { + "label": "rules_path_falls_back_to_home_when_no_xdg()", + "file_type": "code", + "source_file": "breadd/src/core/config.rs", + "source_location": "L663", + "_origin": "ast", + "id": "breadd_src_core_config_rules_path_falls_back_to_home_when_no_xdg", + "community": 2, + "community_name": "config.rs", + "norm_label": "rules_path_falls_back_to_home_when_no_xdg()" + }, + { + "label": "core/mod.rs", + "file_type": "code", + "source_file": "breadd/src/core/mod.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_mod", + "community": 56, + "community_name": "core/mod.rs", + "norm_label": "core/mod.rs" + }, + { + "label": "normalizer.rs", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_normalizer", + "community": 1, + "community_name": "RawEvent", + "norm_label": "normalizer.rs" + }, + { + "label": "EventNormalizer", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L13", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer", + "community": 1, + "community_name": "RawEvent", + "norm_label": "eventnormalizer" + }, + { + "label": "RwLock", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_normalizer_rs_rwlock", + "community": 1, + "community_name": "RawEvent", + "norm_label": "rwlock" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_normalizer_rs_hashmap", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hashmap" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_normalizer_rs_string", + "community": 1, + "community_name": "RawEvent", + "norm_label": "string" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L28", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_new", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_normalizer_rs_self", + "community": 1, + "community_name": "RawEvent", + "norm_label": "self" + }, + { + "label": ".with_legacy_hyprland_event_names()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L43", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_with_legacy_hyprland_event_names", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".with_legacy_hyprland_event_names()" + }, + { + "label": ".normalize()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L48", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize()" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_normalizer_rs_vec", + "community": 1, + "community_name": "RawEvent", + "norm_label": "vec" + }, + { + "label": ".normalize_udev()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L91", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_udev", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_udev()" + }, + { + "label": ".normalize_hyprland()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L198", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_hyprland()" + }, + { + "label": ".emit_hyprland_dual()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L304", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".emit_hyprland_dual()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_normalizer_rs_value", + "community": 1, + "community_name": "RawEvent", + "norm_label": "value" + }, + { + "label": ".normalize_power()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L335", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_power()" + }, + { + "label": ".normalize_bluetooth()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L392", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_bluetooth", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_bluetooth()" + }, + { + "label": ".normalize_network()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L477", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_network", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_network()" + }, + { + "label": ".normalize_terminal()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L521", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_terminal", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_terminal()" + }, + { + "label": ".normalize_remote()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L532", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_remote", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_remote()" + }, + { + "label": ".normalize_git()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L543", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_git", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_git()" + }, + { + "label": ".normalize_filesystem()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L554", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_filesystem", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_filesystem()" + }, + { + "label": ".normalize_systemd()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L565", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_systemd", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_systemd()" + }, + { + "label": ".normalize_podman()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L579", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_podman", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_podman()" + }, + { + "label": ".normalize_app()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L604", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".normalize_app()" + }, + { + "label": ".accept()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L624", + "_origin": "ast", + "id": "breadd_src_core_normalizer_eventnormalizer_accept", + "community": 1, + "community_name": "RawEvent", + "norm_label": ".accept()" + }, + { + "label": "split_hyprland_fields()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L668", + "_origin": "ast", + "id": "breadd_src_core_normalizer_split_hyprland_fields", + "community": 1, + "community_name": "RawEvent", + "norm_label": "split_hyprland_fields()" + }, + { + "label": "raw()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L679", + "_origin": "ast", + "id": "breadd_src_core_normalizer_raw", + "community": 1, + "community_name": "RawEvent", + "norm_label": "raw()" + }, + { + "label": "udev_add_emits_connected_with_identity_fields()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L691", + "_origin": "ast", + "id": "breadd_src_core_normalizer_udev_add_emits_connected_with_identity_fields", + "community": 1, + "community_name": "RawEvent", + "norm_label": "udev_add_emits_connected_with_identity_fields()" + }, + { + "label": "udev_remove_emits_disconnected()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L718", + "_origin": "ast", + "id": "breadd_src_core_normalizer_udev_remove_emits_disconnected", + "community": 1, + "community_name": "RawEvent", + "norm_label": "udev_remove_emits_disconnected()" + }, + { + "label": "udev_bind_action_is_suppressed()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L739", + "_origin": "ast", + "id": "breadd_src_core_normalizer_udev_bind_action_is_suppressed", + "community": 1, + "community_name": "RawEvent", + "norm_label": "udev_bind_action_is_suppressed()" + }, + { + "label": "udev_anonymous_child_interface_is_dropped()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L756", + "_origin": "ast", + "id": "breadd_src_core_normalizer_udev_anonymous_child_interface_is_dropped", + "community": 1, + "community_name": "RawEvent", + "norm_label": "udev_anonymous_child_interface_is_dropped()" + }, + { + "label": "udev_dedupes_child_nodes_of_same_physical_device()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L772", + "_origin": "ast", + "id": "breadd_src_core_normalizer_udev_dedupes_child_nodes_of_same_physical_device", + "community": 1, + "community_name": "RawEvent", + "norm_label": "udev_dedupes_child_nodes_of_same_physical_device()" + }, + { + "label": "udev_disconnect_does_not_share_dedup_with_connect()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L798", + "_origin": "ast", + "id": "breadd_src_core_normalizer_udev_disconnect_does_not_share_dedup_with_connect", + "community": 1, + "community_name": "RawEvent", + "norm_label": "udev_disconnect_does_not_share_dedup_with_connect()" + }, + { + "label": "hyprland_workspace_change()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L825", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_workspace_change", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_workspace_change()" + }, + { + "label": "hyprland_active_window_v2_parses_address_from_fields()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L842", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_active_window_v2_parses_address_from_fields", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_active_window_v2_parses_address_from_fields()" + }, + { + "label": "hyprland_openwindow_splits_all_fields()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L862", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_openwindow_splits_all_fields", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_openwindow_splits_all_fields()" + }, + { + "label": "hyprland_unknown_kind_falls_through_to_generic_event()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L886", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_unknown_kind_falls_through_to_generic_event", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_unknown_kind_falls_through_to_generic_event()" + }, + { + "label": "hyprland_monitor_lifecycle()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L903", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_monitor_lifecycle", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_monitor_lifecycle()" + }, + { + "label": "hyprland_dual_emit_covers_all_ten_mappings_by_default()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L940", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_dual_emit_covers_all_ten_mappings_by_default", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_dual_emit_covers_all_ten_mappings_by_default()" + }, + { + "label": "hyprland_legacy_names_suppressed_when_compat_disabled()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1055", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_legacy_names_suppressed_when_compat_disabled", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_legacy_names_suppressed_when_compat_disabled()" + }, + { + "label": "hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1160", + "_origin": "ast", + "id": "breadd_src_core_normalizer_hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat", + "community": 1, + "community_name": "RawEvent", + "norm_label": "hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat()" + }, + { + "label": "power_ac_connected_emits_named_event()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1199", + "_origin": "ast", + "id": "breadd_src_core_normalizer_power_ac_connected_emits_named_event", + "community": 1, + "community_name": "RawEvent", + "norm_label": "power_ac_connected_emits_named_event()" + }, + { + "label": "power_battery_thresholds_select_correct_event()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1212", + "_origin": "ast", + "id": "breadd_src_core_normalizer_power_battery_thresholds_select_correct_event", + "community": 1, + "community_name": "RawEvent", + "norm_label": "power_battery_thresholds_select_correct_event()" + }, + { + "label": "power_mid_range_battery_emits_generic_changed()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1238", + "_origin": "ast", + "id": "breadd_src_core_normalizer_power_mid_range_battery_emits_generic_changed", + "community": 1, + "community_name": "RawEvent", + "norm_label": "power_mid_range_battery_emits_generic_changed()" + }, + { + "label": "power_ac_and_battery_can_both_fire()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1251", + "_origin": "ast", + "id": "breadd_src_core_normalizer_power_ac_and_battery_can_both_fire", + "community": 1, + "community_name": "RawEvent", + "norm_label": "power_ac_and_battery_can_both_fire()" + }, + { + "label": "bluetooth_connected_emits_device_connected()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1267", + "_origin": "ast", + "id": "breadd_src_core_normalizer_bluetooth_connected_emits_device_connected", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bluetooth_connected_emits_device_connected()" + }, + { + "label": "bluetooth_disconnected_emits_device_disconnected()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1293", + "_origin": "ast", + "id": "breadd_src_core_normalizer_bluetooth_disconnected_emits_device_disconnected", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bluetooth_disconnected_emits_device_disconnected()" + }, + { + "label": "bluetooth_enumerate_includes_name()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1310", + "_origin": "ast", + "id": "breadd_src_core_normalizer_bluetooth_enumerate_includes_name", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bluetooth_enumerate_includes_name()" + }, + { + "label": "bluetooth_paired_emits_bluetooth_specific_event()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1329", + "_origin": "ast", + "id": "breadd_src_core_normalizer_bluetooth_paired_emits_bluetooth_specific_event", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bluetooth_paired_emits_bluetooth_specific_event()" + }, + { + "label": "bluetooth_unpaired_emits_bluetooth_specific_event()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1348", + "_origin": "ast", + "id": "breadd_src_core_normalizer_bluetooth_unpaired_emits_bluetooth_specific_event", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bluetooth_unpaired_emits_bluetooth_specific_event()" + }, + { + "label": "bluetooth_name_falls_back_to_properties()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1365", + "_origin": "ast", + "id": "breadd_src_core_normalizer_bluetooth_name_falls_back_to_properties", + "community": 1, + "community_name": "RawEvent", + "norm_label": "bluetooth_name_falls_back_to_properties()" + }, + { + "label": "network_online_and_offline()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1384", + "_origin": "ast", + "id": "breadd_src_core_normalizer_network_online_and_offline", + "community": 1, + "community_name": "RawEvent", + "norm_label": "network_online_and_offline()" + }, + { + "label": "system_events_pass_through_unchanged()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1405", + "_origin": "ast", + "id": "breadd_src_core_normalizer_system_events_pass_through_unchanged", + "community": 1, + "community_name": "RawEvent", + "norm_label": "system_events_pass_through_unchanged()" + }, + { + "label": "dedup_drops_duplicate_within_window()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1422", + "_origin": "ast", + "id": "breadd_src_core_normalizer_dedup_drops_duplicate_within_window", + "community": 1, + "community_name": "RawEvent", + "norm_label": "dedup_drops_duplicate_within_window()" + }, + { + "label": "dedup_allows_after_window_elapses()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1432", + "_origin": "ast", + "id": "breadd_src_core_normalizer_dedup_allows_after_window_elapses", + "community": 1, + "community_name": "RawEvent", + "norm_label": "dedup_allows_after_window_elapses()" + }, + { + "label": "dedup_distinguishes_different_payloads()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1442", + "_origin": "ast", + "id": "breadd_src_core_normalizer_dedup_distinguishes_different_payloads", + "community": 1, + "community_name": "RawEvent", + "norm_label": "dedup_distinguishes_different_payloads()" + }, + { + "label": "dedup_window_of_zero_allows_everything()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1467", + "_origin": "ast", + "id": "breadd_src_core_normalizer_dedup_window_of_zero_allows_everything", + "community": 1, + "community_name": "RawEvent", + "norm_label": "dedup_window_of_zero_allows_everything()" + }, + { + "label": "app_own_namespace_passes_through()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1486", + "_origin": "ast", + "id": "breadd_src_core_normalizer_app_own_namespace_passes_through", + "community": 1, + "community_name": "RawEvent", + "norm_label": "app_own_namespace_passes_through()" + }, + { + "label": "app_command_to_another_known_app_passes_through()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1499", + "_origin": "ast", + "id": "breadd_src_core_normalizer_app_command_to_another_known_app_passes_through", + "community": 1, + "community_name": "RawEvent", + "norm_label": "app_command_to_another_known_app_passes_through()" + }, + { + "label": "app_wrong_namespace_is_dropped()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1512", + "_origin": "ast", + "id": "breadd_src_core_normalizer_app_wrong_namespace_is_dropped", + "community": 1, + "community_name": "RawEvent", + "norm_label": "app_wrong_namespace_is_dropped()" + }, + { + "label": "app_command_to_unknown_or_reserved_target_is_dropped()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1524", + "_origin": "ast", + "id": "breadd_src_core_normalizer_app_command_to_unknown_or_reserved_target_is_dropped", + "community": 1, + "community_name": "RawEvent", + "norm_label": "app_command_to_unknown_or_reserved_target_is_dropped()" + }, + { + "label": "split_fields_handles_empty_and_single()", + "file_type": "code", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1545", + "_origin": "ast", + "id": "breadd_src_core_normalizer_split_fields_handles_empty_and_single", + "community": 1, + "community_name": "RawEvent", + "norm_label": "split_fields_handles_empty_and_single()" + }, + { + "label": "rules.rs", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_rules", + "community": 68, + "community_name": "rules.rs", + "norm_label": "rules.rs" + }, + { + "label": "RulesFile", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L36", + "_origin": "ast", + "id": "breadd_src_core_rules_rulesfile", + "community": 68, + "community_name": "rules.rs", + "norm_label": "rulesfile" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_vec", + "community": 68, + "community_name": "rules.rs", + "norm_label": "vec" + }, + { + "label": "RawRule", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L42", + "_origin": "ast", + "id": "breadd_src_core_rules_rawrule", + "community": 68, + "community_name": "rules.rs", + "norm_label": "rawrule" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_option", + "community": 68, + "community_name": "rules.rs", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_string", + "community": 68, + "community_name": "rules.rs", + "norm_label": "string" + }, + { + "label": "RuleAction", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L51", + "_origin": "ast", + "id": "breadd_src_core_rules_ruleaction", + "community": 68, + "community_name": "rules.rs", + "norm_label": "ruleaction" + }, + { + "label": "ParsedRule", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L67", + "_origin": "ast", + "id": "breadd_src_core_rules_parsedrule", + "community": 68, + "community_name": "rules.rs", + "norm_label": "parsedrule" + }, + { + "label": "RuleIssue", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L80", + "_origin": "ast", + "id": "breadd_src_core_rules_ruleissue", + "community": 68, + "community_name": "rules.rs", + "norm_label": "ruleissue" + }, + { + "label": "Display", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_display", + "community": 68, + "community_name": "rules.rs", + "norm_label": "display" + }, + { + "label": ".fmt()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L90", + "_origin": "ast", + "id": "breadd_src_core_rules_ruleissue_fmt", + "community": 68, + "community_name": "rules.rs", + "norm_label": ".fmt()" + }, + { + "label": "Formatter", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_formatter", + "community": 68, + "community_name": "rules.rs", + "norm_label": "formatter" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_result", + "community": 68, + "community_name": "rules.rs", + "norm_label": "result" + }, + { + "label": "RulesLoadOutcome", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L100", + "_origin": "ast", + "id": "breadd_src_core_rules_rulesloadoutcome", + "community": 68, + "community_name": "rules.rs", + "norm_label": "rulesloadoutcome" + }, + { + "label": "load_rules()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L126", + "_origin": "ast", + "id": "breadd_src_core_rules_load_rules", + "community": 68, + "community_name": "rules.rs", + "norm_label": "load_rules()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_path", + "community": 68, + "community_name": "rules.rs", + "norm_label": "path" + }, + { + "label": "validate_rule()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L153", + "_origin": "ast", + "id": "breadd_src_core_rules_validate_rule", + "community": 68, + "community_name": "rules.rs", + "norm_label": "validate_rule()" + }, + { + "label": "write_temp()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L210", + "_origin": "ast", + "id": "breadd_src_core_rules_write_temp", + "community": 68, + "community_name": "rules.rs", + "norm_label": "write_temp()" + }, + { + "label": "TempDir", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_tempdir", + "community": 68, + "community_name": "rules.rs", + "norm_label": "tempdir" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_rules_rs_pathbuf", + "community": 68, + "community_name": "rules.rs", + "norm_label": "pathbuf" + }, + { + "label": "absent_file_is_not_an_error()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L219", + "_origin": "ast", + "id": "breadd_src_core_rules_absent_file_is_not_an_error", + "community": 68, + "community_name": "rules.rs", + "norm_label": "absent_file_is_not_an_error()" + }, + { + "label": "invalid_toml_is_fatal()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L226", + "_origin": "ast", + "id": "breadd_src_core_rules_invalid_toml_is_fatal", + "community": 68, + "community_name": "rules.rs", + "norm_label": "invalid_toml_is_fatal()" + }, + { + "label": "empty_file_loads_with_no_rules()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L235", + "_origin": "ast", + "id": "breadd_src_core_rules_empty_file_loads_with_no_rules", + "community": 68, + "community_name": "rules.rs", + "norm_label": "empty_file_loads_with_no_rules()" + }, + { + "label": "well_formed_rules_all_three_action_kinds_parse()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L247", + "_origin": "ast", + "id": "breadd_src_core_rules_well_formed_rules_all_three_action_kinds_parse", + "community": 68, + "community_name": "rules.rs", + "norm_label": "well_formed_rules_all_three_action_kinds_parse()" + }, + { + "label": "wildcard_on_is_passed_through_unvalidated()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L289", + "_origin": "ast", + "id": "breadd_src_core_rules_wildcard_on_is_passed_through_unvalidated", + "community": 68, + "community_name": "rules.rs", + "norm_label": "wildcard_on_is_passed_through_unvalidated()" + }, + { + "label": "missing_on_is_reported_with_index_and_no_on()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L305", + "_origin": "ast", + "id": "breadd_src_core_rules_missing_on_is_reported_with_index_and_no_on", + "community": 68, + "community_name": "rules.rs", + "norm_label": "missing_on_is_reported_with_index_and_no_on()" + }, + { + "label": "empty_on_is_treated_as_missing()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L323", + "_origin": "ast", + "id": "breadd_src_core_rules_empty_on_is_treated_as_missing", + "community": 68, + "community_name": "rules.rs", + "norm_label": "empty_on_is_treated_as_missing()" + }, + { + "label": "zero_action_keys_is_reported()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L339", + "_origin": "ast", + "id": "breadd_src_core_rules_zero_action_keys_is_reported", + "community": 68, + "community_name": "rules.rs", + "norm_label": "zero_action_keys_is_reported()" + }, + { + "label": "multiple_action_keys_is_reported()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L356", + "_origin": "ast", + "id": "breadd_src_core_rules_multiple_action_keys_is_reported", + "community": 68, + "community_name": "rules.rs", + "norm_label": "multiple_action_keys_is_reported()" + }, + { + "label": "one_bad_rule_does_not_block_other_valid_rules()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L375", + "_origin": "ast", + "id": "breadd_src_core_rules_one_bad_rule_does_not_block_other_valid_rules", + "community": 68, + "community_name": "rules.rs", + "norm_label": "one_bad_rule_does_not_block_other_valid_rules()" + }, + { + "label": "rule_issue_display_includes_index_and_on()", + "file_type": "code", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L399", + "_origin": "ast", + "id": "breadd_src_core_rules_rule_issue_display_includes_index_and_on", + "community": 68, + "community_name": "rules.rs", + "norm_label": "rule_issue_display_includes_index_and_on()" + }, + { + "label": "state_engine.rs", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_state_engine", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "state_engine.rs" + }, + { + "label": "StateHandle", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L18", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle", + "community": 22, + "community_name": "StateHandle", + "norm_label": "statehandle" + }, + { + "label": "Arc", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_arc", + "community": 22, + "community_name": "StateHandle", + "norm_label": "arc" + }, + { + "label": "RwLock", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_rwlock", + "community": 22, + "community_name": "StateHandle", + "norm_label": "rwlock" + }, + { + "label": "UnboundedSender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_unboundedsender", + "community": 22, + "community_name": "StateHandle", + "norm_label": "unboundedsender" + }, + { + "label": "StateCommand", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L23", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statecommand", + "community": 22, + "community_name": "StateHandle", + "norm_label": "statecommand" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_string", + "community": 16, + "community_name": "Value", + "norm_label": "string" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_option", + "community": 16, + "community_name": "Value", + "norm_label": "option" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_vec", + "community": 22, + "community_name": "StateHandle", + "norm_label": "vec" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_new", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_self", + "community": 22, + "community_name": "StateHandle", + "norm_label": "self" + }, + { + "label": ".state_arc()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L63", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_state_arc", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".state_arc()" + }, + { + "label": ".state_get()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L67", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_state_get", + "community": 16, + "community_name": "Value", + "norm_label": ".state_get()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_value", + "community": 16, + "community_name": "Value", + "norm_label": "value" + }, + { + "label": ".state_dump()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L82", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_state_dump", + "community": 16, + "community_name": "Value", + "norm_label": ".state_dump()" + }, + { + "label": ".register_subscription()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L87", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_register_subscription", + "community": 16, + "community_name": "Value", + "norm_label": ".register_subscription()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_result", + "community": 16, + "community_name": "Value", + "norm_label": "result" + }, + { + "label": ".remove_subscription()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L98", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_remove_subscription", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".remove_subscription()" + }, + { + "label": ".register_watch()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L104", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_register_watch", + "community": 16, + "community_name": "Value", + "norm_label": ".register_watch()" + }, + { + "label": ".remove_watch()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L110", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_remove_watch", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".remove_watch()" + }, + { + "label": ".clear_subscriptions()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L114", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_clear_subscriptions", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".clear_subscriptions()" + }, + { + "label": ".clear_modules()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L118", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_clear_modules", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".clear_modules()" + }, + { + "label": ".clear_widgets()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L122", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_clear_widgets", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".clear_widgets()" + }, + { + "label": ".set_module_status()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L126", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_set_module_status", + "community": 16, + "community_name": "Value", + "norm_label": ".set_module_status()" + }, + { + "label": ".set_module_status_ex()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L143", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_set_module_status_ex", + "community": 16, + "community_name": "Value", + "norm_label": ".set_module_status_ex()" + }, + { + "label": ".set_profile()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L160", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_set_profile", + "community": 16, + "community_name": "Value", + "norm_label": ".set_profile()" + }, + { + "label": ".set_device_rules()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L164", + "_origin": "ast", + "id": "breadd_src_core_state_engine_statehandle_set_device_rules", + "community": 22, + "community_name": "StateHandle", + "norm_label": ".set_device_rules()" + }, + { + "label": "run_state_engine()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "_origin": "ast", + "id": "breadd_src_core_state_engine_run_state_engine", + "community": 22, + "community_name": "StateHandle", + "norm_label": "run_state_engine()" + }, + { + "label": "UnboundedReceiver", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "unboundedreceiver", + "community": 22, + "community_name": "StateHandle", + "norm_label": "unboundedreceiver" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_sender", + "community": 22, + "community_name": "StateHandle", + "norm_label": "sender" + }, + { + "label": "AtomicU64", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_atomicu64", + "community": 22, + "community_name": "StateHandle", + "norm_label": "atomicu64" + }, + { + "label": "Receiver", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_receiver", + "community": 22, + "community_name": "StateHandle", + "norm_label": "receiver" + }, + { + "label": "handle_command()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "_origin": "ast", + "id": "breadd_src_core_state_engine_handle_command", + "community": 22, + "community_name": "StateHandle", + "norm_label": "handle_command()" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_state_engine_rs_hashmap", + "community": 22, + "community_name": "StateHandle", + "norm_label": "hashmap" + }, + { + "label": "dispatch_event()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "_origin": "ast", + "id": "breadd_src_core_state_engine_dispatch_event", + "community": 22, + "community_name": "StateHandle", + "norm_label": "dispatch_event()" + }, + { + "label": "value_at_path()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L387", + "_origin": "ast", + "id": "breadd_src_core_state_engine_value_at_path", + "community": 16, + "community_name": "Value", + "norm_label": "value_at_path()" + }, + { + "label": "hyprland_state_key()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L401", + "_origin": "ast", + "id": "breadd_src_core_state_engine_hyprland_state_key", + "community": 16, + "community_name": "Value", + "norm_label": "hyprland_state_key()" + }, + { + "label": "json_stringish()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L420", + "_origin": "ast", + "id": "breadd_src_core_state_engine_json_stringish", + "community": 16, + "community_name": "Value", + "norm_label": "json_stringish()" + }, + { + "label": "workspace_id_from_data()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L428", + "_origin": "ast", + "id": "breadd_src_core_state_engine_workspace_id_from_data", + "community": 16, + "community_name": "Value", + "norm_label": "workspace_id_from_data()" + }, + { + "label": "active_window_from_data()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L440", + "_origin": "ast", + "id": "breadd_src_core_state_engine_active_window_from_data", + "community": 16, + "community_name": "Value", + "norm_label": "active_window_from_data()" + }, + { + "label": "upsert_monitor()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L452", + "_origin": "ast", + "id": "breadd_src_core_state_engine_upsert_monitor", + "community": 16, + "community_name": "Value", + "norm_label": "upsert_monitor()" + }, + { + "label": "apply_hyprland_snapshot()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L480", + "_origin": "ast", + "id": "breadd_src_core_state_engine_apply_hyprland_snapshot", + "community": 16, + "community_name": "Value", + "norm_label": "apply_hyprland_snapshot()" + }, + { + "label": "apply_event_to_state()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L529", + "_origin": "ast", + "id": "breadd_src_core_state_engine_apply_event_to_state", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "apply_event_to_state()" + }, + { + "label": "resolve_device()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L624", + "_origin": "ast", + "id": "breadd_src_core_state_engine_resolve_device", + "community": 16, + "community_name": "Value", + "norm_label": "resolve_device()" + }, + { + "label": "condition_matches()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L634", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_matches", + "community": 16, + "community_name": "Value", + "norm_label": "condition_matches()" + }, + { + "label": "apply_device_change()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L752", + "_origin": "ast", + "id": "breadd_src_core_state_engine_apply_device_change", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "apply_device_change()" + }, + { + "label": "ev()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L801", + "_origin": "ast", + "id": "breadd_src_core_state_engine_ev", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "ev()" + }, + { + "label": "value_at_path_returns_root_for_empty_path()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L815", + "_origin": "ast", + "id": "breadd_src_core_state_engine_value_at_path_returns_root_for_empty_path", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "value_at_path_returns_root_for_empty_path()" + }, + { + "label": "value_at_path_navigates_nested_keys()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L821", + "_origin": "ast", + "id": "breadd_src_core_state_engine_value_at_path_navigates_nested_keys", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "value_at_path_navigates_nested_keys()" + }, + { + "label": "value_at_path_returns_none_on_missing_key()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L827", + "_origin": "ast", + "id": "breadd_src_core_state_engine_value_at_path_returns_none_on_missing_key", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "value_at_path_returns_none_on_missing_key()" + }, + { + "label": "monitor_connect_adds_new_monitor()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L836", + "_origin": "ast", + "id": "breadd_src_core_state_engine_monitor_connect_adds_new_monitor", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "monitor_connect_adds_new_monitor()" + }, + { + "label": "monitor_reconnect_does_not_duplicate()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L853", + "_origin": "ast", + "id": "breadd_src_core_state_engine_monitor_reconnect_does_not_duplicate", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "monitor_reconnect_does_not_duplicate()" + }, + { + "label": "monitor_disconnect_keeps_record_but_flips_connected_flag()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L867", + "_origin": "ast", + "id": "breadd_src_core_state_engine_monitor_disconnect_keeps_record_but_flips_connected_flag", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "monitor_disconnect_keeps_record_but_flips_connected_flag()" + }, + { + "label": "workspace_changed_updates_active_workspace()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L884", + "_origin": "ast", + "id": "breadd_src_core_state_engine_workspace_changed_updates_active_workspace", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "workspace_changed_updates_active_workspace()" + }, + { + "label": "window_focus_change_updates_active_window()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L900", + "_origin": "ast", + "id": "breadd_src_core_state_engine_window_focus_change_updates_active_window", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "window_focus_change_updates_active_window()" + }, + { + "label": "namespaced_hyprland_events_update_the_same_state()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L916", + "_origin": "ast", + "id": "breadd_src_core_state_engine_namespaced_hyprland_events_update_the_same_state", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "namespaced_hyprland_events_update_the_same_state()" + }, + { + "label": "hyprland_snapshot_replaces_topology()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L949", + "_origin": "ast", + "id": "breadd_src_core_state_engine_hyprland_snapshot_replaces_topology", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "hyprland_snapshot_replaces_topology()" + }, + { + "label": "device_connect_adds_device_with_all_fields()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L979", + "_origin": "ast", + "id": "breadd_src_core_state_engine_device_connect_adds_device_with_all_fields", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "device_connect_adds_device_with_all_fields()" + }, + { + "label": "device_connect_is_idempotent_for_same_id()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1004", + "_origin": "ast", + "id": "breadd_src_core_state_engine_device_connect_is_idempotent_for_same_id", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "device_connect_is_idempotent_for_same_id()" + }, + { + "label": "device_disconnect_removes_matching_id()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1013", + "_origin": "ast", + "id": "breadd_src_core_state_engine_device_disconnect_removes_matching_id", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "device_disconnect_removes_matching_id()" + }, + { + "label": "device_disconnect_of_unknown_id_is_noop()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1025", + "_origin": "ast", + "id": "breadd_src_core_state_engine_device_disconnect_of_unknown_id_is_noop", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "device_disconnect_of_unknown_id_is_noop()" + }, + { + "label": "power_event_updates_ac_and_battery_low_flag()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1035", + "_origin": "ast", + "id": "breadd_src_core_state_engine_power_event_updates_ac_and_battery_low_flag", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "power_event_updates_ac_and_battery_low_flag()" + }, + { + "label": "power_clamps_battery_percent_to_100()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1057", + "_origin": "ast", + "id": "breadd_src_core_state_engine_power_clamps_battery_percent_to_100", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "power_clamps_battery_percent_to_100()" + }, + { + "label": "network_event_updates_online_flag_and_interfaces()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1069", + "_origin": "ast", + "id": "breadd_src_core_state_engine_network_event_updates_online_flag_and_interfaces", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "network_event_updates_online_flag_and_interfaces()" + }, + { + "label": "profile_activated_pushes_previous_to_history()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1093", + "_origin": "ast", + "id": "breadd_src_core_state_engine_profile_activated_pushes_previous_to_history", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "profile_activated_pushes_previous_to_history()" + }, + { + "label": "profile_activated_to_same_name_is_noop()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1112", + "_origin": "ast", + "id": "breadd_src_core_state_engine_profile_activated_to_same_name_is_noop", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "profile_activated_to_same_name_is_noop()" + }, + { + "label": "unknown_event_does_not_mutate_state()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1123", + "_origin": "ast", + "id": "breadd_src_core_state_engine_unknown_event_does_not_mutate_state", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "unknown_event_does_not_mutate_state()" + }, + { + "label": "condition_vendor_id_matches_case_insensitively()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1137", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_vendor_id_matches_case_insensitively", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "condition_vendor_id_matches_case_insensitively()" + }, + { + "label": "condition_name_contains_searches_name_and_vendor()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1147", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_name_contains_searches_name_and_vendor", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "condition_name_contains_searches_name_and_vendor()" + }, + { + "label": "condition_input_flags_match_booleans()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1158", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_input_flags_match_booleans", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "condition_input_flags_match_booleans()" + }, + { + "label": "condition_usb_hub_requires_hub_and_secondary_class()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1176", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_usb_hub_requires_hub_and_secondary_class", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "condition_usb_hub_requires_hub_and_secondary_class()" + }, + { + "label": "condition_id_usb_class_accepts_with_or_without_0x_prefix()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1198", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_id_usb_class_accepts_with_or_without_0x_prefix", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "condition_id_usb_class_accepts_with_or_without_0x_prefix()" + }, + { + "label": "condition_empty_matches_anything()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1209", + "_origin": "ast", + "id": "breadd_src_core_state_engine_condition_empty_matches_anything", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "condition_empty_matches_anything()" + }, + { + "label": "resolve_device_returns_first_matching_rule()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1218", + "_origin": "ast", + "id": "breadd_src_core_state_engine_resolve_device_returns_first_matching_rule", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "resolve_device_returns_first_matching_rule()" + }, + { + "label": "resolve_device_skips_rules_with_no_conditions()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1250", + "_origin": "ast", + "id": "breadd_src_core_state_engine_resolve_device_skips_rules_with_no_conditions", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "resolve_device_skips_rules_with_no_conditions()" + }, + { + "label": "resolve_device_with_empty_ruleset_returns_unknown()", + "file_type": "code", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1259", + "_origin": "ast", + "id": "breadd_src_core_state_engine_resolve_device_with_empty_ruleset_returns_unknown", + "community": 9, + "community_name": "state_engine.rs", + "norm_label": "resolve_device_with_empty_ruleset_returns_unknown()" + }, + { + "label": "subscriptions.rs", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_subscriptions", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "subscriptions.rs" + }, + { + "label": "SubscriptionId", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L4", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscriptionid", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "subscriptionid" + }, + { + "label": "Subscription", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L7", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscription", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "subscription" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_rs_string", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "string" + }, + { + "label": "SubscriptionTable", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L14", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscriptiontable", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "subscriptiontable" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_rs_vec", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "vec" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_rs_hashmap", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "hashmap" + }, + { + "label": ".add_with_id()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L21", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": ".add_with_id()" + }, + { + "label": ".remove()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L35", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscriptiontable_remove", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": ".remove()" + }, + { + "label": ".clear()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L55", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscriptiontable_clear", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": ".clear()" + }, + { + "label": ".match_event()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L60", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": ".match_event()" + }, + { + "label": "table_add_assigns_provided_id_and_finds_match()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L82", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_add_assigns_provided_id_and_finds_match", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_add_assigns_provided_id_and_finds_match()" + }, + { + "label": "table_match_returns_all_matching_subscriptions()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L95", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_match_returns_all_matching_subscriptions", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_match_returns_all_matching_subscriptions()" + }, + { + "label": "table_remove_returns_true_only_for_known_ids()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L111", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_remove_returns_true_only_for_known_ids", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_remove_returns_true_only_for_known_ids()" + }, + { + "label": "table_remove_preserves_other_entries_after_swap_remove()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L122", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_remove_preserves_other_entries_after_swap_remove", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_remove_preserves_other_entries_after_swap_remove()" + }, + { + "label": "table_clear_removes_all()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L137", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_clear_removes_all", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_clear_removes_all()" + }, + { + "label": "table_match_returns_empty_for_unmatched_event()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L149", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_match_returns_empty_for_unmatched_event", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_match_returns_empty_for_unmatched_event()" + }, + { + "label": "table_once_flag_is_preserved_in_match_result()", + "file_type": "code", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L156", + "_origin": "ast", + "id": "breadd_src_core_subscriptions_table_once_flag_is_preserved_in_match_result", + "community": 20, + "community_name": "SubscriptionId", + "norm_label": "table_once_flag_is_preserved_in_match_result()" + }, + { + "label": "supervisor.rs", + "file_type": "code", + "source_file": "breadd/src/core/supervisor.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_supervisor", + "community": 3, + "community_name": "Server", + "norm_label": "supervisor.rs" + }, + { + "label": "spawn_supervised()", + "file_type": "code", + "source_file": "breadd/src/core/supervisor.rs", + "source_location": "L7", + "_origin": "ast", + "id": "breadd_src_core_supervisor_spawn_supervised", + "community": 3, + "community_name": "Server", + "norm_label": "spawn_supervised()" + }, + { + "label": "Receiver", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_supervisor_rs_receiver", + "community": 3, + "community_name": "Server", + "norm_label": "receiver" + }, + { + "label": "F", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_supervisor_rs_f", + "community": 3, + "community_name": "Server", + "norm_label": "f" + }, + { + "label": "types.rs", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_core_types", + "community": 14, + "community_name": "types.rs", + "norm_label": "types.rs" + }, + { + "label": "RuntimeState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L8", + "_origin": "ast", + "id": "breadd_src_core_types_runtimestate", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "runtimestate" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_vec", + "community": 14, + "community_name": "types.rs", + "norm_label": "vec" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_option", + "community": 14, + "community_name": "types.rs", + "norm_label": "option" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_string", + "community": 14, + "community_name": "types.rs", + "norm_label": "string" + }, + { + "label": "Monitor", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L26", + "_origin": "ast", + "id": "breadd_src_core_types_monitor", + "community": 14, + "community_name": "types.rs", + "norm_label": "monitor" + }, + { + "label": "Workspace", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L34", + "_origin": "ast", + "id": "breadd_src_core_types_workspace", + "community": 14, + "community_name": "types.rs", + "norm_label": "workspace" + }, + { + "label": "DeviceTopology", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L40", + "_origin": "ast", + "id": "breadd_src_core_types_devicetopology", + "community": 14, + "community_name": "types.rs", + "norm_label": "devicetopology" + }, + { + "label": "Device", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L45", + "_origin": "ast", + "id": "breadd_src_core_types_device", + "community": 71, + "community_name": "udev.rs", + "norm_label": "device" + }, + { + "label": "MatchCondition", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L58", + "_origin": "ast", + "id": "breadd_src_core_types_matchcondition", + "community": 14, + "community_name": "types.rs", + "norm_label": "matchcondition" + }, + { + "label": "DeviceRule", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L77", + "_origin": "ast", + "id": "breadd_src_core_types_devicerule", + "community": 22, + "community_name": "StateHandle", + "norm_label": "devicerule" + }, + { + "label": "NetworkState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L83", + "_origin": "ast", + "id": "breadd_src_core_types_networkstate", + "community": 14, + "community_name": "types.rs", + "norm_label": "networkstate" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_hashmap", + "community": 14, + "community_name": "types.rs", + "norm_label": "hashmap" + }, + { + "label": "InterfaceState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L89", + "_origin": "ast", + "id": "breadd_src_core_types_interfacestate", + "community": 14, + "community_name": "types.rs", + "norm_label": "interfacestate" + }, + { + "label": "PowerState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L94", + "_origin": "ast", + "id": "breadd_src_core_types_powerstate", + "community": 14, + "community_name": "types.rs", + "norm_label": "powerstate" + }, + { + "label": "ProfileState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L101", + "_origin": "ast", + "id": "breadd_src_core_types_profilestate", + "community": 14, + "community_name": "types.rs", + "norm_label": "profilestate" + }, + { + "label": "BTreeMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_btreemap", + "community": 14, + "community_name": "types.rs", + "norm_label": "btreemap" + }, + { + "label": "Default", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_default", + "community": 14, + "community_name": "types.rs", + "norm_label": "default" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L108", + "_origin": "ast", + "id": "breadd_src_core_types_profilestate_default", + "community": 14, + "community_name": "types.rs", + "norm_label": ".default()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_self", + "community": 14, + "community_name": "types.rs", + "norm_label": "self" + }, + { + "label": "ModuleStatus", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L118", + "_origin": "ast", + "id": "breadd_src_core_types_modulestatus", + "community": 14, + "community_name": "types.rs", + "norm_label": "modulestatus" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_core_types_rs_value", + "community": 14, + "community_name": "types.rs", + "norm_label": "value" + }, + { + "label": "ModuleLoadState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L139", + "_origin": "ast", + "id": "breadd_src_core_types_moduleloadstate", + "community": 16, + "community_name": "Value", + "norm_label": "moduleloadstate" + }, + { + "label": "WorkflowStatus", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L152", + "_origin": "ast", + "id": "breadd_src_core_types_workflowstatus", + "community": 14, + "community_name": "types.rs", + "norm_label": "workflowstatus" + }, + { + "label": "WorkflowState", + "file_type": "code", + "source_file": "breadd/src/core/types.rs", + "source_location": "L166", + "_origin": "ast", + "id": "breadd_src_core_types_workflowstate", + "community": 14, + "community_name": "types.rs", + "norm_label": "workflowstate" + }, + { + "label": "ipc/mod.rs", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_ipc_mod", + "community": 3, + "community_name": "Server", + "norm_label": "ipc/mod.rs" + }, + { + "label": "Server", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L47", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server", + "community": 3, + "community_name": "Server", + "norm_label": "server" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_pathbuf", + "community": 3, + "community_name": "Server", + "norm_label": "pathbuf" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_sender", + "community": 3, + "community_name": "Server", + "norm_label": "sender" + }, + { + "label": "UnboundedSender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_unboundedsender", + "community": 3, + "community_name": "Server", + "norm_label": "unboundedsender" + }, + { + "label": "Arc", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_arc", + "community": 3, + "community_name": "Server", + "norm_label": "arc" + }, + { + "label": "RwLock", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_rwlock", + "community": 3, + "community_name": "Server", + "norm_label": "rwlock" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_hashmap", + "community": 3, + "community_name": "Server", + "norm_label": "hashmap" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_string", + "community": 3, + "community_name": "Server", + "norm_label": "string" + }, + { + "label": "AtomicU64", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_atomicu64", + "community": 3, + "community_name": "Server", + "norm_label": "atomicu64" + }, + { + "label": "Mutex", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_mutex", + "community": 3, + "community_name": "Server", + "norm_label": "mutex" + }, + { + "label": "VecDeque", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_vecdeque", + "community": 3, + "community_name": "Server", + "norm_label": "vecdeque" + }, + { + "label": "Instant", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_instant", + "community": 3, + "community_name": "Server", + "norm_label": "instant" + }, + { + "label": "IpcRequest", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L67", + "_origin": "ast", + "id": "breadd_src_ipc_mod_ipcrequest", + "community": 3, + "community_name": "Server", + "norm_label": "ipcrequest" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_value", + "community": 3, + "community_name": "Server", + "norm_label": "value" + }, + { + "label": "IpcResponse", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L75", + "_origin": "ast", + "id": "breadd_src_ipc_mod_ipcresponse", + "community": 3, + "community_name": "Server", + "norm_label": "ipcresponse" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_option", + "community": 3, + "community_name": "Server", + "norm_label": "option" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server_new", + "community": 3, + "community_name": "Server", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_self", + "community": 3, + "community_name": "Server", + "norm_label": "self" + }, + { + "label": ".serve()", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L115", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server_serve", + "community": 3, + "community_name": "Server", + "norm_label": ".serve()" + }, + { + "label": "Receiver", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_receiver", + "community": 3, + "community_name": "Server", + "norm_label": "receiver" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_result", + "community": 3, + "community_name": "Server", + "norm_label": "result" + }, + { + "label": ".handle_connection()", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L159", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server_handle_connection", + "community": 3, + "community_name": "Server", + "norm_label": ".handle_connection()" + }, + { + "label": "UnixStream", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "unixstream", + "community": 30, + "community_name": "TestHarness", + "norm_label": "unixstream" + }, + { + "label": ".handle_request()", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L235", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server_handle_request", + "community": 3, + "community_name": "Server", + "norm_label": ".handle_request()" + }, + { + "label": ".manual_emit()", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L445", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server_manual_emit", + "community": 3, + "community_name": "Server", + "norm_label": ".manual_emit()" + }, + { + "label": ".stream_events()", + "file_type": "code", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L463", + "_origin": "ast", + "id": "breadd_src_ipc_mod_server_stream_events", + "community": 3, + "community_name": "Server", + "norm_label": ".stream_events()" + }, + { + "label": "OwnedWriteHalf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_mod_rs_ownedwritehalf", + "community": 3, + "community_name": "Server", + "norm_label": "ownedwritehalf" + }, + { + "label": "module_host_bridge.rs", + "file_type": "code", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "module_host_bridge.rs" + }, + { + "label": "Server", + "file_type": "code", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L44", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_server", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "server" + }, + { + "label": ".handle_module_host_connection()", + "file_type": "code", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".handle_module_host_connection()" + }, + { + "label": "Lines", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "lines", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "lines" + }, + { + "label": "BufReader", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "bufreader", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "bufreader" + }, + { + "label": "OwnedReadHalf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "ownedreadhalf", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "ownedreadhalf" + }, + { + "label": "OwnedWriteHalf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_ownedwritehalf", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "ownedwritehalf" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_result", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "result" + }, + { + "label": ".dispatch_module_host_method()", + "file_type": "code", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".dispatch_module_host_method()" + }, + { + "label": "UnboundedSender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_unboundedsender", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "unboundedsender" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_string", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "string" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_hashmap", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "hashmap" + }, + { + "label": "JoinHandle", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "joinhandle", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "joinhandle" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_option", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "option" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_sender", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "sender" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_rs_value", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "value" + }, + { + "label": "path_allowed()", + "file_type": "code", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L511", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_path_allowed", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "path_allowed()" + }, + { + "label": "bin_allowed()", + "file_type": "code", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L531", + "_origin": "ast", + "id": "breadd_src_ipc_module_host_bridge_bin_allowed", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "bin_allowed()" + }, + { + "label": "lua/mod.rs", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_lua_mod", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "lua/mod.rs" + }, + { + "label": "LuaMessage", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L31", + "_origin": "ast", + "id": "breadd_src_lua_mod_luamessage", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "luamessage" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_sender", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "sender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_result", + "community": 17, + "community_name": "Result", + "norm_label": "result" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_string", + "community": 17, + "community_name": "Result", + "norm_label": "string" + }, + { + "label": "ErrorEntry", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L49", + "_origin": "ast", + "id": "breadd_src_lua_mod_errorentry", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "errorentry" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_option", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "option" + }, + { + "label": "RuntimeHandle", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L56", + "_origin": "ast", + "id": "breadd_src_lua_mod_runtimehandle", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "runtimehandle" + }, + { + "label": "UnboundedSender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_unboundedsender", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "unboundedsender" + }, + { + "label": "Arc", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_arc", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "arc" + }, + { + "label": "Mutex", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_mutex", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "mutex" + }, + { + "label": "VecDeque", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_vecdeque", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "vecdeque" + }, + { + "label": ".sender()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L62", + "_origin": "ast", + "id": "breadd_src_lua_mod_runtimehandle_sender", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".sender()" + }, + { + "label": ".reload()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L66", + "_origin": "ast", + "id": "breadd_src_lua_mod_runtimehandle_reload", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".reload()" + }, + { + "label": ".shutdown()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L78", + "_origin": "ast", + "id": "breadd_src_lua_mod_runtimehandle_shutdown", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".shutdown()" + }, + { + "label": ".recent_errors()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L82", + "_origin": "ast", + "id": "breadd_src_lua_mod_runtimehandle_recent_errors", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".recent_errors()" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_vec", + "community": 33, + "community_name": ".new", + "norm_label": "vec" + }, + { + "label": "spawn_runtime()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "_origin": "ast", + "id": "breadd_src_lua_mod_spawn_runtime", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "spawn_runtime()" + }, + { + "label": "TimerId", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L169", + "_origin": "ast", + "id": "breadd_src_lua_mod_timerid", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "timerid" + }, + { + "label": "HandlerEntry", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L171", + "_origin": "ast", + "id": "breadd_src_lua_mod_handlerentry", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "handlerentry" + }, + { + "label": "RegistryKey", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_registrykey", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "registrykey" + }, + { + "label": "HandlerKind", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L180", + "_origin": "ast", + "id": "breadd_src_lua_mod_handlerkind", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "handlerkind" + }, + { + "label": "TimerEntry", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L185", + "_origin": "ast", + "id": "breadd_src_lua_mod_timerentry", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "timerentry" + }, + { + "label": "ModuleDecl", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L197", + "_origin": "ast", + "id": "breadd_src_lua_mod_moduledecl", + "community": 33, + "community_name": ".new", + "norm_label": "moduledecl" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_pathbuf", + "community": 88, + "community_name": "PathBuf", + "norm_label": "pathbuf" + }, + { + "label": "ModuleInfo", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L216", + "_origin": "ast", + "id": "breadd_src_lua_mod_moduleinfo", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "moduleinfo" + }, + { + "label": "LuaEngine", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L220", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "luaengine" + }, + { + "label": "Lua", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_lua", + "community": 17, + "community_name": "Result", + "norm_label": "lua" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_hashmap", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "hashmap" + }, + { + "label": "HashSet", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_hashset", + "community": 33, + "community_name": ".new", + "norm_label": "hashset" + }, + { + "label": "AtomicU64", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_atomicu64", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "atomicu64" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_new", + "community": 33, + "community_name": ".new", + "norm_label": ".new()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_self", + "community": 33, + "community_name": ".new", + "norm_label": "self" + }, + { + "label": ".reload_internal()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L294", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_reload_internal", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".reload_internal()" + }, + { + "label": ".install_api()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L347", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_install_api", + "community": 17, + "community_name": "Result", + "norm_label": ".install_api()" + }, + { + "label": ".load_device_rules()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1280", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_device_rules", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".load_device_rules()" + }, + { + "label": ".load_profiles()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1335", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_profiles", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".load_profiles()" + }, + { + "label": ".load_rules_toml()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1381", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_rules_toml", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".load_rules_toml()" + }, + { + "label": ".load_init_and_modules()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1436", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "community": 33, + "community_name": ".new", + "norm_label": ".load_init_and_modules()" + }, + { + "label": ".load_module()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1539", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_module", + "community": 33, + "community_name": ".new", + "norm_label": ".load_module()" + }, + { + "label": ".load_out_of_process_module()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1590", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_out_of_process_module", + "community": 33, + "community_name": ".new", + "norm_label": ".load_out_of_process_module()" + }, + { + "label": ".load_lua_file()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1612", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_lua_file", + "community": 33, + "community_name": ".new", + "norm_label": ".load_lua_file()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_path", + "community": 33, + "community_name": ".new", + "norm_label": "path" + }, + { + "label": ".load_scoped_lua_file()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1642", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "community": 33, + "community_name": ".new", + "norm_label": ".load_scoped_lua_file()" + }, + { + "label": ".build_scoped_env()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1724", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_build_scoped_env", + "community": 33, + "community_name": ".new", + "norm_label": ".build_scoped_env()" + }, + { + "label": "Table", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_table", + "community": 14, + "community_name": "types.rs", + "norm_label": "table" + }, + { + "label": ".load_lua_source()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1833", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_load_lua_source", + "community": 33, + "community_name": ".new", + "norm_label": ".load_lua_source()" + }, + { + "label": ".handle_event()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1841", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_handle_event", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".handle_event()" + }, + { + "label": ".handle_timer()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1912", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_handle_timer", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".handle_timer()" + }, + { + "label": ".remove_handler()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1936", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_remove_handler", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".remove_handler()" + }, + { + "label": ".run_on_load()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1942", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_run_on_load", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".run_on_load()" + }, + { + "label": ".run_on_reload()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1962", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_run_on_reload", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".run_on_reload()" + }, + { + "label": ".run_on_unload()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1988", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_run_on_unload", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".run_on_unload()" + }, + { + "label": ".handle_callback_error()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2014", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_handle_callback_error", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".handle_callback_error()" + }, + { + "label": "LuaError", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "luaerror", + "community": 0, + "community_name": "LuaEngine", + "norm_label": "luaerror" + }, + { + "label": ".get_module_hook()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2051", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_get_module_hook", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".get_module_hook()" + }, + { + "label": "Function", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_function", + "community": 17, + "community_name": "Result", + "norm_label": "function" + }, + { + "label": ".module_is_registered()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2061", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_module_is_registered", + "community": 33, + "community_name": ".new", + "norm_label": ".module_is_registered()" + }, + { + "label": ".module_is_builtin()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2068", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_module_is_builtin", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".module_is_builtin()" + }, + { + "label": ".module_ungated()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2080", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_module_ungated", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".module_ungated()" + }, + { + "label": ".set_current_module()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2091", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_set_current_module", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".set_current_module()" + }, + { + "label": ".set_current_dispatch_id()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2102", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_set_current_dispatch_id", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".set_current_dispatch_id()" + }, + { + "label": ".cancel_all_timers()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2109", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_cancel_all_timers", + "community": 0, + "community_name": "LuaEngine", + "norm_label": ".cancel_all_timers()" + }, + { + "label": ".install_log_helpers()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2117", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_install_log_helpers", + "community": 17, + "community_name": "Result", + "norm_label": ".install_log_helpers()" + }, + { + "label": ".install_debounce()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2176", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_install_debounce", + "community": 17, + "community_name": "Result", + "norm_label": ".install_debounce()" + }, + { + "label": ".scan_module_decl()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2209", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_scan_module_decl", + "community": 33, + "community_name": ".new", + "norm_label": ".scan_module_decl()" + }, + { + "label": ".install_require_loader()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2273", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_install_require_loader", + "community": 17, + "community_name": "Result", + "norm_label": ".install_require_loader()" + }, + { + "label": ".install_wait_helper()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2315", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_install_wait_helper", + "community": 17, + "community_name": "Result", + "norm_label": ".install_wait_helper()" + }, + { + "label": ".install_workflow_helpers()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2370", + "_origin": "ast", + "id": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": ".install_workflow_helpers()" + }, + { + "label": "workflow_register()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2599", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_register", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_register()" + }, + { + "label": "RwLock", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_rwlock", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "rwlock" + }, + { + "label": "workflow_step()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2626", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_step", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_step()" + }, + { + "label": "workflow_finish()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2640", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_finish", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_finish()" + }, + { + "label": "workflow_fail()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2654", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_fail", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_fail()" + }, + { + "label": "workflow_timeout()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2669", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_timeout", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_timeout()" + }, + { + "label": "workflow_status_json()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_status_json", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_status_json()" + }, + { + "label": "JsonValue", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_jsonvalue", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "jsonvalue" + }, + { + "label": "workflow_list_json()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2699", + "_origin": "ast", + "id": "breadd_src_lua_mod_workflow_list_json", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "workflow_list_json()" + }, + { + "label": "WidgetRegisterArgs", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2714", + "_origin": "ast", + "id": "breadd_src_lua_mod_widgetregisterargs", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "widgetregisterargs" + }, + { + "label": "WidgetUpdateArgs", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2729", + "_origin": "ast", + "id": "breadd_src_lua_mod_widgetupdateargs", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "widgetupdateargs" + }, + { + "label": "default_widget_visible()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2740", + "_origin": "ast", + "id": "breadd_src_lua_mod_default_widget_visible", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "default_widget_visible()" + }, + { + "label": "widget_register()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "_origin": "ast", + "id": "breadd_src_lua_mod_widget_register", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "widget_register()" + }, + { + "label": "widget_update()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "_origin": "ast", + "id": "breadd_src_lua_mod_widget_update", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "widget_update()" + }, + { + "label": "widget_remove()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2811", + "_origin": "ast", + "id": "breadd_src_lua_mod_widget_remove", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "widget_remove()" + }, + { + "label": "widget_list_json()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2825", + "_origin": "ast", + "id": "breadd_src_lua_mod_widget_list_json", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "widget_list_json()" + }, + { + "label": "order_module_decls()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2837", + "_origin": "ast", + "id": "breadd_src_lua_mod_order_module_decls", + "community": 33, + "community_name": ".new", + "norm_label": "order_module_decls()" + }, + { + "label": "module_name_from_path()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2911", + "_origin": "ast", + "id": "breadd_src_lua_mod_module_name_from_path", + "community": 33, + "community_name": ".new", + "norm_label": "module_name_from_path()" + }, + { + "label": "is_lib_path()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2920", + "_origin": "ast", + "id": "breadd_src_lua_mod_is_lib_path", + "community": 33, + "community_name": ".new", + "norm_label": "is_lib_path()" + }, + { + "label": "read_module_permissions()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2943", + "_origin": "ast", + "id": "breadd_src_lua_mod_read_module_permissions", + "community": 33, + "community_name": ".new", + "norm_label": "read_module_permissions()" + }, + { + "label": "json_to_lua()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2979", + "_origin": "ast", + "id": "breadd_src_lua_mod_json_to_lua", + "community": 17, + "community_name": "Result", + "norm_label": "json_to_lua()" + }, + { + "label": "T", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "t", + "community": 17, + "community_name": "Result", + "norm_label": "t" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_value", + "community": 17, + "community_name": "Result", + "norm_label": "value" + }, + { + "label": "state_value_to_lua()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "_origin": "ast", + "id": "breadd_src_lua_mod_state_value_to_lua", + "community": 17, + "community_name": "Result", + "norm_label": "state_value_to_lua()" + }, + { + "label": "module_store_get()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "_origin": "ast", + "id": "breadd_src_lua_mod_module_store_get", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "module_store_get()" + }, + { + "label": "module_store_set()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "_origin": "ast", + "id": "breadd_src_lua_mod_module_store_set", + "community": 60, + "community_name": "lua/mod.rs", + "norm_label": "module_store_set()" + }, + { + "label": "lua_expand_path()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3069", + "_origin": "ast", + "id": "breadd_src_lua_mod_lua_expand_path", + "community": 88, + "community_name": "PathBuf", + "norm_label": "lua_expand_path()" + }, + { + "label": "shell_quote()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3087", + "_origin": "ast", + "id": "breadd_src_lua_mod_shell_quote", + "community": 17, + "community_name": "Result", + "norm_label": "shell_quote()" + }, + { + "label": "dirs_home()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3091", + "_origin": "ast", + "id": "breadd_src_lua_mod_dirs_home", + "community": 88, + "community_name": "PathBuf", + "norm_label": "dirs_home()" + }, + { + "label": "lua_machine_name()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3098", + "_origin": "ast", + "id": "breadd_src_lua_mod_lua_machine_name", + "community": 17, + "community_name": "Result", + "norm_label": "lua_machine_name()" + }, + { + "label": "lua_hostname()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3111", + "_origin": "ast", + "id": "breadd_src_lua_mod_lua_hostname", + "community": 17, + "community_name": "Result", + "norm_label": "lua_hostname()" + }, + { + "label": "lua_machine_tags()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3135", + "_origin": "ast", + "id": "breadd_src_lua_mod_lua_machine_tags", + "community": 17, + "community_name": "Result", + "norm_label": "lua_machine_tags()" + }, + { + "label": "read_sync_toml()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3151", + "_origin": "ast", + "id": "breadd_src_lua_mod_read_sync_toml", + "community": 17, + "community_name": "Result", + "norm_label": "read_sync_toml()" + }, + { + "label": "builtin_module_decls()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3441", + "_origin": "ast", + "id": "breadd_src_lua_mod_builtin_module_decls", + "community": 33, + "community_name": ".new", + "norm_label": "builtin_module_decls()" + }, + { + "label": "hyprland_request_socket()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3478", + "_origin": "ast", + "id": "breadd_src_lua_mod_hyprland_request_socket", + "community": 17, + "community_name": "Result", + "norm_label": "hyprland_request_socket()" + }, + { + "label": "hyprland_request()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3512", + "_origin": "ast", + "id": "breadd_src_lua_mod_hyprland_request", + "community": 17, + "community_name": "Result", + "norm_label": "hyprland_request()" + }, + { + "label": "parse_match_condition()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3524", + "_origin": "ast", + "id": "breadd_src_lua_mod_parse_match_condition", + "community": 14, + "community_name": "types.rs", + "norm_label": "parse_match_condition()" + }, + { + "label": "list_lua_files()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3540", + "_origin": "ast", + "id": "breadd_src_lua_mod_list_lua_files", + "community": 33, + "community_name": ".new", + "norm_label": "list_lua_files()" + }, + { + "label": "bluetooth_spawn()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3566", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_spawn", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_spawn()" + }, + { + "label": "F", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_f", + "community": 17, + "community_name": "Result", + "norm_label": "f" + }, + { + "label": "bluetooth_query()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3588", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_query", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_query()" + }, + { + "label": "bluetooth_find_adapter()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3611", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_find_adapter", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_find_adapter()" + }, + { + "label": "Connection", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_lua_mod_rs_connection", + "community": 17, + "community_name": "Result", + "norm_label": "connection" + }, + { + "label": "bluetooth_set_powered()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3634", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_set_powered", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_set_powered()" + }, + { + "label": "bluetooth_get_powered()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3652", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_get_powered", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_get_powered()" + }, + { + "label": "bluetooth_connect()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3669", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_connect", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_connect()" + }, + { + "label": "bluetooth_disconnect()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3684", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_disconnect", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_disconnect()" + }, + { + "label": "bluetooth_set_scanning()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3699", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_set_scanning", + "community": 17, + "community_name": "Result", + "norm_label": "bluetooth_set_scanning()" + }, + { + "label": "BluetoothDevice", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3718", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetoothdevice", + "community": 17, + "community_name": "Result", + "norm_label": "bluetoothdevice" + }, + { + "label": "bluetooth_list_devices()", + "file_type": "code", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3725", + "_origin": "ast", + "id": "breadd_src_lua_mod_bluetooth_list_devices", + "community": 33, + "community_name": ".new", + "norm_label": "bluetooth_list_devices()" + }, + { + "label": "breadd/src/main.rs", + "file_type": "code", + "source_file": "breadd/src/main.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_main", + "community": 31, + "community_name": "Sync", + "norm_label": "breadd/src/main.rs" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "breadd/src/main.rs", + "source_location": "L23", + "_origin": "ast", + "id": "breadd_src_main_main", + "community": 31, + "community_name": "Sync", + "norm_label": "main()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_main_rs_result", + "community": 31, + "community_name": "Sync", + "norm_label": "result" + }, + { + "label": "wait_for_shutdown()", + "file_type": "code", + "source_file": "breadd/src/main.rs", + "source_location": "L150", + "_origin": "ast", + "id": "breadd_src_main_wait_for_shutdown", + "community": 31, + "community_name": "Sync", + "norm_label": "wait_for_shutdown()" + }, + { + "label": "module_host.rs", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_src_module_host", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "module_host.rs" + }, + { + "label": "ModuleHostOutcome", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L86", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostoutcome", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "modulehostoutcome" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_string", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "string" + }, + { + "label": "PendingModuleHost", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L95", + "_origin": "ast", + "id": "breadd_src_module_host_pendingmodulehost", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "pendingmodulehost" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_vec", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "vec" + }, + { + "label": "Sender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_sender", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "sender" + }, + { + "label": "ActiveModuleHost", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L101", + "_origin": "ast", + "id": "breadd_src_module_host_activemodulehost", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "activemodulehost" + }, + { + "label": "ModuleHostRegistry", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L109", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "modulehostregistry" + }, + { + "label": "Arc", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_arc", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "arc" + }, + { + "label": "Mutex", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_mutex", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "mutex" + }, + { + "label": "Inner", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L114", + "_origin": "ast", + "id": "breadd_src_module_host_inner", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "inner" + }, + { + "label": "HashMap", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_hashmap", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "hashmap" + }, + { + "label": "Default", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_default", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "default" + }, + { + "label": ".default()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L120", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_default", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".default()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_self", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "self" + }, + { + "label": ".new()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L126", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_new", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".new()" + }, + { + "label": ".insert_pending()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L132", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_insert_pending", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".insert_pending()" + }, + { + "label": ".take_pending()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L144", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_take_pending", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".take_pending()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_option", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "option" + }, + { + "label": ".insert_active()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L152", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_insert_active", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".insert_active()" + }, + { + "label": ".remove_active()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L160", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_remove_active", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".remove_active()" + }, + { + "label": ".terminate_existing()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L178", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_terminate_existing", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".terminate_existing()" + }, + { + "label": ".shutdown_all()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L193", + "_origin": "ast", + "id": "breadd_src_module_host_modulehostregistry_shutdown_all", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": ".shutdown_all()" + }, + { + "label": "spawn_module_host()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "_origin": "ast", + "id": "breadd_src_module_host_spawn_module_host", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "spawn_module_host()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_path", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "path" + }, + { + "label": "UnboundedSender", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_unboundedsender", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "unboundedsender" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_result", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "result" + }, + { + "label": "short()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L350", + "_origin": "ast", + "id": "breadd_src_module_host_short", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "short()" + }, + { + "label": "describe_exit()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L354", + "_origin": "ast", + "id": "breadd_src_module_host_describe_exit", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "describe_exit()" + }, + { + "label": "ExitStatus", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "exitstatus", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "exitstatus" + }, + { + "label": "resolve_module_host_binary()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L377", + "_origin": "ast", + "id": "breadd_src_module_host_resolve_module_host_binary", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "resolve_module_host_binary()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_src_module_host_rs_pathbuf", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "pathbuf" + }, + { + "label": "apply_sandbox()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L458", + "_origin": "ast", + "id": "breadd_src_module_host_apply_sandbox", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "apply_sandbox()" + }, + { + "label": "resolve_bin_path()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L616", + "_origin": "ast", + "id": "breadd_src_module_host_resolve_bin_path", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "resolve_bin_path()" + }, + { + "label": "landlock_denies_reads_outside_granted_path()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L647", + "_origin": "ast", + "id": "breadd_src_module_host_landlock_denies_reads_outside_granted_path", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "landlock_denies_reads_outside_granted_path()" + }, + { + "label": "no_exec_permission_means_binary_cannot_be_executed_at_all()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L725", + "_origin": "ast", + "id": "breadd_src_module_host_no_exec_permission_means_binary_cannot_be_executed_at_all", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "no_exec_permission_means_binary_cannot_be_executed_at_all()" + }, + { + "label": "which_sh()", + "file_type": "code", + "source_file": "breadd/src/module_host.rs", + "source_location": "L771", + "_origin": "ast", + "id": "breadd_src_module_host_which_sh", + "community": 65, + "community_name": "ModuleHostRegistry", + "norm_label": "which_sh()" + }, + { + "label": "ipc_integration.rs", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_tests_ipc_integration", + "community": 8, + "community_name": "Result", + "norm_label": "ipc_integration.rs" + }, + { + "label": "ping_and_state_dump_work()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L15", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "community": 8, + "community_name": "Result", + "norm_label": "ping_and_state_dump_work()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_result", + "community": 8, + "community_name": "Result", + "norm_label": "result" + }, + { + "label": "unknown_method_returns_error()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L36", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_unknown_method_returns_error", + "community": 8, + "community_name": "Result", + "norm_label": "unknown_method_returns_error()" + }, + { + "label": "profile_activate_updates_state()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L53", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_profile_activate_updates_state", + "community": 8, + "community_name": "Result", + "norm_label": "profile_activate_updates_state()" + }, + { + "label": "profile_activate_without_name_errors()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L78", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "community": 8, + "community_name": "Result", + "norm_label": "profile_activate_without_name_errors()" + }, + { + "label": "emit_without_event_errors()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L92", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_event_errors", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_event_errors()" + }, + { + "label": "emit_without_source_rejects_adapter_owned_event_name()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L104", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_rejects_adapter_owned_event_name()" + }, + { + "label": "emit_without_source_rejects_every_adapter_owned_domain()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L129", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_rejects_every_adapter_owned_domain()" + }, + { + "label": "emit_without_source_still_allows_custom_event_names()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L160", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_still_allows_custom_event_names()" + }, + { + "label": "emit_without_source_is_tagged_manual_not_system()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L184", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_is_tagged_manual_not_system()" + }, + { + "label": "emit_with_internal_source_is_rejected()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L253", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "community": 8, + "community_name": "Result", + "norm_label": "emit_with_internal_source_is_rejected()" + }, + { + "label": "emit_with_unregistered_app_source_is_rejected()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L277", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "community": 8, + "community_name": "Result", + "norm_label": "emit_with_unregistered_app_source_is_rejected()" + }, + { + "label": "emit_with_known_app_source_routes_through_normalizer()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L294", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "community": 8, + "community_name": "Result", + "norm_label": "emit_with_known_app_source_routes_through_normalizer()" + }, + { + "label": "emit_with_app_source_rejects_wrong_namespace()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L357", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "community": 8, + "community_name": "Result", + "norm_label": "emit_with_app_source_rejects_wrong_namespace()" + }, + { + "label": "emit_without_source_allows_well_formed_command_event()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L385", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_allows_well_formed_command_event()" + }, + { + "label": "emit_without_source_rejects_command_to_non_app()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L412", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_rejects_command_to_non_app()" + }, + { + "label": "emit_without_source_still_rejects_hyprland_namespace()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L434", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "community": 8, + "community_name": "Result", + "norm_label": "emit_without_source_still_rejects_hyprland_namespace()" + }, + { + "label": "emit_with_app_source_allows_command_to_another_app()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L454", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "community": 8, + "community_name": "Result", + "norm_label": "emit_with_app_source_allows_command_to_another_app()" + }, + { + "label": "emit_with_app_source_still_rejects_foreign_app_namespace()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L479", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "community": 8, + "community_name": "Result", + "norm_label": "emit_with_app_source_still_rejects_foreign_app_namespace()" + }, + { + "label": "state_get_returns_specific_subtree()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L505", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "community": 8, + "community_name": "Result", + "norm_label": "state_get_returns_specific_subtree()" + }, + { + "label": "state_get_missing_key_returns_error()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L527", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "community": 8, + "community_name": "Result", + "norm_label": "state_get_missing_key_returns_error()" + }, + { + "label": "modules_list_returns_array()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L541", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_modules_list_returns_array", + "community": 8, + "community_name": "Result", + "norm_label": "modules_list_returns_array()" + }, + { + "label": "scoped_module_sees_only_granted_state_read_permission()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L577", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "community": 8, + "community_name": "Result", + "norm_label": "scoped_module_sees_only_granted_state_read_permission()" + }, + { + "label": "module_with_no_manifest_keeps_full_access_but_is_flagged_ungated()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L674", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "community": 8, + "community_name": "Result", + "norm_label": "module_with_no_manifest_keeps_full_access_but_is_flagged_ungated()" + }, + { + "label": "explicit_empty_permissions_is_scoped_but_not_flagged_ungated()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L749", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "community": 8, + "community_name": "Result", + "norm_label": "explicit_empty_permissions_is_scoped_but_not_flagged_ungated()" + }, + { + "label": "modules_reload_succeeds()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L808", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_modules_reload_succeeds", + "community": 8, + "community_name": "Result", + "norm_label": "modules_reload_succeeds()" + }, + { + "label": "daemon_survives_repeated_reloads_and_pipeline_resumes()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L821", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "community": 8, + "community_name": "Result", + "norm_label": "daemon_survives_repeated_reloads_and_pipeline_resumes()" + }, + { + "label": "events_replay_returns_buffered_events()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L871", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "community": 8, + "community_name": "Result", + "norm_label": "events_replay_returns_buffered_events()" + }, + { + "label": "event_stream_filter_excludes_non_matching_events()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L902", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "community": 8, + "community_name": "Result", + "norm_label": "event_stream_filter_excludes_non_matching_events()" + }, + { + "label": "multiple_concurrent_clients_each_get_response()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L955", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "community": 8, + "community_name": "Result", + "norm_label": "multiple_concurrent_clients_each_get_response()" + }, + { + "label": "events_stream_receives_emitted_events()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L989", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "community": 8, + "community_name": "Result", + "norm_label": "events_stream_receives_emitted_events()" + }, + { + "label": "event_causality_chain_threads_caused_by_across_handlers()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1062", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "community": 8, + "community_name": "Result", + "norm_label": "event_causality_chain_threads_caused_by_across_handlers()" + }, + { + "label": "workflow_reaches_done_via_wait_any_happy_path()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1203", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "community": 8, + "community_name": "Result", + "norm_label": "workflow_reaches_done_via_wait_any_happy_path()" + }, + { + "label": "workflow_times_out_when_deadline_exceeded()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1240", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "community": 8, + "community_name": "Result", + "norm_label": "workflow_times_out_when_deadline_exceeded()" + }, + { + "label": "workflow_captures_error_on_failure()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1268", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "community": 8, + "community_name": "Result", + "norm_label": "workflow_captures_error_on_failure()" + }, + { + "label": "rules_toml_absent_is_a_no_op()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1299", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "community": 8, + "community_name": "Result", + "norm_label": "rules_toml_absent_is_a_no_op()" + }, + { + "label": "rules_toml_well_formed_all_action_kinds_work_end_to_end()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1329", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "community": 8, + "community_name": "Result", + "norm_label": "rules_toml_well_formed_all_action_kinds_work_end_to_end()" + }, + { + "label": "rules_toml_malformed_rule_surfaces_doctor_visible_error()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1447", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "community": 8, + "community_name": "Result", + "norm_label": "rules_toml_malformed_rule_surfaces_doctor_visible_error()" + }, + { + "label": "wait_for_file()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1502", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_wait_for_file", + "community": 8, + "community_name": "Result", + "norm_label": "wait_for_file()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_path", + "community": 8, + "community_name": "Result", + "norm_label": "path" + }, + { + "label": "poll_workflow_status()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1518", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_poll_workflow_status", + "community": 8, + "community_name": "Result", + "norm_label": "poll_workflow_status()" + }, + { + "label": "TestHarness", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "testharness", + "community": 8, + "community_name": "Result", + "norm_label": "testharness" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_value", + "community": 8, + "community_name": "Result", + "norm_label": "value" + }, + { + "label": "TestHarness", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1543", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness", + "community": 8, + "community_name": "Result", + "norm_label": "testharness" + }, + { + "label": "TempDir", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_tempdir", + "community": 8, + "community_name": "Result", + "norm_label": "tempdir" + }, + { + "label": "Child", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_child", + "community": 8, + "community_name": "Result", + "norm_label": "child" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_pathbuf", + "community": 8, + "community_name": "Result", + "norm_label": "pathbuf" + }, + { + "label": ".spawn()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1550", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_spawn", + "community": 8, + "community_name": "Result", + "norm_label": ".spawn()" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_self", + "community": 8, + "community_name": "Result", + "norm_label": "self" + }, + { + "label": ".spawn_with_init()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1554", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "community": 8, + "community_name": "Result", + "norm_label": ".spawn_with_init()" + }, + { + "label": ".spawn_with_init_and_rules()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1562", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "community": 8, + "community_name": "Result", + "norm_label": ".spawn_with_init_and_rules()" + }, + { + "label": "Option", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_option", + "community": 8, + "community_name": "Result", + "norm_label": "option" + }, + { + "label": ".spawn_with_module()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1630", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "community": 8, + "community_name": "Result", + "norm_label": ".spawn_with_module()" + }, + { + "label": ".socket_path()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1703", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_socket_path", + "community": 8, + "community_name": "Result", + "norm_label": ".socket_path()" + }, + { + "label": ".wait_until_ready()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1707", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "community": 8, + "community_name": "Result", + "norm_label": ".wait_until_ready()" + }, + { + "label": ".send_request()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1722", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_send_request", + "community": 8, + "community_name": "Result", + "norm_label": ".send_request()" + }, + { + "label": ".wait_for_module_loaded()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1757", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "community": 8, + "community_name": "Result", + "norm_label": ".wait_for_module_loaded()" + }, + { + "label": ".trigger_and_await_result()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1794", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "community": 8, + "community_name": "Result", + "norm_label": ".trigger_and_await_result()" + }, + { + "label": ".shutdown()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1822", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_shutdown", + "community": 8, + "community_name": "Result", + "norm_label": ".shutdown()" + }, + { + "label": "Drop", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_rs_drop", + "community": 8, + "community_name": "Result", + "norm_label": "drop" + }, + { + "label": ".drop()", + "file_type": "code", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1840", + "_origin": "ast", + "id": "breadd_tests_ipc_integration_testharness_drop", + "community": 8, + "community_name": "Result", + "norm_label": ".drop()" + }, + { + "label": "module_host_sandbox.rs", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L1", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox", + "community": 30, + "community_name": "TestHarness", + "norm_label": "module_host_sandbox.rs" + }, + { + "label": "TestHarness", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L47", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness", + "community": 30, + "community_name": "TestHarness", + "norm_label": "testharness" + }, + { + "label": "TempDir", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_tempdir", + "community": 30, + "community_name": "TestHarness", + "norm_label": "tempdir" + }, + { + "label": "Child", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_child", + "community": 30, + "community_name": "TestHarness", + "norm_label": "child" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_pathbuf", + "community": 30, + "community_name": "TestHarness", + "norm_label": "pathbuf" + }, + { + "label": ".spawn_with_modules()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L60", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_spawn_with_modules", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".spawn_with_modules()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_result", + "community": 30, + "community_name": "TestHarness", + "norm_label": "result" + }, + { + "label": "Self", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_self", + "community": 30, + "community_name": "TestHarness", + "norm_label": "self" + }, + { + "label": ".socket_path()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L133", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_socket_path", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".socket_path()" + }, + { + "label": "Path", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_path", + "community": 30, + "community_name": "TestHarness", + "norm_label": "path" + }, + { + "label": ".wait_until_ready()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L137", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_wait_until_ready", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".wait_until_ready()" + }, + { + "label": ".wait_for_module_loaded()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L156", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_wait_for_module_loaded", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".wait_for_module_loaded()" + }, + { + "label": ".send_request()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L183", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_send_request", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".send_request()" + }, + { + "label": "Value", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_value", + "community": 30, + "community_name": "TestHarness", + "norm_label": "value" + }, + { + "label": ".find_module_host_pid()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L212", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_find_module_host_pid", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".find_module_host_pid()" + }, + { + "label": ".shutdown()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L244", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_shutdown", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".shutdown()" + }, + { + "label": "Drop", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_rs_drop", + "community": 30, + "community_name": "TestHarness", + "norm_label": "drop" + }, + { + "label": ".drop()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L260", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_testharness_drop", + "community": 30, + "community_name": "TestHarness", + "norm_label": ".drop()" + }, + { + "label": "os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L291", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "community": 30, + "community_name": "TestHarness", + "norm_label": "os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope()" + }, + { + "label": "killing_a_module_host_child_does_not_take_down_breadd_or_other_modules()", + "file_type": "code", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L438", + "_origin": "ast", + "id": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "community": 30, + "community_name": "TestHarness", + "norm_label": "killing_a_module_host_child_does_not_take_down_breadd_or_other_modules()" + }, + { + "label": "build.sh", + "file_type": "code", + "source_file": "ci/build.sh", + "source_location": "L1", + "metadata": { + "language": "bash", + "kind": "file" + }, + "_origin": "ast", + "id": "ci_build", + "community": 89, + "community_name": "build.sh", + "norm_label": "build.sh" + }, + { + "label": "build.sh script", + "file_type": "code", + "source_file": "ci/build.sh", + "source_location": "L1", + "metadata": { + "language": "bash", + "kind": "bash_entrypoint" + }, + "_origin": "ast", + "id": "ci_build_sh__entry", + "community": 89, + "community_name": "build.sh", + "norm_label": "build.sh script" + }, + { + "label": "active-window-widget.lua", + "file_type": "code", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_active_window_widget", + "community": 32, + "community_name": "active-window-widget.lua", + "norm_label": "active-window-widget.lua" + }, + { + "label": "label_for()", + "file_type": "code", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L14", + "_origin": "ast", + "id": "examples_modules_active_window_widget_label_for", + "community": 32, + "community_name": "active-window-widget.lua", + "norm_label": "label_for()" + }, + { + "label": "widget_root()", + "file_type": "code", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L29", + "_origin": "ast", + "id": "examples_modules_active_window_widget_widget_root", + "community": 32, + "community_name": "active-window-widget.lua", + "norm_label": "widget_root()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L33", + "_origin": "ast", + "id": "examples_modules_active_window_widget_m_on_load", + "community": 32, + "community_name": "active-window-widget.lua", + "norm_label": "m.on_load()" + }, + { + "label": "bluetooth-toggle-widget.lua", + "file_type": "code", + "source_file": "examples/modules/bluetooth-toggle-widget.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_bluetooth_toggle_widget", + "community": 37, + "community_name": "bluetooth-toggle-widget.lua", + "norm_label": "bluetooth-toggle-widget.lua" + }, + { + "label": "widget_root()", + "file_type": "code", + "source_file": "examples/modules/bluetooth-toggle-widget.lua", + "source_location": "L14", + "_origin": "ast", + "id": "examples_modules_bluetooth_toggle_widget_widget_root", + "community": 37, + "community_name": "bluetooth-toggle-widget.lua", + "norm_label": "widget_root()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/bluetooth-toggle-widget.lua", + "source_location": "L43", + "_origin": "ast", + "id": "examples_modules_bluetooth_toggle_widget_m_on_load", + "community": 37, + "community_name": "bluetooth-toggle-widget.lua", + "norm_label": "m.on_load()" + }, + { + "label": "init.lua", + "file_type": "code", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_cpu_temp_widget_init", + "community": 85, + "community_name": "init.lua", + "norm_label": "init.lua" + }, + { + "label": "read_temp_c()", + "file_type": "code", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L32", + "_origin": "ast", + "id": "examples_modules_cpu_temp_widget_init_read_temp_c", + "community": 85, + "community_name": "init.lua", + "norm_label": "read_temp_c()" + }, + { + "label": "widget_root()", + "file_type": "code", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L40", + "_origin": "ast", + "id": "examples_modules_cpu_temp_widget_init_widget_root", + "community": 85, + "community_name": "init.lua", + "norm_label": "widget_root()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L60", + "_origin": "ast", + "id": "examples_modules_cpu_temp_widget_init_m_on_load", + "community": 85, + "community_name": "init.lua", + "norm_label": "m.on_load()" + }, + { + "label": "dock-monitors.lua", + "file_type": "code", + "source_file": "examples/modules/dock-monitors.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_dock_monitors", + "community": 40, + "community_name": "dock-monitors.lua", + "norm_label": "dock-monitors.lua" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/dock-monitors.lua", + "source_location": "L21", + "_origin": "ast", + "id": "examples_modules_dock_monitors_m_on_load", + "community": 40, + "community_name": "dock-monitors.lua", + "norm_label": "m.on_load()" + }, + { + "label": "dock-workflow.lua", + "file_type": "code", + "source_file": "examples/modules/dock-workflow.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_dock_workflow", + "community": 41, + "community_name": "dock-workflow.lua", + "norm_label": "dock-workflow.lua" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/dock-workflow.lua", + "source_location": "L44", + "_origin": "ast", + "id": "examples_modules_dock_workflow_m_on_load", + "community": 41, + "community_name": "dock-workflow.lua", + "norm_label": "m.on_load()" + }, + { + "label": "external-monitors.lua", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_external_monitors", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "external-monitors.lua" + }, + { + "label": "inhibit_lid()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L28", + "_origin": "ast", + "id": "examples_modules_external_monitors_inhibit_lid", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "inhibit_lid()" + }, + { + "label": "release_lid()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L38", + "_origin": "ast", + "id": "examples_modules_external_monitors_release_lid", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "release_lid()" + }, + { + "label": "is_internal()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L44", + "_origin": "ast", + "id": "examples_modules_external_monitors_is_internal", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "is_internal()" + }, + { + "label": "drm_status()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L48", + "_origin": "ast", + "id": "examples_modules_external_monitors_drm_status", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "drm_status()" + }, + { + "label": "drm_first_mode()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L58", + "_origin": "ast", + "id": "examples_modules_external_monitors_drm_first_mode", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "drm_first_mode()" + }, + { + "label": "list_connectors()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L71", + "_origin": "ast", + "id": "examples_modules_external_monitors_list_connectors", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "list_connectors()" + }, + { + "label": "connected()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L87", + "_origin": "ast", + "id": "examples_modules_external_monitors_connected", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "connected()" + }, + { + "label": "apply_monitor()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L103", + "_origin": "ast", + "id": "examples_modules_external_monitors_apply_monitor", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "apply_monitor()" + }, + { + "label": "apply()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L132", + "_origin": "ast", + "id": "examples_modules_external_monitors_apply", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "apply()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L166", + "_origin": "ast", + "id": "examples_modules_external_monitors_m_on_load", + "community": 61, + "community_name": "external-monitors.lua", + "norm_label": "m.on_load()" + }, + { + "label": "focus-mode-widget.lua", + "file_type": "code", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_focus_mode_widget", + "community": 34, + "community_name": "focus-mode-widget.lua", + "norm_label": "focus-mode-widget.lua" + }, + { + "label": "is_focused()", + "file_type": "code", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L22", + "_origin": "ast", + "id": "examples_modules_focus_mode_widget_is_focused", + "community": 34, + "community_name": "focus-mode-widget.lua", + "norm_label": "is_focused()" + }, + { + "label": "widget_root()", + "file_type": "code", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L26", + "_origin": "ast", + "id": "examples_modules_focus_mode_widget_widget_root", + "community": 34, + "community_name": "focus-mode-widget.lua", + "norm_label": "widget_root()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L35", + "_origin": "ast", + "id": "examples_modules_focus_mode_widget_m_on_load", + "community": 34, + "community_name": "focus-mode-widget.lua", + "norm_label": "m.on_load()" + }, + { + "label": "git-branch-widget.lua", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_git_branch_widget", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "git-branch-widget.lua" + }, + { + "label": "shell_quote()", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L41", + "_origin": "ast", + "id": "examples_modules_git_branch_widget_shell_quote", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "shell_quote()" + }, + { + "label": "focused_tab_cwd()", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L50", + "_origin": "ast", + "id": "examples_modules_git_branch_widget_focused_tab_cwd", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "focused_tab_cwd()" + }, + { + "label": "git_info()", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L88", + "_origin": "ast", + "id": "examples_modules_git_branch_widget_git_info", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "git_info()" + }, + { + "label": "widget_root()", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L111", + "_origin": "ast", + "id": "examples_modules_git_branch_widget_widget_root", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "widget_root()" + }, + { + "label": "update()", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L122", + "_origin": "ast", + "id": "examples_modules_git_branch_widget_update", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "update()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L133", + "_origin": "ast", + "id": "examples_modules_git_branch_widget_m_on_load", + "community": 29, + "community_name": "git-branch-widget.lua", + "norm_label": "m.on_load()" + }, + { + "label": "low-battery-warning.lua", + "file_type": "code", + "source_file": "examples/modules/low-battery-warning.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_low_battery_warning", + "community": 42, + "community_name": "low-battery-warning.lua", + "norm_label": "low-battery-warning.lua" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/low-battery-warning.lua", + "source_location": "L11", + "_origin": "ast", + "id": "examples_modules_low_battery_warning_m_on_load", + "community": 42, + "community_name": "low-battery-warning.lua", + "norm_label": "m.on_load()" + }, + { + "label": "pause-media-on-headphone-unplug.lua", + "file_type": "code", + "source_file": "examples/modules/pause-media-on-headphone-unplug.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_pause_media_on_headphone_unplug", + "community": 38, + "community_name": "pause-media-on-headphone-unplug.lua", + "norm_label": "pause-media-on-headphone-unplug.lua" + }, + { + "label": "looks_like_headphones()", + "file_type": "code", + "source_file": "examples/modules/pause-media-on-headphone-unplug.lua", + "source_location": "L8", + "_origin": "ast", + "id": "examples_modules_pause_media_on_headphone_unplug_looks_like_headphones", + "community": 38, + "community_name": "pause-media-on-headphone-unplug.lua", + "norm_label": "looks_like_headphones()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/pause-media-on-headphone-unplug.lua", + "source_location": "L17", + "_origin": "ast", + "id": "examples_modules_pause_media_on_headphone_unplug_m_on_load", + "community": 38, + "community_name": "pause-media-on-headphone-unplug.lua", + "norm_label": "m.on_load()" + }, + { + "label": "workflow-status-widget.lua", + "file_type": "code", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_workflow_status_widget", + "community": 35, + "community_name": "workflow-status-widget.lua", + "norm_label": "workflow-status-widget.lua" + }, + { + "label": "most_relevant()", + "file_type": "code", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L20", + "_origin": "ast", + "id": "examples_modules_workflow_status_widget_most_relevant", + "community": 35, + "community_name": "workflow-status-widget.lua", + "norm_label": "most_relevant()" + }, + { + "label": "widget_update()", + "file_type": "code", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L31", + "_origin": "ast", + "id": "examples_modules_workflow_status_widget_widget_update", + "community": 35, + "community_name": "workflow-status-widget.lua", + "norm_label": "widget_update()" + }, + { + "label": "M.on_load()", + "file_type": "code", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L63", + "_origin": "ast", + "id": "examples_modules_workflow_status_widget_m_on_load", + "community": 35, + "community_name": "workflow-status-widget.lua", + "norm_label": "m.on_load()" + }, + { + "label": "install.sh", + "file_type": "code", + "source_file": "scripts/install.sh", + "source_location": "L1", + "metadata": { + "language": "bash", + "kind": "file" + }, + "_origin": "ast", + "id": "scripts_install", + "community": 43, + "community_name": "install.sh", + "norm_label": "install.sh" + }, + { + "label": "install.sh script", + "file_type": "code", + "source_file": "scripts/install.sh", + "source_location": "L1", + "metadata": { + "language": "bash", + "kind": "bash_entrypoint" + }, + "_origin": "ast", + "id": "scripts_install_sh__entry", + "community": 43, + "community_name": "install.sh", + "norm_label": "install.sh script" + }, + { + "label": "xtask/src/main.rs", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L1", + "_origin": "ast", + "id": "xtask_src_main", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "xtask/src/main.rs" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L27", + "_origin": "ast", + "id": "xtask_src_main_main", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "main()" + }, + { + "label": "ExitCode", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "exitcode", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "exitcode" + }, + { + "label": "usage()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L49", + "_origin": "ast", + "id": "xtask_src_main_usage", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "usage()" + }, + { + "label": "run_check_docs()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L55", + "_origin": "ast", + "id": "xtask_src_main_run_check_docs", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "run_check_docs()" + }, + { + "label": "Result", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "xtask_src_main_rs_result", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "result" + }, + { + "label": "repo_root()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L76", + "_origin": "ast", + "id": "xtask_src_main_repo_root", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "repo_root()" + }, + { + "label": "PathBuf", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "xtask_src_main_rs_pathbuf", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "pathbuf" + }, + { + "label": "Schema", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L90", + "_origin": "ast", + "id": "xtask_src_main_schema", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "schema" + }, + { + "label": "Vec", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "xtask_src_main_rs_vec", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "vec" + }, + { + "label": "SchemaEntry", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L96", + "_origin": "ast", + "id": "xtask_src_main_schemaentry", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "schemaentry" + }, + { + "label": "String", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "xtask_src_main_rs_string", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "string" + }, + { + "label": "ident_at()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L143", + "_origin": "ast", + "id": "xtask_src_main_ident_at", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "ident_at()" + }, + { + "label": "ident_upto_quote()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L152", + "_origin": "ast", + "id": "xtask_src_main_ident_upto_quote", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "ident_upto_quote()" + }, + { + "label": "extract_lua_bindings()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L158", + "_origin": "ast", + "id": "xtask_src_main_extract_lua_bindings", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extract_lua_bindings()" + }, + { + "label": "BTreeSet", + "file_type": "code", + "source_file": "", + "source_location": "", + "_origin": "ast", + "id": "btreeset", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "btreeset" + }, + { + "label": "extract_ipc_methods()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L230", + "_origin": "ast", + "id": "xtask_src_main_extract_ipc_methods", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extract_ipc_methods()" + }, + { + "label": "kebab()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L295", + "_origin": "ast", + "id": "xtask_src_main_kebab", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "kebab()" + }, + { + "label": "extract_enum_variants()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L315", + "_origin": "ast", + "id": "xtask_src_main_extract_enum_variants", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extract_enum_variants()" + }, + { + "label": "extract_cli_commands()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L346", + "_origin": "ast", + "id": "xtask_src_main_extract_cli_commands", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extract_cli_commands()" + }, + { + "label": "section()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L366", + "_origin": "ast", + "id": "xtask_src_main_section", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "section()" + }, + { + "label": "lua_api_section()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L377", + "_origin": "ast", + "id": "xtask_src_main_lua_api_section", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "lua_api_section()" + }, + { + "label": "ipc_section()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L381", + "_origin": "ast", + "id": "xtask_src_main_ipc_section", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "ipc_section()" + }, + { + "label": "readme_cli_section()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L388", + "_origin": "ast", + "id": "xtask_src_main_readme_cli_section", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "readme_cli_section()" + }, + { + "label": "CheckReport", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L396", + "_origin": "ast", + "id": "xtask_src_main_checkreport", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "checkreport" + }, + { + "label": ".is_clean()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L414", + "_origin": "ast", + "id": "xtask_src_main_checkreport_is_clean", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": ".is_clean()" + }, + { + "label": ".print()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L423", + "_origin": "ast", + "id": "xtask_src_main_checkreport_print", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": ".print()" + }, + { + "label": "check()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L481", + "_origin": "ast", + "id": "xtask_src_main_check", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "check()" + }, + { + "label": "schema_toml_for()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L694", + "_origin": "ast", + "id": "xtask_src_main_schema_toml_for", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "schema_toml_for()" + }, + { + "label": "full_schema()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L704", + "_origin": "ast", + "id": "xtask_src_main_full_schema", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "full_schema()" + }, + { + "label": "extracts_lua_bindings_precisely()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L724", + "_origin": "ast", + "id": "xtask_src_main_extracts_lua_bindings_precisely", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extracts_lua_bindings_precisely()" + }, + { + "label": "extracts_ipc_methods_without_leaking_nested_match_arms()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L743", + "_origin": "ast", + "id": "xtask_src_main_extracts_ipc_methods_without_leaking_nested_match_arms", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extracts_ipc_methods_without_leaking_nested_match_arms()" + }, + { + "label": "clean_state_passes()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L756", + "_origin": "ast", + "id": "xtask_src_main_clean_state_passes", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "clean_state_passes()" + }, + { + "label": "renamed_schema_entry_is_caught_as_drift()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L762", + "_origin": "ast", + "id": "xtask_src_main_renamed_schema_entry_is_caught_as_drift", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "renamed_schema_entry_is_caught_as_drift()" + }, + { + "label": "removed_ipc_method_is_caught_as_drift()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L786", + "_origin": "ast", + "id": "xtask_src_main_removed_ipc_method_is_caught_as_drift", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "removed_ipc_method_is_caught_as_drift()" + }, + { + "label": "missing_doc_heading_is_caught_as_drift()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L804", + "_origin": "ast", + "id": "xtask_src_main_missing_doc_heading_is_caught_as_drift", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "missing_doc_heading_is_caught_as_drift()" + }, + { + "label": "unknown_kind_is_rejected()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L822", + "_origin": "ast", + "id": "xtask_src_main_unknown_kind_is_rejected", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "unknown_kind_is_rejected()" + }, + { + "label": "kebab_converts_pascal_case_correctly()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L832", + "_origin": "ast", + "id": "xtask_src_main_kebab_converts_pascal_case_correctly", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "kebab_converts_pascal_case_correctly()" + }, + { + "label": "extracts_cli_commands_with_subcommand_groups_dotted()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L839", + "_origin": "ast", + "id": "xtask_src_main_extracts_cli_commands_with_subcommand_groups_dotted", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "extracts_cli_commands_with_subcommand_groups_dotted()" + }, + { + "label": "renamed_cli_command_is_caught_as_drift()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L852", + "_origin": "ast", + "id": "xtask_src_main_renamed_cli_command_is_caught_as_drift", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "renamed_cli_command_is_caught_as_drift()" + }, + { + "label": "missing_readme_cli_line_is_caught_as_drift()", + "file_type": "code", + "source_file": "xtask/src/main.rs", + "source_location": "L875", + "_origin": "ast", + "id": "xtask_src_main_missing_readme_cli_line_is_caught_as_drift", + "community": 66, + "community_name": "xtask/src/main.rs", + "norm_label": "missing_readme_cli_line_is_caught_as_drift()" + }, + { + "label": "AGENTS.md", + "file_type": "document", + "source_file": "AGENTS.md", + "source_location": "L1", + "_origin": "ast", + "id": "agents", + "community": 62, + "community_name": "AGENTS.md \u2014 Repo hygiene", + "norm_label": "agents.md" + }, + { + "label": "AGENTS.md \u2014 Repo hygiene", + "file_type": "document", + "source_file": "AGENTS.md", + "source_location": "L1", + "_origin": "ast", + "id": "agents_agents_md_repo_hygiene", + "community": 62, + "community_name": "AGENTS.md \u2014 Repo hygiene", + "norm_label": "agents.md \u2014 repo hygiene" + }, + { + "label": "Remotes", + "file_type": "document", + "source_file": "AGENTS.md", + "source_location": "L16", + "_origin": "ast", + "id": "agents_remotes", + "community": 62, + "community_name": "AGENTS.md \u2014 Repo hygiene", + "norm_label": "remotes" + }, + { + "label": "CI", + "file_type": "document", + "source_file": "AGENTS.md", + "source_location": "L22", + "_origin": "ast", + "id": "agents_ci", + "community": 62, + "community_name": "AGENTS.md \u2014 Repo hygiene", + "norm_label": "ci" + }, + { + "label": "Local architecture (still true)", + "file_type": "document", + "source_file": "AGENTS.md", + "source_location": "L31", + "_origin": "ast", + "id": "agents_local_architecture_still_true", + "community": 62, + "community_name": "AGENTS.md \u2014 Repo hygiene", + "norm_label": "local architecture (still true)" + }, + { + "label": "Don't", + "file_type": "document", + "source_file": "AGENTS.md", + "source_location": "L39", + "_origin": "ast", + "id": "agents_don_t", + "community": 62, + "community_name": "AGENTS.md \u2014 Repo hygiene", + "norm_label": "don't" + }, + { + "label": "CLAUDE.md", + "file_type": "document", + "source_file": "CLAUDE.md", + "source_location": "L1", + "_origin": "ast", + "id": "claude", + "community": 63, + "community_name": "CLAUDE.md \u2014 Repo hygiene", + "norm_label": "claude.md" + }, + { + "label": "CLAUDE.md \u2014 Repo hygiene", + "file_type": "document", + "source_file": "CLAUDE.md", + "source_location": "L1", + "_origin": "ast", + "id": "claude_claude_md_repo_hygiene", + "community": 63, + "community_name": "CLAUDE.md \u2014 Repo hygiene", + "norm_label": "claude.md \u2014 repo hygiene" + }, + { + "label": "Remotes", + "file_type": "document", + "source_file": "CLAUDE.md", + "source_location": "L10", + "_origin": "ast", + "id": "claude_remotes", + "community": 63, + "community_name": "CLAUDE.md \u2014 Repo hygiene", + "norm_label": "remotes" + }, + { + "label": "CI", + "file_type": "document", + "source_file": "CLAUDE.md", + "source_location": "L14", + "_origin": "ast", + "id": "claude_ci", + "community": 63, + "community_name": "CLAUDE.md \u2014 Repo hygiene", + "norm_label": "ci" + }, + { + "label": "Don't", + "file_type": "document", + "source_file": "CLAUDE.md", + "source_location": "L19", + "_origin": "ast", + "id": "claude_don_t", + "community": 63, + "community_name": "CLAUDE.md \u2014 Repo hygiene", + "norm_label": "don't" + }, + { + "label": "DEPRECATIONS.md", + "file_type": "document", + "source_file": "DEPRECATIONS.md", + "source_location": "L1", + "_origin": "ast", + "id": "deprecations", + "community": 67, + "community_name": "Bread", + "norm_label": "deprecations.md" + }, + { + "label": "Deprecations", + "file_type": "document", + "source_file": "DEPRECATIONS.md", + "source_location": "L1", + "_origin": "ast", + "id": "deprecations_deprecations", + "community": 67, + "community_name": "Bread", + "norm_label": "deprecations" + }, + { + "label": "Hyprland legacy flat event names (since v1.5)", + "file_type": "document", + "source_file": "DEPRECATIONS.md", + "source_location": "L8", + "_origin": "ast", + "id": "deprecations_hyprland_legacy_flat_event_names_since_v1_5", + "community": 67, + "community_name": "Bread", + "norm_label": "hyprland legacy flat event names (since v1.5)" + }, + { + "label": "modules/README.md", + "file_type": "document", + "source_file": "examples/modules/README.md", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_readme", + "community": 67, + "community_name": "Bread", + "norm_label": "modules/readme.md" + }, + { + "label": "Example bread modules", + "file_type": "document", + "source_file": "examples/modules/README.md", + "source_location": "L1", + "_origin": "ast", + "id": "examples_modules_readme_example_bread_modules", + "community": 67, + "community_name": "Bread", + "norm_label": "example bread modules" + }, + { + "label": "Installing", + "file_type": "document", + "source_file": "examples/modules/README.md", + "source_location": "L7", + "_origin": "ast", + "id": "examples_modules_readme_installing", + "community": 67, + "community_name": "Bread", + "norm_label": "installing" + }, + { + "label": "Modules", + "file_type": "document", + "source_file": "examples/modules/README.md", + "source_location": "L33", + "_origin": "ast", + "id": "examples_modules_readme_modules", + "community": 67, + "community_name": "Bread", + "norm_label": "modules" + }, + { + "label": "packaging/README.md", + "file_type": "document", + "source_file": "packaging/README.md", + "source_location": "L1", + "_origin": "ast", + "id": "packaging_readme", + "community": 87, + "community_name": "packaging/README.md", + "norm_label": "packaging/readme.md" + }, + { + "label": "systemd user service", + "file_type": "document", + "source_file": "packaging/README.md", + "source_location": "L17", + "_origin": "ast", + "id": "packaging_readme_systemd_user_service", + "community": 87, + "community_name": "packaging/README.md", + "norm_label": "systemd user service" + }, + { + "label": "CONTRIBUTING.md", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L1", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "contributing.md", + "id": "contributing" + }, + { + "label": "Contributing", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L1", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "contributing", + "id": "contributing_contributing" + }, + { + "label": "Branches", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L8", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "branches", + "id": "contributing_branches" + }, + { + "label": "The release cycle", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L26", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "the release cycle", + "id": "contributing_the_release_cycle" + }, + { + "label": "Tracks, from a user's perspective", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L43", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "tracks, from a user's perspective", + "id": "contributing_tracks_from_a_user_s_perspective" + }, + { + "label": "Local development", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L63", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "local development", + "id": "contributing_local_development" + }, + { + "label": "Keeping the API docs honest", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L70", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "keeping the api docs honest", + "id": "contributing_keeping_the_api_docs_honest" + }, + { + "label": "CI", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L94", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "ci", + "id": "contributing_ci" + }, + { + "label": "Questions", + "file_type": "document", + "source_file": "CONTRIBUTING.md", + "source_location": "L106", + "_origin": "ast", + "community": 77, + "community_name": "Contributing", + "norm_label": "questions", + "id": "contributing_questions" + }, + { + "label": "Documentation.md", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "documentation.md", + "id": "documentation" + }, + { + "label": "Bread Documentation", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "bread documentation", + "id": "documentation_bread_documentation" + }, + { + "label": "Contents", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L3", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "contents", + "id": "documentation_contents" + }, + { + "label": "Overview", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L25", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "overview", + "id": "documentation_overview" + }, + { + "label": "API Stability & Versioning", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L37", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "api stability & versioning", + "id": "documentation_api_stability_versioning" + }, + { + "label": "Getting started", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L48", + "_origin": "ast", + "community": 80, + "community_name": "Getting started", + "norm_label": "getting started", + "id": "documentation_getting_started" + }, + { + "label": "1) Create a minimal config", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L50", + "_origin": "ast", + "community": 80, + "community_name": "Getting started", + "norm_label": "1) create a minimal config", + "id": "documentation_1_create_a_minimal_config" + }, + { + "label": "2) The fast path: `rules.toml` *(Since: v1.5)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L57", + "_origin": "ast", + "community": 80, + "community_name": "Getting started", + "norm_label": "2) the fast path: `rules.toml` *(since: v1.5)*", + "id": "documentation_2_the_fast_path_rules_toml_since_v1_5" + }, + { + "label": "3) Minimal `init.lua`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L102", + "_origin": "ast", + "community": 80, + "community_name": "Getting started", + "norm_label": "3) minimal `init.lua`", + "id": "documentation_3_minimal_init_lua" + }, + { + "label": "4) Start the daemon", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L111", + "_origin": "ast", + "community": 80, + "community_name": "Getting started", + "norm_label": "4) start the daemon", + "id": "documentation_4_start_the_daemon" + }, + { + "label": "5) Check that it's running", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L120", + "_origin": "ast", + "community": 80, + "community_name": "Getting started", + "norm_label": "5) check that it's running", + "id": "documentation_5_check_that_it_s_running" + }, + { + "label": "Your first module", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L127", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "your first module", + "id": "documentation_your_first_module" + }, + { + "label": "Run, reload, and watch", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L157", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "run, reload, and watch", + "id": "documentation_run_reload_and_watch" + }, + { + "label": "Modules: install and manage", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L169", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "modules: install and manage", + "id": "documentation_modules_install_and_manage" + }, + { + "label": "Capability-scoped modules *(Since: v1.5)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L223", + "_origin": "ast", + "community": 81, + "community_name": "Capability-scoped modules *(Since: v1.5)*", + "norm_label": "capability-scoped modules *(since: v1.5)*", + "id": "documentation_capability_scoped_modules_since_v1_5" + }, + { + "label": "Baseline (always available, no manifest entry needed)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L241", + "_origin": "ast", + "community": 81, + "community_name": "Capability-scoped modules *(Since: v1.5)*", + "norm_label": "baseline (always available, no manifest entry needed)", + "id": "documentation_baseline_always_available_no_manifest_entry_needed" + }, + { + "label": "Gated \u2014 requires a matching `[[permissions]]` entry", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L251", + "_origin": "ast", + "community": 81, + "community_name": "Capability-scoped modules *(Since: v1.5)*", + "norm_label": "gated \u2014 requires a matching `[[permissions]]` entry", + "id": "documentation_gated_requires_a_matching_permissions_entry" + }, + { + "label": "`path`/`bin` enforcement depends on where the module runs", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L296", + "_origin": "ast", + "community": 81, + "community_name": "Capability-scoped modules *(Since: v1.5)*", + "norm_label": "`path`/`bin` enforcement depends on where the module runs", + "id": "documentation_path_bin_enforcement_depends_on_where_the_module_runs" + }, + { + "label": "`require(\"bread.devices\")` still works from a scoped module", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L317", + "_origin": "ast", + "community": 81, + "community_name": "Capability-scoped modules *(Since: v1.5)*", + "norm_label": "`require(\"bread.devices\")` still works from a scoped module", + "id": "documentation_require_bread_devices_still_works_from_a_scoped_module" + }, + { + "label": "`bread modules audit `", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L334", + "_origin": "ast", + "community": 81, + "community_name": "Capability-scoped modules *(Since: v1.5)*", + "norm_label": "`bread modules audit `", + "id": "documentation_bread_modules_audit_name" + }, + { + "label": "Out-of-process module sandboxing *(Since: v1.6)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L351", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "out-of-process module sandboxing *(since: v1.6)*", + "id": "documentation_out_of_process_module_sandboxing_since_v1_6" + }, + { + "label": "The gap this closes", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L353", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "the gap this closes", + "id": "documentation_the_gap_this_closes" + }, + { + "label": "What still runs in-process", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L372", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "what still runs in-process", + "id": "documentation_what_still_runs_in_process" + }, + { + "label": "Architecture", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L387", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "architecture", + "id": "documentation_architecture" + }, + { + "label": "The token/identity handshake", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L424", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "the token/identity handshake", + "id": "documentation_the_token_identity_handshake" + }, + { + "label": "The Landlock sandbox", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L450", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "the landlock sandbox", + "id": "documentation_the_landlock_sandbox" + }, + { + "label": "RPC bridge coverage", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L521", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "rpc bridge coverage", + "id": "documentation_rpc_bridge_coverage" + }, + { + "label": "Crash isolation", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L564", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "crash isolation", + "id": "documentation_crash_isolation" + }, + { + "label": "New IPC methods", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L583", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "new ipc methods", + "id": "documentation_new_ipc_methods" + }, + { + "label": "What's implemented vs. deferred", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L592", + "_origin": "ast", + "community": 73, + "community_name": "Out-of-process module sandboxing *(Since: v1.6)*", + "norm_label": "what's implemented vs. deferred", + "id": "documentation_what_s_implemented_vs_deferred" + }, + { + "label": "Debugging tips", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L638", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "debugging tips", + "id": "documentation_debugging_tips" + }, + { + "label": "Dictionary: Lua API", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L651", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "dictionary: lua api", + "id": "documentation_dictionary_lua_api" + }, + { + "label": "Module declaration", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L655", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "module declaration", + "id": "documentation_module_declaration" + }, + { + "label": "Events", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L671", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "events", + "id": "documentation_events" + }, + { + "label": "`bread.on(pattern, fn) -> id`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L673", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.on(pattern, fn) -> id`", + "id": "documentation_bread_on_pattern_fn_id" + }, + { + "label": "`bread.once(pattern, fn) -> id`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L685", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.once(pattern, fn) -> id`", + "id": "documentation_bread_once_pattern_fn_id" + }, + { + "label": "`bread.filter(pattern, fn, opts) -> id`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L688", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.filter(pattern, fn, opts) -> id`", + "id": "documentation_bread_filter_pattern_fn_opts_id" + }, + { + "label": "`bread.off(id)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L701", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.off(id)`", + "id": "documentation_bread_off_id" + }, + { + "label": "`bread.emit(event, data)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L704", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.emit(event, data)`", + "id": "documentation_bread_emit_event_data" + }, + { + "label": "`bread.wait(pattern, opts) -> event | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L707", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.wait(pattern, opts) -> event | nil`", + "id": "documentation_bread_wait_pattern_opts_event_nil" + }, + { + "label": "`bread.spawn(fn)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L719", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.spawn(fn)`", + "id": "documentation_bread_spawn_fn" + }, + { + "label": "`bread.wait_any(patterns, opts) -> event | nil` *(Since: v1.2)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L722", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.wait_any(patterns, opts) -> event | nil` *(since: v1.2)*", + "id": "documentation_bread_wait_any_patterns_opts_event_nil_since_v1_2" + }, + { + "label": "`bread.wait_all(patterns, opts) -> table` *(Since: v1.2)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L737", + "_origin": "ast", + "community": 75, + "community_name": "Events", + "norm_label": "`bread.wait_all(patterns, opts) -> table` *(since: v1.2)*", + "id": "documentation_bread_wait_all_patterns_opts_table_since_v1_2" + }, + { + "label": "Workflows *(Since: v1.2)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L740", + "_origin": "ast", + "community": 82, + "community_name": "Workflows *(Since: v1.2)*", + "norm_label": "workflows *(since: v1.2)*", + "id": "documentation_workflows_since_v1_2" + }, + { + "label": "`bread.workflow.define(name, fn)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L744", + "_origin": "ast", + "community": 82, + "community_name": "Workflows *(Since: v1.2)*", + "norm_label": "`bread.workflow.define(name, fn)`", + "id": "documentation_bread_workflow_define_name_fn" + }, + { + "label": "`bread.workflow.start(name, opts)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L747", + "_origin": "ast", + "community": 82, + "community_name": "Workflows *(Since: v1.2)*", + "norm_label": "`bread.workflow.start(name, opts)`", + "id": "documentation_bread_workflow_start_name_opts" + }, + { + "label": "`bread.workflow.step(label)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L757", + "_origin": "ast", + "community": 82, + "community_name": "Workflows *(Since: v1.2)*", + "norm_label": "`bread.workflow.step(label)`", + "id": "documentation_bread_workflow_step_label" + }, + { + "label": "`bread.workflow.status(name) -> table | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L760", + "_origin": "ast", + "community": 82, + "community_name": "Workflows *(Since: v1.2)*", + "norm_label": "`bread.workflow.status(name) -> table | nil`", + "id": "documentation_bread_workflow_status_name_table_nil" + }, + { + "label": "`bread.workflow.list() -> table`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L776", + "_origin": "ast", + "community": 82, + "community_name": "Workflows *(Since: v1.2)*", + "norm_label": "`bread.workflow.list() -> table`", + "id": "documentation_bread_workflow_list_table" + }, + { + "label": "Widgets *(Since: v1.3)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L779", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "widgets *(since: v1.3)*", + "id": "documentation_widgets_since_v1_3" + }, + { + "label": "`bread.widget.register(spec) -> ok, err`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L785", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "`bread.widget.register(spec) -> ok, err`", + "id": "documentation_bread_widget_register_spec_ok_err" + }, + { + "label": "Node types", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L799", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "node types", + "id": "documentation_node_types" + }, + { + "label": "`style` *(Since: v1.4)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L827", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "`style` *(since: v1.4)*", + "id": "documentation_style_since_v1_4" + }, + { + "label": "Style vs. `class`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L847", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "style vs. `class`", + "id": "documentation_style_vs_class" + }, + { + "label": "`bread.widget.update(id, patch) -> ok, err`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L851", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "`bread.widget.update(id, patch) -> ok, err`", + "id": "documentation_bread_widget_update_id_patch_ok_err" + }, + { + "label": "`bread.widget.remove(id) -> bool`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L860", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "`bread.widget.remove(id) -> bool`", + "id": "documentation_bread_widget_remove_id_bool" + }, + { + "label": "`bread.widget.list() -> table`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L863", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "`bread.widget.list() -> table`", + "id": "documentation_bread_widget_list_table" + }, + { + "label": "Click events", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L866", + "_origin": "ast", + "community": 79, + "community_name": "Widgets *(Since: v1.3)*", + "norm_label": "click events", + "id": "documentation_click_events" + }, + { + "label": "State", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L878", + "_origin": "ast", + "community": 84, + "community_name": "State", + "norm_label": "state", + "id": "documentation_state" + }, + { + "label": "`bread.state.get(path)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L880", + "_origin": "ast", + "community": 84, + "community_name": "State", + "norm_label": "`bread.state.get(path)`", + "id": "documentation_bread_state_get_path" + }, + { + "label": "Typed shorthands", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L888", + "_origin": "ast", + "community": 84, + "community_name": "State", + "norm_label": "typed shorthands", + "id": "documentation_typed_shorthands" + }, + { + "label": "`bread.state.watch(path, fn) -> id`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L900", + "_origin": "ast", + "community": 84, + "community_name": "State", + "norm_label": "`bread.state.watch(path, fn) -> id`", + "id": "documentation_bread_state_watch_path_fn_id" + }, + { + "label": "Profiles", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L911", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "profiles", + "id": "documentation_profiles" + }, + { + "label": "`bread.profile.activate(name)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L913", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "`bread.profile.activate(name)`", + "id": "documentation_bread_profile_activate_name" + }, + { + "label": "Execution", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L916", + "_origin": "ast", + "community": 86, + "community_name": "Execution", + "norm_label": "execution", + "id": "documentation_execution" + }, + { + "label": "`bread.exec(cmd)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L918", + "_origin": "ast", + "community": 86, + "community_name": "Execution", + "norm_label": "`bread.exec(cmd)`", + "id": "documentation_bread_exec_cmd" + }, + { + "label": "`bread.exec_capture(cmd, opts) -> ok, stdout`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L921", + "_origin": "ast", + "community": 86, + "community_name": "Execution", + "norm_label": "`bread.exec_capture(cmd, opts) -> ok, stdout`", + "id": "documentation_bread_exec_capture_cmd_opts_ok_stdout" + }, + { + "label": "Notifications", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L944", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "notifications", + "id": "documentation_notifications" + }, + { + "label": "`bread.notify(message, opts)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L946", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "`bread.notify(message, opts)`", + "id": "documentation_bread_notify_message_opts" + }, + { + "label": "Timers", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L960", + "_origin": "ast", + "community": 83, + "community_name": "Timers", + "norm_label": "timers", + "id": "documentation_timers" + }, + { + "label": "`bread.after(delay_ms, fn) -> id`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L962", + "_origin": "ast", + "community": 83, + "community_name": "Timers", + "norm_label": "`bread.after(delay_ms, fn) -> id`", + "id": "documentation_bread_after_delay_ms_fn_id" + }, + { + "label": "`bread.every(interval_ms, fn) -> id`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L965", + "_origin": "ast", + "community": 83, + "community_name": "Timers", + "norm_label": "`bread.every(interval_ms, fn) -> id`", + "id": "documentation_bread_every_interval_ms_fn_id" + }, + { + "label": "`bread.cancel(id)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L968", + "_origin": "ast", + "community": 83, + "community_name": "Timers", + "norm_label": "`bread.cancel(id)`", + "id": "documentation_bread_cancel_id" + }, + { + "label": "Utilities", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L971", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "utilities", + "id": "documentation_utilities" + }, + { + "label": "`bread.debounce(delay_ms, fn) -> wrapped_fn`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L973", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "`bread.debounce(delay_ms, fn) -> wrapped_fn`", + "id": "documentation_bread_debounce_delay_ms_fn_wrapped_fn" + }, + { + "label": "`bread.log(msg)` / `bread.warn(msg)` / `bread.error(msg)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L983", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "`bread.log(msg)` / `bread.warn(msg)` / `bread.error(msg)`", + "id": "documentation_bread_log_msg_bread_warn_msg_bread_error_msg" + }, + { + "label": "Machine and filesystem", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L986", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "machine and filesystem", + "id": "documentation_machine_and_filesystem" + }, + { + "label": "`bread.machine.name() -> string`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L988", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.machine.name() -> string`", + "id": "documentation_bread_machine_name_string" + }, + { + "label": "`bread.machine.tags() -> string[]`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L993", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.machine.tags() -> string[]`", + "id": "documentation_bread_machine_tags_string" + }, + { + "label": "`bread.machine.has_tag(tag) -> bool`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L997", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.machine.has_tag(tag) -> bool`", + "id": "documentation_bread_machine_has_tag_tag_bool" + }, + { + "label": "`bread.fs.write(path, content)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1000", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.fs.write(path, content)`", + "id": "documentation_bread_fs_write_path_content" + }, + { + "label": "`bread.fs.read(path) -> string | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1003", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.fs.read(path) -> string | nil`", + "id": "documentation_bread_fs_read_path_string_nil" + }, + { + "label": "`bread.fs.exists(path) -> bool`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1006", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.fs.exists(path) -> bool`", + "id": "documentation_bread_fs_exists_path_bool" + }, + { + "label": "`bread.fs.readlink(path) -> string | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1009", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.fs.readlink(path) -> string | nil`", + "id": "documentation_bread_fs_readlink_path_string_nil" + }, + { + "label": "`bread.fs.expand(path) -> string`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1015", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.fs.expand(path) -> string`", + "id": "documentation_bread_fs_expand_path_string" + }, + { + "label": "`bread.json.decode(str) -> table | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1018", + "_origin": "ast", + "community": 76, + "community_name": "Machine and filesystem", + "norm_label": "`bread.json.decode(str) -> table | nil`", + "id": "documentation_bread_json_decode_str_table_nil" + }, + { + "label": "Hyprland", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1023", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "hyprland", + "id": "documentation_hyprland" + }, + { + "label": "Bluetooth", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1051", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "bluetooth", + "id": "documentation_bluetooth" + }, + { + "label": "`bread.bluetooth.power(enabled)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1055", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "`bread.bluetooth.power(enabled)`", + "id": "documentation_bread_bluetooth_power_enabled" + }, + { + "label": "`bread.bluetooth.powered() -> bool | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1058", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "`bread.bluetooth.powered() -> bool | nil`", + "id": "documentation_bread_bluetooth_powered_bool_nil" + }, + { + "label": "`bread.bluetooth.connect(address)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1067", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "`bread.bluetooth.connect(address)`", + "id": "documentation_bread_bluetooth_connect_address" + }, + { + "label": "`bread.bluetooth.disconnect(address)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1074", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "`bread.bluetooth.disconnect(address)`", + "id": "documentation_bread_bluetooth_disconnect_address" + }, + { + "label": "`bread.bluetooth.scan(enabled)`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1077", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "`bread.bluetooth.scan(enabled)`", + "id": "documentation_bread_bluetooth_scan_enabled" + }, + { + "label": "`bread.bluetooth.devices() -> table | nil`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1080", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "`bread.bluetooth.devices() -> table | nil`", + "id": "documentation_bread_bluetooth_devices_table_nil" + }, + { + "label": "Example: auto-connect headphones on AC power", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1102", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "example: auto-connect headphones on ac power", + "id": "documentation_example_auto_connect_headphones_on_ac_power" + }, + { + "label": "Example: turn off Bluetooth on battery", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1120", + "_origin": "ast", + "community": 78, + "community_name": "Bluetooth", + "norm_label": "example: turn off bluetooth on battery", + "id": "documentation_example_turn_off_bluetooth_on_battery" + }, + { + "label": "Module lifecycle hooks", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1128", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "module lifecycle hooks", + "id": "documentation_module_lifecycle_hooks" + }, + { + "label": "Module storage", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1152", + "_origin": "ast", + "community": 72, + "community_name": "Dictionary: Lua API", + "norm_label": "module storage", + "id": "documentation_module_storage" + }, + { + "label": "Dictionary: Built-in modules", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1165", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "dictionary: built-in modules", + "id": "documentation_dictionary_built_in_modules" + }, + { + "label": "`bread.rules` *(Since: v1.5)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1169", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "`bread.rules` *(since: v1.5)*", + "id": "documentation_bread_rules_since_v1_5" + }, + { + "label": "`bread.monitors`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1200", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "`bread.monitors`", + "id": "documentation_bread_monitors" + }, + { + "label": "`bread.devices`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1226", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "`bread.devices`", + "id": "documentation_bread_devices" + }, + { + "label": "Functions", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1258", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "functions", + "id": "documentation_functions" + }, + { + "label": "Device rule options", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1264", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "device rule options", + "id": "documentation_device_rule_options" + }, + { + "label": "Example: Keyboard configuration on connect", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1296", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "example: keyboard configuration on connect", + "id": "documentation_example_keyboard_configuration_on_connect" + }, + { + "label": "Example: Dock-specific setup", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1309", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "example: dock-specific setup", + "id": "documentation_example_dock_specific_setup" + }, + { + "label": "`bread.workspaces`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1333", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "`bread.workspaces`", + "id": "documentation_bread_workspaces" + }, + { + "label": "`bread.binds`", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1350", + "_origin": "ast", + "community": 74, + "community_name": "Dictionary: Built-in modules", + "norm_label": "`bread.binds`", + "id": "documentation_bread_binds" + }, + { + "label": "Dictionary: Event reference", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1373", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "dictionary: event reference", + "id": "documentation_dictionary_event_reference" + }, + { + "label": "Pattern matching", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1391", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "pattern matching", + "id": "documentation_pattern_matching" + }, + { + "label": "Normalized events", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1400", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "normalized events", + "id": "documentation_normalized_events" + }, + { + "label": "System", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1402", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "system", + "id": "documentation_system" + }, + { + "label": "Devices (udev / Bluetooth)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1409", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "devices (udev / bluetooth)", + "id": "documentation_devices_udev_bluetooth" + }, + { + "label": "Bluetooth (BlueZ)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1427", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "bluetooth (bluez)", + "id": "documentation_bluetooth_bluez" + }, + { + "label": "Hyprland", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1440", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "hyprland", + "id": "documentation_hyprland_1440" + }, + { + "label": "Compatibility: `[compat]` config", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1470", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "compatibility: `[compat]` config", + "id": "documentation_compatibility_compat_config" + }, + { + "label": "Power", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1479", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "power", + "id": "documentation_power" + }, + { + "label": "Network", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1491", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "network", + "id": "documentation_network" + }, + { + "label": "System events", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1498", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "system events", + "id": "documentation_system_events" + }, + { + "label": "Widgets *(Since: v1.3)*", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1506", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "widgets *(since: v1.3)*", + "id": "documentation_widgets_since_v1_3_1506" + }, + { + "label": "Terminal (shell precmd/preexec hooks)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1517", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "terminal (shell precmd/preexec hooks)", + "id": "documentation_terminal_shell_precmd_preexec_hooks" + }, + { + "label": "Git (hooks + dirty-state poller)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1529", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "git (hooks + dirty-state poller)", + "id": "documentation_git_hooks_dirty_state_poller" + }, + { + "label": "Filesystem / project detection", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1541", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "filesystem / project detection", + "id": "documentation_filesystem_project_detection" + }, + { + "label": "Systemd (`systemd --user` units)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1551", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "systemd (`systemd --user` units)", + "id": "documentation_systemd_systemd_user_units" + }, + { + "label": "Podman (containers)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1561", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "podman (containers)", + "id": "documentation_podman_containers" + }, + { + "label": "Remote (SSH session detection)", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1571", + "_origin": "ast", + "community": 69, + "community_name": "Normalized events", + "norm_label": "remote (ssh session detection)", + "id": "documentation_remote_ssh_session_detection" + }, + { + "label": "Namespaces", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1582", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "namespaces", + "id": "documentation_namespaces" + }, + { + "label": "Integrating a bread\\* app", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1598", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "integrating a bread\\* app", + "id": "documentation_integrating_a_bread_app" + }, + { + "label": "Dictionary: Runtime state schema", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1615", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "dictionary: runtime state schema", + "id": "documentation_dictionary_runtime_state_schema" + }, + { + "label": "Dictionary: IPC protocol", + "file_type": "document", + "source_file": "Documentation.md", + "source_location": "L1700", + "_origin": "ast", + "community": 70, + "community_name": "Bread Documentation", + "norm_label": "dictionary: ipc protocol", + "id": "documentation_dictionary_ipc_protocol" + }, + { + "label": "Examples.md", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L1", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "examples.md", + "id": "examples" + }, + { + "label": "Bread Examples", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L1", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "bread examples", + "id": "examples_bread_examples" + }, + { + "label": "Example 1: Porting keyboard_and_display_watcher.sh (system script)", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L7", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "example 1: porting keyboard_and_display_watcher.sh (system script)", + "id": "examples_example_1_porting_keyboard_and_display_watcher_sh_system_script" + }, + { + "label": "Example 2: Porting autostart.lua", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L93", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "example 2: porting autostart.lua", + "id": "examples_example_2_porting_autostart_lua" + }, + { + "label": "Example 3: Porting display/monitors.lua", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L130", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "example 3: porting display/monitors.lua", + "id": "examples_example_3_porting_display_monitors_lua" + }, + { + "label": "Example 4: Multi-step automation workflows", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L182", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "example 4: multi-step automation workflows", + "id": "examples_example_4_multi_step_automation_workflows" + }, + { + "label": "Example 5: A live widget in breadbar", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L241", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "example 5: a live widget in breadbar", + "id": "examples_example_5_a_live_widget_in_breadbar" + }, + { + "label": "Tips for porting your own scripts", + "file_type": "document", + "source_file": "Examples.md", + "source_location": "L313", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "tips for porting your own scripts", + "id": "examples_tips_for_porting_your_own_scripts" + }, + { + "label": "README.md", + "file_type": "document", + "source_file": "README.md", + "source_location": "L1", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "readme.md", + "id": "readme" + }, + { + "label": "Bread", + "file_type": "document", + "source_file": "README.md", + "source_location": "L1", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "bread", + "id": "readme_bread" + }, + { + "label": "How it works", + "file_type": "document", + "source_file": "README.md", + "source_location": "L13", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "how it works", + "id": "readme_how_it_works" + }, + { + "label": "Architecture", + "file_type": "document", + "source_file": "README.md", + "source_location": "L42", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "architecture", + "id": "readme_architecture" + }, + { + "label": "Requirements", + "file_type": "document", + "source_file": "README.md", + "source_location": "L62", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "requirements", + "id": "readme_requirements" + }, + { + "label": "Installation", + "file_type": "document", + "source_file": "README.md", + "source_location": "L76", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "installation", + "id": "readme_installation" + }, + { + "label": "From source", + "file_type": "document", + "source_file": "README.md", + "source_location": "L78", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "from source", + "id": "readme_from_source" + }, + { + "label": "Via bakery", + "file_type": "document", + "source_file": "README.md", + "source_location": "L101", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "via bakery", + "id": "readme_via_bakery" + }, + { + "label": "systemd user service", + "file_type": "document", + "source_file": "README.md", + "source_location": "L109", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "systemd user service", + "id": "readme_systemd_user_service" + }, + { + "label": "Configuration", + "file_type": "document", + "source_file": "README.md", + "source_location": "L120", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "configuration", + "id": "readme_configuration" + }, + { + "label": "CLI reference", + "file_type": "document", + "source_file": "README.md", + "source_location": "L199", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "cli reference", + "id": "readme_cli_reference" + }, + { + "label": "Module system", + "file_type": "document", + "source_file": "README.md", + "source_location": "L244", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "module system", + "id": "readme_module_system" + }, + { + "label": "Installing modules", + "file_type": "document", + "source_file": "README.md", + "source_location": "L248", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "installing modules", + "id": "readme_installing_modules" + }, + { + "label": "Writing a module", + "file_type": "document", + "source_file": "README.md", + "source_location": "L269", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "writing a module", + "id": "readme_writing_a_module" + }, + { + "label": "Event reference, Lua API, and IPC protocol", + "file_type": "document", + "source_file": "README.md", + "source_location": "L303", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "event reference, lua api, and ipc protocol", + "id": "readme_event_reference_lua_api_and_ipc_protocol" + }, + { + "label": "Contributing", + "file_type": "document", + "source_file": "README.md", + "source_location": "L315", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "contributing", + "id": "readme_contributing" + }, + { + "label": "License", + "file_type": "document", + "source_file": "README.md", + "source_location": "L323", + "_origin": "ast", + "community": 67, + "community_name": "Bread", + "norm_label": "license", + "id": "readme_license" + }, + { + "label": "Bread Daemon (breadd)", + "type": "component", + "description": "Long-running Rust process that normalizes hardware/OS signals into semantic events, maintains runtime state, and dispatches events to Lua modules.", + "confidence": 0.95, + "source_location": "README.md:16-20, Documentation.md:25-28", + "source_file": "README.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread daemon (breadd)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "sys_bread_daemon" + }, + { + "label": "Bread CLI (bread)", + "type": "component", + "description": "Command-line interface that communicates with the daemon over a Unix socket at $XDG_RUNTIME_DIR/bread/breadd.sock.", + "confidence": 0.95, + "source_location": "README.md:46, Documentation.md:29", + "source_file": "README.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread cli (bread)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "sys_bread_cli" + }, + { + "label": "Lua Runtime", + "type": "component", + "description": "Dedicated thread inside breadd that loads Lua modules and executes automation logic in response to events.", + "confidence": 0.95, + "source_location": "Documentation.md:28", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "lua runtime", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "sys_lua_runtime" + }, + { + "label": "Hyprland Adapter", + "type": "adapter", + "description": "Interfaces with Hyprland compositor IPC to monitor workspace changes, window focus, and monitor connections.", + "confidence": 0.95, + "source_location": "Documentation.md:31, README.md:64", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "hyprland adapter", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "adapter_hyprland" + }, + { + "label": "udev Adapter", + "type": "adapter", + "description": "Monitors USB and input device hotplug events via udev/netlink to emit device connection/disconnection events.", + "confidence": 0.95, + "source_location": "Documentation.md:31, README.md:64", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "udev adapter", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "adapter_udev" + }, + { + "label": "Power Adapter", + "type": "adapter", + "description": "Monitors AC power and battery state via UPower D-Bus and sysfs to emit power events.", + "confidence": 0.95, + "source_location": "Documentation.md:31, README.md:64", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "power adapter", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "adapter_power" + }, + { + "label": "Network Adapter", + "type": "adapter", + "description": "Monitors network connectivity via rtnetlink and sysfs to emit network connection/disconnection events.", + "confidence": 0.95, + "source_location": "Documentation.md:31, README.md:64", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "network adapter", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "adapter_network" + }, + { + "label": "Bluetooth Adapter", + "type": "adapter", + "description": "Interfaces with BlueZ D-Bus to monitor and control Bluetooth device pairing, connection, and power state.", + "confidence": 0.95, + "source_location": "Documentation.md:31, README.md:64", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bluetooth adapter", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "adapter_bluetooth" + }, + { + "label": "Git Adapter", + "type": "adapter", + "description": "Monitors git repositories via hooks and dirty-state poller to emit commit and branch change events.", + "confidence": 0.95, + "source_location": "Documentation.md:31", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 45, + "norm_label": "git adapter", + "_origin": "semantic", + "community_name": "Git Adapter", + "id": "adapter_git" + }, + { + "label": "Filesystem Adapter", + "type": "adapter", + "description": "Watches project root directories for file changes and build artifacts.", + "confidence": 0.95, + "source_location": "Documentation.md:31", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 44, + "norm_label": "filesystem adapter", + "_origin": "semantic", + "community_name": "Filesystem Adapter", + "id": "adapter_filesystem" + }, + { + "label": "Systemd Adapter", + "type": "adapter", + "description": "Monitors systemd --user unit state changes to emit service start/stop/failure events.", + "confidence": 0.95, + "source_location": "Documentation.md:31", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 47, + "norm_label": "systemd adapter", + "_origin": "semantic", + "community_name": "Systemd Adapter", + "id": "adapter_systemd" + }, + { + "label": "Podman Adapter", + "type": "adapter", + "description": "Monitors Podman container lifecycle events (start, stop, health changes).", + "confidence": 0.95, + "source_location": "Documentation.md:31", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 46, + "norm_label": "podman adapter", + "_origin": "semantic", + "community_name": "Podman Adapter", + "id": "adapter_podman" + }, + { + "label": "Monitors Module (Built-in)", + "type": "module", + "description": "High-level declarative monitor event handlers and layout management for display configuration.", + "confidence": 0.95, + "source_location": "Documentation.md:676-699", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "monitors module (built-in)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "module_monitors" + }, + { + "label": "Devices Module (Built-in)", + "type": "module", + "description": "Device connection rules with name-based matching for hardware hotplug events.", + "confidence": 0.95, + "source_location": "Documentation.md:702-807", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "devices module (built-in)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "module_devices" + }, + { + "label": "Workspaces Module (Built-in)", + "type": "module", + "description": "Workspace-to-monitor assignment and application pinning functionality.", + "confidence": 0.95, + "source_location": "Documentation.md:809-824", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "workspaces module (built-in)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "module_workspaces" + }, + { + "label": "Binds Module (Built-in)", + "type": "module", + "description": "Runtime keybind management via Hyprland dispatcher.", + "confidence": 0.95, + "source_location": "Documentation.md:826-845", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 59, + "norm_label": "binds module (built-in)", + "_origin": "semantic", + "community_name": "Binds Module (Built-in)", + "id": "module_binds" + }, + { + "label": "bread.device.connected", + "type": "event", + "description": "Emitted when a USB device or Bluetooth device connects, contains device info and raw udev properties.", + "confidence": 0.95, + "source_location": "Documentation.md:880-895", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.device.connected", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_device_connected" + }, + { + "label": "bread.device.disconnected", + "type": "event", + "description": "Emitted when a USB device or Bluetooth device disconnects.", + "confidence": 0.95, + "source_location": "Documentation.md:880-895", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.device.disconnected", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_device_disconnected" + }, + { + "label": "bread.monitor.connected", + "type": "event", + "description": "Emitted when an external monitor connects to the system.", + "confidence": 0.95, + "source_location": "Documentation.md:917", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.monitor.connected", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_monitor_connected" + }, + { + "label": "bread.monitor.disconnected", + "type": "event", + "description": "Emitted when an external monitor disconnects from the system.", + "confidence": 0.95, + "source_location": "Documentation.md:918", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.monitor.disconnected", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_monitor_disconnected" + }, + { + "label": "bread.workspace.changed", + "type": "event", + "description": "Emitted when the active workspace changes in Hyprland.", + "confidence": 0.95, + "source_location": "Documentation.md:914", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.workspace.changed", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_workspace_changed" + }, + { + "label": "bread.window.opened", + "type": "event", + "description": "Emitted when a new window opens, contains address, workspace, class, and title.", + "confidence": 0.95, + "source_location": "Documentation.md:921", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.window.opened", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_window_opened" + }, + { + "label": "bread.power.ac.connected", + "type": "event", + "description": "Emitted when AC adapter connects, contains ac_connected flag and battery_percent.", + "confidence": 0.95, + "source_location": "Documentation.md:930", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.power.ac.connected", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_power_ac_connected" + }, + { + "label": "bread.power.battery.low", + "type": "event", + "description": "Emitted when battery level drops below threshold.", + "confidence": 0.95, + "source_location": "Documentation.md:932", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.power.battery.low", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_power_battery_low" + }, + { + "label": "bread.network.connected", + "type": "event", + "description": "Emitted when network connection is established.", + "confidence": 0.95, + "source_location": "Documentation.md:942", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.network.connected", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_network_connected" + }, + { + "label": "bread.bluetooth.device.paired", + "type": "event", + "description": "Emitted when a Bluetooth device is first learned by BlueZ (paired or on adapter restart).", + "confidence": 0.95, + "source_location": "Documentation.md:903", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.bluetooth.device.paired", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "event_bluetooth_device_paired" + }, + { + "label": "bread.system.startup", + "type": "event", + "description": "Emitted once when breadd starts up and Lua runtime is initialized.", + "confidence": 0.95, + "source_location": "Documentation.md:877", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 57, + "norm_label": "bread.system.startup", + "_origin": "semantic", + "community_name": "bread.system.startup", + "id": "event_system_startup" + }, + { + "label": "bread.on(pattern, fn)", + "type": "concept", + "description": "Subscribe to matching events by pattern, returns subscription ID for later unsubscribe.", + "confidence": 0.95, + "source_location": "Documentation.md:184-193", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.on(pattern, fn)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "api_bread_on" + }, + { + "label": "bread.wait(pattern, opts)", + "type": "concept", + "description": "Coroutine-only: suspend until a matching event arrives; must be used with bread.spawn.", + "confidence": 0.95, + "source_location": "Documentation.md:218-227", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.wait(pattern, opts)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "api_bread_wait" + }, + { + "label": "bread.spawn(fn)", + "type": "concept", + "description": "Spawn a coroutine and surface errors if it fails; required for using bread.wait.", + "confidence": 0.95, + "source_location": "Documentation.md:230-231", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.spawn(fn)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "api_bread_spawn" + }, + { + "label": "bread.state.watch(path, fn)", + "type": "concept", + "description": "Watch a state path for changes, callback receives new and old values.", + "confidence": 0.95, + "source_location": "Documentation.md:411-420", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 54, + "norm_label": "bread.state.watch(path, fn)", + "_origin": "semantic", + "community_name": "bread.state.watch(path, fn)", + "id": "api_bread_state_watch" + }, + { + "label": "bread.exec(cmd)", + "type": "concept", + "description": "Fire-and-forget async shell command execution.", + "confidence": 0.95, + "source_location": "Documentation.md:429-430", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 51, + "norm_label": "bread.exec(cmd)", + "_origin": "semantic", + "community_name": "bread.exec(cmd)", + "id": "api_bread_exec" + }, + { + "label": "bread.notify(message, opts)", + "type": "concept", + "description": "Send a desktop notification via notify-send with optional title, urgency, timeout, and icon.", + "confidence": 0.95, + "source_location": "Documentation.md:457-469", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 53, + "norm_label": "bread.notify(message, opts)", + "_origin": "semantic", + "community_name": "bread.notify(message, opts)", + "id": "api_bread_notify" + }, + { + "label": "bread.after(delay_ms, fn)", + "type": "concept", + "description": "Run a function once after a delay in milliseconds.", + "confidence": 0.95, + "source_location": "Documentation.md:473-474", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 48, + "norm_label": "bread.after(delay_ms, fn)", + "_origin": "semantic", + "community_name": "bread.after(delay_ms, fn)", + "id": "api_bread_after" + }, + { + "label": "bread.every(interval_ms, fn)", + "type": "concept", + "description": "Run a function on a repeating interval in milliseconds.", + "confidence": 0.95, + "source_location": "Documentation.md:476-477", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 50, + "norm_label": "bread.every(interval_ms, fn)", + "_origin": "semantic", + "community_name": "bread.every(interval_ms, fn)", + "id": "api_bread_every" + }, + { + "label": "bread.workflow API", + "type": "concept", + "description": "Multi-step automation system with define, start, step, status, and list for coroutine-based workflows with timeouts.", + "confidence": 0.95, + "source_location": "Documentation.md:251-288", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.workflow api", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "api_bread_workflow" + }, + { + "label": "bread.widget API", + "type": "concept", + "description": "Declarative, live-updating widget rendering system for breadbar and sibling apps with typed nodes (box, label, icon, progress).", + "confidence": 0.95, + "source_location": "Documentation.md:290-387", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 36, + "norm_label": "bread.widget api", + "_origin": "semantic", + "community_name": "bread.widget API", + "id": "api_bread_widget" + }, + { + "label": "bread.hyprland namespace", + "type": "concept", + "description": "Compositor bindings for dispatching commands, setting keywords, querying state, and subscribing to raw events.", + "confidence": 0.95, + "source_location": "Documentation.md:534-556", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 52, + "norm_label": "bread.hyprland namespace", + "_origin": "semantic", + "community_name": "bread.hyprland namespace", + "id": "api_bread_hyprland" + }, + { + "label": "bread.bluetooth namespace", + "type": "concept", + "description": "Bluetooth adapter and device control via BlueZ D-Bus with power, connect, disconnect, scan, and devices query.", + "confidence": 0.95, + "source_location": "Documentation.md:558-625", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 49, + "norm_label": "bread.bluetooth namespace", + "_origin": "semantic", + "community_name": "bread.bluetooth namespace", + "id": "api_bread_bluetooth" + }, + { + "label": "breadd.toml Config", + "type": "config", + "description": "Daemon configuration file at ~/.config/bread/breadd.toml with optional settings for adapters, events, notifications, and modules.", + "confidence": 0.95, + "source_location": "README.md:117-155", + "source_file": "README.md", + "file_type": "concept", + "community": 5, + "norm_label": "breadd.toml config", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "config_breadd_toml" + }, + { + "label": "init.lua Entry Point", + "type": "config", + "description": "Lua entry point loaded first at ~/.config/bread/init.lua; setup and startup logic goes here.", + "confidence": 0.95, + "source_location": "Documentation.md:51, README.md:157-165", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "init.lua entry point", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "config_init_lua" + }, + { + "label": "modules/ Directory", + "type": "config", + "description": "Auto-discovered Lua module directory at ~/.config/bread/modules/ where user modules are placed.", + "confidence": 0.95, + "source_location": "Documentation.md:52, README.md:157", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "modules/ directory", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "config_modules_dir" + }, + { + "label": "main Branch", + "type": "pattern", + "description": "Single long-lived trunk branch where all work accumulates; short-lived feature/fix branches merge back to main.", + "confidence": 0.95, + "source_location": "CONTRIBUTING.md:10, README.md:5", + "source_file": "CONTRIBUTING.md", + "file_type": "concept", + "community": 28, + "norm_label": "main branch", + "_origin": "semantic", + "community_name": "main Branch", + "id": "branch_main" + }, + { + "label": "dev Release Track", + "type": "pattern", + "description": "Bleeding-edge track published on every push to main; auto-versioned with timestamp.", + "confidence": 0.95, + "source_location": "CONTRIBUTING.md:43-56", + "source_file": "CONTRIBUTING.md", + "file_type": "concept", + "community": 91, + "norm_label": "dev release track", + "_origin": "semantic", + "community_name": "dev Release Track", + "id": "release_track_dev" + }, + { + "label": "beta Release Track", + "type": "pattern", + "description": "Release candidate track published on vX.Y.Z-rc.N tags; version sorts below final release.", + "confidence": 0.95, + "source_location": "CONTRIBUTING.md:43-56", + "source_file": "CONTRIBUTING.md", + "file_type": "concept", + "community": 90, + "norm_label": "beta release track", + "_origin": "semantic", + "community_name": "beta Release Track", + "id": "release_track_beta" + }, + { + "label": "stable Release Track", + "type": "pattern", + "description": "Final release track published on vX.Y.Z tags; only track published to GitHub Releases.", + "confidence": 0.95, + "source_location": "CONTRIBUTING.md:43-56", + "source_file": "CONTRIBUTING.md", + "file_type": "concept", + "community": 92, + "norm_label": "stable release track", + "_origin": "semantic", + "community_name": "stable Release Track", + "id": "release_track_stable" + }, + { + "label": "Event-Driven Architecture", + "type": "pattern", + "description": "Core Bread pattern: adapters emit raw events, normalizer transforms to semantic events, Lua modules subscribe and react.", + "confidence": 0.95, + "source_location": "README.md:14-21, Documentation.md:23-26", + "source_file": "README.md", + "file_type": "concept", + "community": 5, + "norm_label": "event-driven architecture", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "pattern_event_driven" + }, + { + "label": "Module Skeleton Pattern", + "type": "pattern", + "description": "Every module calls bread.module once at top level, registers subscriptions in on_load, returns M.", + "confidence": 0.95, + "source_location": "Documentation.md:96-102, Examples.md:16-86", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 39, + "norm_label": "module skeleton pattern", + "_origin": "semantic", + "community_name": "Autostart Example Module", + "id": "pattern_module_skeleton" + }, + { + "label": "Coroutine Workflow Pattern", + "type": "pattern", + "description": "Multi-step automations using bread.spawn, bread.wait, and bread.workflow for ordered steps with timeouts.", + "confidence": 0.95, + "source_location": "Examples.md:183-226, Documentation.md:251-288", + "source_file": "Examples.md", + "file_type": "concept", + "community": 5, + "norm_label": "coroutine workflow pattern", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "pattern_coroutine_workflow" + }, + { + "label": "Live Widget Update Pattern", + "type": "pattern", + "description": "Widgets register with bread.widget.register, update via bread.widget.update on timers or state changes.", + "confidence": 0.95, + "source_location": "Examples.md:241-296, Documentation.md:290-387", + "source_file": "Examples.md", + "file_type": "concept", + "community": 36, + "norm_label": "live widget update pattern", + "_origin": "semantic", + "community_name": "bread.widget API", + "id": "pattern_widget_live_update" + }, + { + "label": "Autostart Example Module", + "type": "component", + "description": "Run startup commands once on bread.system.startup event.", + "confidence": 0.95, + "source_location": "Examples.md:93-128", + "source_file": "Examples.md", + "file_type": "concept", + "community": 39, + "norm_label": "autostart example module", + "_origin": "semantic", + "community_name": "Autostart Example Module", + "id": "example_autostart" + }, + { + "label": "Monitors Configuration Example", + "type": "component", + "description": "Adjust monitor resolution and layout based on external monitor connect/disconnect events.", + "confidence": 0.95, + "source_location": "Examples.md:130-180", + "source_file": "Examples.md", + "file_type": "concept", + "community": 58, + "norm_label": "monitors configuration example", + "_origin": "semantic", + "community_name": "Monitors Configuration Example", + "id": "example_monitors" + }, + { + "label": "Dock Workflow Example", + "type": "component", + "description": "Multi-step workflow for dock connection: apply layout, wait for monitor, activate profile, notify.", + "confidence": 0.95, + "source_location": "Examples.md:182-226", + "source_file": "Examples.md", + "file_type": "concept", + "community": 5, + "norm_label": "dock workflow example", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "example_dock_workflow" + }, + { + "label": "CPU Temperature Widget Example", + "type": "component", + "description": "Live CPU temperature display in breadbar with color warning at threshold.", + "confidence": 0.95, + "source_location": "Examples.md:241-296", + "source_file": "Examples.md", + "file_type": "concept", + "community": 36, + "norm_label": "cpu temperature widget example", + "_origin": "semantic", + "community_name": "bread.widget API", + "id": "example_widget_cpu_temp" + }, + { + "label": "IPC Protocol", + "type": "concept", + "description": "Newline-delimited JSON protocol over Unix socket for CLI and app communication with daemon.", + "confidence": 0.95, + "source_location": "Documentation.md:1146-1181", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "ipc protocol", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "ipc_protocol" + }, + { + "label": "RuntimeState Schema", + "type": "concept", + "description": "Complete runtime state snapshot containing monitors, workspaces, devices, network, power, profiles, modules, workflows, and widgets.", + "confidence": 0.95, + "source_location": "Documentation.md:1061-1142", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "runtimestate schema", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "state_runtime_schema" + }, + { + "label": "API Stability & Versioning (v1)", + "type": "pattern", + "description": "Bread Automation API v1 guarantees additive-only changes, deprecation windows, and version discovery via IPC.", + "confidence": 0.95, + "source_location": "Documentation.md:35-44", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "api stability & versioning (v1)", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "api_stability_versioning" + }, + { + "label": "bread..* Namespace Convention", + "type": "pattern", + "description": "Sibling bread* apps publish within their own bread..* namespace; daemon enforces app id uniqueness.", + "confidence": 0.95, + "source_location": "Documentation.md:1029-1042", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread..* namespace convention", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "app_namespace_convention" + }, + { + "label": "bread.command..* Command Convention", + "type": "pattern", + "description": "Outbound commands to sibling apps published as bread.command.., best-effort fire-and-forget.", + "confidence": 0.95, + "source_location": "Documentation.md:1038-1041", + "source_file": "Documentation.md", + "file_type": "concept", + "community": 5, + "norm_label": "bread.command..* command convention", + "_origin": "semantic", + "community_name": "Bread Daemon (breadd)", + "id": "command_namespace_convention" + } + ], + "links": [ + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L323", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_all_hook_scripts_exit_0_unconditionally", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L313", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_all_hook_scripts_start_with_shebang_and_marker", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L122", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_branch_changed_emit_line", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L140", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_commit_created_emit_line", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L288", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_detects_own_marker", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L294", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_does_not_falsely_detect_marker", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L131", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_emit_line_for", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L308", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_empty_file_is_not_managed", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L187", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_git_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L152", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L353", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_hook_script_rejects_unknown_name", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_hookoutcome", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L215", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_hooks_path_override", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L49", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_install_git", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L85", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_install_one_hook", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L115", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_is_bread_managed", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L300", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_marker_must_match_whole_trimmed_line", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L345", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_post_checkout_only_emits_on_branch_checkout", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L334", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_post_commit_and_post_merge_emit_commit_created", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L235", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_print_hooks_path_warning", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L250", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_print_summary", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L23", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L270", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_run_git", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L204", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git", + "target": "bread_cli_src_hooks_git_show_toplevel", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L85", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_one_hook", + "target": "bread_cli_src_hooks_git_hookoutcome", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_git_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L71", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L53", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_hooks_path_override", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L72", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_install_one_hook", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L54", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_print_hooks_path_warning", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L78", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_print_summary", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L49", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_git", + "target": "bread_cli_src_hooks_git_show_toplevel", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L187", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_git_dir", + "target": "bread_cli_src_hooks_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L215", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_hooks_path_override", + "target": "bread_cli_src_hooks_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L85", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_one_hook", + "target": "bread_cli_src_hooks_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L270", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_run_git", + "target": "bread_cli_src_hooks_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L204", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_show_toplevel", + "target": "bread_cli_src_hooks_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L89", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_one_hook", + "target": "bread_cli_src_hooks_git_is_bread_managed", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L85", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_install_one_hook", + "target": "bread_cli_src_hooks_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L250", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_print_summary", + "target": "bread_cli_src_hooks_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L122", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_branch_changed_emit_line", + "target": "bread_cli_src_hooks_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L140", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_commit_created_emit_line", + "target": "bread_cli_src_hooks_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L131", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_emit_line_for", + "target": "bread_cli_src_hooks_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L152", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_hook_script", + "target": "bread_cli_src_hooks_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L215", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_hooks_path_override", + "target": "bread_cli_src_hooks_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L270", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_run_git", + "target": "bread_cli_src_hooks_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L134", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_emit_line_for", + "target": "bread_cli_src_hooks_git_commit_created_emit_line", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L325", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_all_hook_scripts_exit_0_unconditionally", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L315", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_all_hook_scripts_start_with_shebang_and_marker", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L354", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_hook_script_rejects_unknown_name", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L346", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_post_checkout_only_emits_on_branch_checkout", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L336", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_post_commit_and_post_merge_emit_commit_created", + "target": "bread_cli_src_hooks_git_hook_script", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L187", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_git_dir", + "target": "bread_cli_src_hooks_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L188", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_git_dir", + "target": "bread_cli_src_hooks_git_run_git", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L250", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_print_summary", + "target": "bread_cli_src_hooks_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L204", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_show_toplevel", + "target": "bread_cli_src_hooks_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L205", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_git_show_toplevel", + "target": "bread_cli_src_hooks_git_run_git", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_git.rs", + "source_location": "L215", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_git_hooks_path_override", + "target": "bread_cli_src_hooks_git_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L444", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_detect_from_env_reads_shell_basename", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L472", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_hook_scripts_background_every_emit_call", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L462", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_hook_scripts_reference_bread_emit_not_bread_emit_cli", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L96", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_hooks_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L114", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_install_shell", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L494", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_join_line_continuations", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L431", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_parse_accepts_known_shells", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L438", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_parse_rejects_unknown_shell", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L46", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L52", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_targetshell", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L164", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell", + "target": "bread_cli_src_hooks_shell_write_hook_file", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L78", + "weight": 1.0, + "_origin": "ast", + "context": "return_type", + "source": "bread_cli_src_hooks_shell_targetshell_detect_from_env", + "target": "bread_cli_src_hooks_shell_targetshell", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L62", + "weight": 1.0, + "_origin": "ast", + "context": "generic_arg", + "source": "bread_cli_src_hooks_shell_targetshell_parse", + "target": "bread_cli_src_hooks_shell_targetshell", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L116", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_targetshell_parse", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L62", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_targetshell_parse", + "target": "bread_cli_src_hooks_shell_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L114", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L164", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_write_hook_file", + "target": "bread_cli_src_hooks_shell_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L117", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_targetshell_detect_from_env", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L96", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_hooks_dir", + "target": "bread_cli_src_hooks_shell_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L120", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_hooks_dir", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L164", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_write_hook_file", + "target": "bread_cli_src_hooks_shell_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L114", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L114", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L125", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_install_shell", + "target": "bread_cli_src_hooks_shell_write_hook_file", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L494", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_join_line_continuations", + "target": "bread_cli_src_hooks_shell_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L480", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_hook_scripts_background_every_emit_call", + "target": "bread_cli_src_hooks_shell_join_line_continuations", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/hooks_shell.rs", + "source_location": "L494", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_hooks_shell_join_line_continuations", + "target": "bread_cli_src_hooks_shell_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L516", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_causalitytracker", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L24", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_cli", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L30", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_commands", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L780", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_config_directory", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L393", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_daemon_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L625", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_format_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L236", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_handle_modules_cmd", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L105", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_hookscommand", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L371", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_install_module", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L141", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_main", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L118", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_modulescommand", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L686", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_print_doctor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L599", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_print_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L566", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_print_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L644", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_print_reload", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L571", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_print_state_formatted", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L578", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_print_value", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L702", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_render_doctor", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L9", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L5", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L400", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L435", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_stream_events", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L380", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_try_daemon_reload", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L661", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_cli_src_main_watch_reload", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L14", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L15", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_main", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L26", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_cli", + "target": "bread_cli_src_main_commands", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L73", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_commands", + "target": "bread_cli_src_main_hookscommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L68", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_commands", + "target": "bread_cli_src_main_modulescommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L90", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_commands", + "target": "bread_cli_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L90", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_commands", + "target": "bread_cli_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L517", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker", + "target": "bread_cli_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L110", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_hookscommand", + "target": "bread_cli_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L599", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_event", + "target": "bread_cli_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L571", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_state_formatted", + "target": "bread_cli_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L435", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_stream_events", + "target": "bread_cli_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L517", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker", + "target": "bread_cli_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L625", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_format_timestamp", + "target": "bread_cli_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L110", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_hookscommand", + "target": "bread_cli_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L137", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_modulescommand", + "target": "bread_cli_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L435", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_stream_events", + "target": "bread_cli_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L236", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_handle_modules_cmd", + "target": "bread_cli_src_main_modulescommand", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L143", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_daemon_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L176", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_handle_modules_cmd", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L224", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_print_doctor", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L161", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_print_json", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_print_reload", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L163", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_print_state_formatted", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L141", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L150", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L173", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_stream_events", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L148", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_main", + "target": "bread_cli_src_main_watch_reload", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L236", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_handle_modules_cmd", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L371", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_install_module", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L686", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_doctor", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L566", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_json", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L400", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_send_request", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L435", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_stream_events", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L661", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_watch_reload", + "target": "bread_cli_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L241", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_handle_modules_cmd", + "target": "bread_cli_src_main_install_module", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L236", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_handle_modules_cmd", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L270", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_handle_modules_cmd", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L243", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_handle_modules_cmd", + "target": "bread_cli_src_main_try_daemon_reload", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L371", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_install_module", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L686", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_doctor", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L400", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_send_request", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L435", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_stream_events", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L380", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_try_daemon_reload", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L661", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_watch_reload", + "target": "bread_cli_src_main_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L371", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_install_module", + "target": "bread_cli_src_modules_mgmt_modulemanifest", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L381", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_try_daemon_reload", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L393", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_daemon_socket_path", + "target": "bread_cli_src_main_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L780", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_main_config_directory", + "target": "bread_cli_src_main_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L697", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_print_doctor", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L400", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_main_send_request", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L449", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_stream_events", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L679", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_watch_reload", + "target": "bread_cli_src_main_send_request", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L538", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker_print", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L599", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_event", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L566", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_json", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L644", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_reload", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L571", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_state_formatted", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L578", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_print_value", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L702", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_main_render_doctor", + "target": "bread_cli_src_main_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L462", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_stream_events", + "target": "bread_cli_src_main_print_event", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L524", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker", + "target": "bread_cli_src_main_causalitytracker_depth", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L538", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker", + "target": "bread_cli_src_main_causalitytracker_print", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L517", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker", + "target": "bread_cli_src_main_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L547", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker_print", + "target": "bread_cli_src_main_causalitytracker_depth", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L555", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_causalitytracker_print", + "target": "bread_cli_src_main_format_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L575", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_print_state_formatted", + "target": "bread_cli_src_main_print_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L618", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_print_event", + "target": "bread_cli_src_main_format_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L680", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_watch_reload", + "target": "bread_cli_src_main_print_reload", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L662", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_watch_reload", + "target": "bread_cli_src_main_config_directory", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/main.rs", + "source_location": "L698", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_main_print_doctor", + "target": "bread_cli_src_main_render_doctor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L386", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_audit_detects_fs_read_and_widget_from_cpu_temp_widget_style_module", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L419", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_audit_extracts_exec_bin_hint_and_ignores_baseline_calls", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L259", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_audit_module", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L443", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_audit_scans_required_sibling_files_in_module_directory", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L321", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_classify_call_site", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L283", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_collect_lua_files", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L221", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_copy_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L370", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_extract_first_string_arg", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L122", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_install_from_local", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_list_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L10", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_modulemanifest", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L208", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_modules_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L35", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_parse_source", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L201", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_read_manifest_file", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L191", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_read_module_manifest", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_remove_module", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L274", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_render_permissions_toml", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L461", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_render_permissions_toml_produces_pastable_block", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L97", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_resolve_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L6", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L303", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_scan_lua_source", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L68", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt", + "target": "bread_cli_src_modules_mgmt_validate_module_name", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_src_modules_mgmt", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L122", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_install_from_local", + "target": "bread_cli_src_modules_mgmt_modulemanifest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_list_modules", + "target": "bread_cli_src_modules_mgmt_modulemanifest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L26", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_modulemanifest", + "target": "bread_cli_src_modules_mgmt_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L16", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_modulemanifest", + "target": "bread_cli_src_modules_mgmt_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L26", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_modulemanifest", + "target": "bread_cli_src_modules_mgmt_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L26", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_modulemanifest", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L201", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_manifest_file", + "target": "bread_cli_src_modules_mgmt_modulemanifest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L191", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_module_manifest", + "target": "bread_cli_src_modules_mgmt_modulemanifest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L370", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_extract_first_string_arg", + "target": "bread_cli_src_modules_mgmt_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L274", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_render_permissions_toml", + "target": "bread_cli_src_modules_mgmt_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L370", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_extract_first_string_arg", + "target": "bread_cli_src_modules_mgmt_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L259", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_module", + "target": "bread_cli_src_modules_mgmt_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L283", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_collect_lua_files", + "target": "bread_cli_src_modules_mgmt_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_list_modules", + "target": "bread_cli_src_modules_mgmt_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L35", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_parse_source", + "target": "bread_cli_src_modules_mgmt_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L35", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_parse_source", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L259", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_module", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L283", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_collect_lua_files", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L221", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_copy_dir", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L122", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_install_from_local", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L169", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_list_modules", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L201", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_manifest_file", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L191", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_module_manifest", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L159", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_remove_module", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L274", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_render_permissions_toml", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L97", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_resolve_module_dir", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L68", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_validate_module_name", + "target": "bread_cli_src_modules_mgmt_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L283", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_collect_lua_files", + "target": "bread_cli_src_modules_mgmt_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L208", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_modules_dir", + "target": "bread_cli_src_modules_mgmt_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L97", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_resolve_module_dir", + "target": "bread_cli_src_modules_mgmt_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L98", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_resolve_module_dir", + "target": "bread_cli_src_modules_mgmt_validate_module_name", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L142", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_install_from_local", + "target": "bread_cli_src_modules_mgmt_resolve_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L192", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_module_manifest", + "target": "bread_cli_src_modules_mgmt_resolve_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L160", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_remove_module", + "target": "bread_cli_src_modules_mgmt_resolve_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L97", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_resolve_module_dir", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L259", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_module", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L283", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_collect_lua_files", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L221", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_copy_dir", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L122", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_install_from_local", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_list_modules", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L201", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_manifest_file", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L191", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_module_manifest", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L159", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_remove_module", + "target": "bread_cli_src_modules_mgmt_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L147", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_install_from_local", + "target": "bread_cli_src_modules_mgmt_copy_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L180", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_list_modules", + "target": "bread_cli_src_modules_mgmt_read_manifest_file", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L197", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_read_module_manifest", + "target": "bread_cli_src_modules_mgmt_read_manifest_file", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L407", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_detects_fs_read_and_widget_from_cpu_temp_widget_style_module", + "target": "bread_cli_src_modules_mgmt_audit_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L436", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_extracts_exec_bin_hint_and_ignores_baseline_calls", + "target": "bread_cli_src_modules_mgmt_audit_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L263", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_module", + "target": "bread_cli_src_modules_mgmt_collect_lua_files", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L266", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_module", + "target": "bread_cli_src_modules_mgmt_scan_lua_source", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L259", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_module", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L456", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_audit_scans_required_sibling_files_in_module_directory", + "target": "bread_cli_src_modules_mgmt_audit_module", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L274", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_render_permissions_toml", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L467", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_render_permissions_toml_produces_pastable_block", + "target": "bread_cli_src_modules_mgmt_render_permissions_toml", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L317", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_scan_lua_source", + "target": "bread_cli_src_modules_mgmt_classify_call_site", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L303", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_scan_lua_source", + "target": "bread_cli_src_modules_mgmt_rs_btreemap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L303", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_scan_lua_source", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L303", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_scan_lua_source", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L321", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_classify_call_site", + "target": "bread_cli_src_modules_mgmt_rs_btreemap", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L327", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_classify_call_site", + "target": "bread_cli_src_modules_mgmt_extract_first_string_arg", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L321", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_classify_call_site", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/src/modules_mgmt.rs", + "source_location": "L321", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_cli_src_modules_mgmt_classify_call_site", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L49", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_install_from_local_fails_without_manifest", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L24", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_install_from_local_succeeds_with_manifest", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L140", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_install_rejects_manifest_with_path_traversal_name", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L92", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_list_reads_manifests_from_disk", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L6", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_make_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L164", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_manifest_written_correctly_on_install", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L67", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_remove_deletes_module_directory", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L80", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_remove_nonexistent_errors", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L123", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_remove_rejects_absolute_path_name", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L130", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_remove_rejects_name_with_slash", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L107", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules", + "target": "bread_cli_tests_modules_remove_rejects_path_traversal_name", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L28", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules_install_from_local_succeeds_with_manifest", + "target": "bread_cli_tests_modules_make_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L94", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules_list_reads_manifests_from_disk", + "target": "bread_cli_tests_modules_make_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L6", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_cli_tests_modules_make_module_dir", + "target": "bread_cli_tests_modules_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L6", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_cli_tests_modules_make_module_dir", + "target": "bread_cli_tests_modules_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L168", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules_manifest_written_correctly_on_install", + "target": "bread_cli_tests_modules_make_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L69", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules_remove_deletes_module_directory", + "target": "bread_cli_tests_modules_make_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-cli/tests/modules.rs", + "source_location": "L132", + "weight": 1.0, + "_origin": "ast", + "source": "bread_cli_tests_modules_remove_rejects_name_with_slash", + "target": "bread_cli_tests_modules_make_module_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-emit/src/main.rs", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "bread_emit_src_main", + "target": "bread_emit_src_main_main", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-emit/src/main.rs", + "source_location": "L15", + "weight": 1.0, + "_origin": "ast", + "source": "bread_emit_src_main", + "target": "bread_emit_src_main_parse_args", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-emit/src/main.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_emit_src_main", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-emit/src/main.rs", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "source": "bread_emit_src_main_main", + "target": "bread_emit_src_main_parse_args", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-emit/src/main.rs", + "source_location": "L15", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_emit_src_main_parse_args", + "target": "bread_emit_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-emit/src/main.rs", + "source_location": "L15", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_emit_src_main_parse_args", + "target": "bread_emit_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_call", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L39", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_hostmessage", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L28", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L45", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_rpcresponse", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L18", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_rs_duration", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L16", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "bread_module_host_src_io_run", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L17", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L23", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_io", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L34", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_lua_env", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L45", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_main", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L7", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L6", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L17", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L32", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L10", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L31", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "bread_module_host_src_io", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_call", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L32", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_iocommand", + "target": "bread_module_host_src_io_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L32", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_module_host_src_io_iocommand", + "target": "bread_module_host_src_io_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L32", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_iocommand", + "target": "bread_module_host_src_io_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L32", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_iocommand", + "target": "bread_module_host_src_io_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L157", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_main_report_status", + "target": "bread_module_host_src_io_iocommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_call", + "target": "bread_module_host_src_io_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L51", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_rpcresponse", + "target": "bread_module_host_src_io_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_call", + "target": "bread_module_host_src_io_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L49", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_rpcresponse", + "target": "bread_module_host_src_io_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_io_call", + "target": "bread_module_host_src_io_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_io_call", + "target": "bread_module_host_src_io_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L40", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_module_host_src_io_hostmessage", + "target": "bread_shared_src_module_host_ipc_modulehostpush", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_hostmessage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L51", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_module_host_src_io_rpcresponse", + "target": "bread_module_host_src_io_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_module_host_src_io_rs_receiver", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L59", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_io_run", + "target": "bread_shared_src_module_host_ipc_modulehosthello", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/io.rs", + "source_location": "L249", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_io_call", + "target": "bread_module_host_src_io_rs_duration", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L334", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L265", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L427", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L389", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L233", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L364", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L303", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_io_call" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L90", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env", + "target": "bread_module_host_src_lua_env_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L122", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env", + "target": "bread_module_host_src_lua_env_modulehostlua", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L32", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_lua_env", + "target": "error", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L24", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_lua_env", + "target": "rc", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L22", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_module_host_src_lua_env", + "target": "refcell", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_json_to_lua", + "target": "bread_module_host_src_lua_env_rs_jsonvalue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_json_to_lua", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L90", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_json_to_lua", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L107", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_json_to_lua", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L90", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_json_to_lua", + "target": "luavalue", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L520", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "target": "bread_module_host_src_lua_env_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L245", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_json", + "target": "bread_module_host_src_lua_env_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L200", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L367", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_lua_env_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L123", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L241", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_json", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L519", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L241", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_json", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L462", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_load_entry", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L477", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_run_on_load", + "target": "bread_module_host_src_lua_env_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L519", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L495", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_dispatch_event", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L504", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_dispatch_timer", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_events", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L241", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_json", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_state", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L462", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_load_entry", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L513", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_lookup", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L477", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_modulehostlua_run_on_load", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L125", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L127", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L127", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L128", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "bread_module_host_src_lua_env_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L127", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "rc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L127", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua", + "target": "refcell", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "rc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "rc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "rc", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L5", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "rc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "refcell", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "refcell", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "refcell", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "refcell", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L513", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_lookup", + "target": "bread_module_host_src_lua_env_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L180", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_modulehostlua_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L154", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L152", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_events", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L158", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L157", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_json", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L150", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L153", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_module_host_src_lua_env_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L132", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_new", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L173", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_module_fn", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L328", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_emit", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L254", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_events", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L241", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_json", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L225", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_logging", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L290", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_timers", + "target": "bread_module_host_src_lua_env_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_module_host_src_lua_env_rs_hashset", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L353", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_state", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_module_host_src_lua_env_rs_hashset", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_module_host_src_lua_env_rs_hashset", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L376", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_fs", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L416", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_install_exec", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L474", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_load_entry", + "target": "bread_module_host_src_lua_env_modulehostlua_run_on_load", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L462", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_load_entry", + "target": "bread_module_host_src_lua_env_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L487", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_run_on_load", + "target": "breadd_src_core_config_envguard_drop" + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L498", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_dispatch_event", + "target": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L496", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_dispatch_event", + "target": "bread_module_host_src_lua_env_modulehostlua_lookup", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L495", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_dispatch_event", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L505", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_dispatch_timer", + "target": "bread_module_host_src_lua_env_modulehostlua_lookup", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L513", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_lookup", + "target": "bread_module_host_src_lua_env_rs_function", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L519", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "target": "bread_module_host_src_lua_env_rs_function", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/lua_env.rs", + "source_location": "L519", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_lua_env_modulehostlua_call_event_handler", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_main", + "target": "bread_module_host_src_main_main", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L157", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_main", + "target": "bread_module_host_src_main_report_status", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L117", + "weight": 1.0, + "_origin": "ast", + "source": "bread_module_host_src_main_main", + "target": "bread_module_host_src_main_report_status", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L157", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_main_report_status", + "target": "bread_module_host_src_main_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L157", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_module_host_src_main_report_status", + "target": "bread_module_host_src_main_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-module-host/src/main.rs", + "source_location": "L157", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_module_host_src_main_report_status", + "target": "bread_module_host_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L258", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_command_stays_reserved_and_is_not_a_known_app", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L89", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_command_target", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L231", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_command_target_extracts_app_id", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L125", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_event_domain", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L186", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_event_domain_extracts_top_level_segment", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L193", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_event_domain_is_none_without_bread_prefix", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_is_command_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L222", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_is_command_event_requires_command_prefix", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L59", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_is_known_app", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L65", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_is_reserved_domain", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L134", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_known_apps_are_recognized", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L146", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_reserved_domains_are_never_known_apps", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L156", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_reserved_domains_are_recognized", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L163", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_reserved_domains_cover_every_adapter_owned_event_family", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L140", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_unknown_app_is_not_recognized", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L75", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_app_namespace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L199", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_app_namespace_accepts_own_namespace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L215", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_app_namespace_rejects_bare_prefix_without_trailing_dot", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L208", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_app_namespace_rejects_other_namespaces", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L109", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_command_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L240", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_command_event_accepts_known_app_with_verb", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L247", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps", + "target": "bread_shared_src_apps_validate_command_event_rejects_unknown_target_or_missing_verb", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "bread_shared_src_apps", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L117", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_apps_validate_command_event", + "target": "bread_shared_src_apps_is_known_app", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L322", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "bread_shared_src_apps_is_known_app" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L447", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "bread_shared_src_apps_is_reserved_domain" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L611", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "target": "bread_shared_src_apps_validate_app_namespace" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L341", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "bread_shared_src_apps_validate_app_namespace" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L89", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_apps_command_target", + "target": "bread_shared_src_apps_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/apps.rs", + "source_location": "L125", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_apps_event_domain", + "target": "bread_shared_src_apps_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L611", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "target": "bread_shared_src_apps_validate_command_event" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L341", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "bread_shared_src_apps_validate_command_event" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L447", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "bread_shared_src_apps_validate_command_event" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L446", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "bread_shared_src_apps_event_domain" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L156", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_dot_double_star_does_not_match_sibling_prefix", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_dot_double_star_matches_exact_prefix_with_zero_segments", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_double_star_matches_zero_or_more_segments", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L139", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_empty_pattern_matches_only_empty_text", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L145", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_empty_text_only_matches_wildcards", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_exact_match", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L26", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_matches_glob", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L16", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_matches_pattern", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L165", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_mid_pattern_star_does_not_cross_dots", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L104", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_recursive_wildcard", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L114", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_single_char_wildcard", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L94", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_single_segment_wildcard", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L121", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob", + "target": "bread_shared_src_glob_star_does_not_cross_dot_segments", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/glob.rs", + "source_location": "L23", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_glob_matches_pattern", + "target": "bread_shared_src_glob_matches_glob", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L326", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_adapter_source_app_serializes_as_externally_tagged_object", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L451", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_adapter_source_is_hashable_and_eq", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L358", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_adapter_source_rejects_unknown_variant", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L334", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_adapter_source_round_trips_through_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L270", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_adapter_source_serializes_as_snake_case", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_adaptersource", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L376", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_bread_event_new_accepts_owned_and_borrowed_names", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L405", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_bread_event_new_assigns_unique_id_and_no_cause", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L364", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_bread_event_new_sets_current_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L384", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_bread_event_round_trips_through_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L414", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_bread_event_with_timestamp_preserves_timestamp_and_assigns_id", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L105", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L185", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_daemonsection", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L227", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_expand_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L258", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_expand_path_expands_leading_tilde", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L248", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_expand_path_leaves_non_tilde_paths_unchanged", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_new_event_id", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L177", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_now_unix_ms", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L444", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_now_unix_ms_is_monotonically_non_decreasing_across_calls", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L427", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_raw_event_round_trips_through_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L204", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_resolve_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L191", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_lib_socketpathconfig", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L17", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_module_host_ipc", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L18", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_shared_src_lib", + "target": "bread_shared_src_permissions", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L77", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_adaptersource", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L111", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent", + "target": "bread_shared_src_lib_adaptersource", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "bread_shared_src_lib_adaptersource", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_with_timestamp", + "target": "bread_shared_src_lib_adaptersource", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L89", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_rawevent", + "target": "bread_shared_src_lib_adaptersource", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L679", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_raw", + "target": "bread_shared_src_lib_adaptersource", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L130", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_with_timestamp", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L187", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_daemonsection", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L169", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_lib_new_event_id", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L91", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_rawevent", + "target": "bread_shared_src_lib_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L93", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_rawevent", + "target": "bread_shared_src_lib_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L24", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_enumerate_existing", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L38", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L123", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L63", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_try_enumerate", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L60", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L96", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L96", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L116", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L23", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L3", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L45", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_new", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L44", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_network_raw_event", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L22", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L31", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L41", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L53", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_power_raw_event", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L30", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L76", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_parse_upower_message", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L33", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L43", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L107", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_device_event", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L95", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_event", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L21", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L40", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_run", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L304", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L48", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L604", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L392", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_bluetooth", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L554", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_filesystem", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L543", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_git", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L198", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L477", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_network", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L579", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_podman", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L335", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L532", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_remote", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L565", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_systemd", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L521", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_terminal", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L91", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_udev", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L679", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_raw", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L53", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "bread_shared_src_lib_rawevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L113", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent", + "target": "bread_shared_src_lib_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "bread_shared_src_lib_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_with_timestamp", + "target": "bread_shared_src_lib_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent", + "target": "bread_shared_src_lib_breadevent_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent", + "target": "bread_shared_src_lib_breadevent_with_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L130", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent", + "target": "bread_shared_src_lib_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L23", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L53", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc_modulehostpush", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L624", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_accept", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L304", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L48", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L604", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L392", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_bluetooth", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L554", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_filesystem", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L543", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_git", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L198", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L477", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_network", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L579", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_podman", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L335", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L532", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_remote", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L565", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_systemd", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L521", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_terminal", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L91", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_udev", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L529", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L801", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_ev", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L56", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L245", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1841", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L34", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luamessage", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "bread_shared_src_lib_breadevent", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L453", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_adapter_source_is_hashable_and_eq", + "target": "bread_shared_src_lib_breadevent_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L377", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_bread_event_new_accepts_owned_and_borrowed_names", + "target": "bread_shared_src_lib_breadevent_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L406", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_bread_event_new_assigns_unique_id_and_no_cause", + "target": "bread_shared_src_lib_breadevent_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L366", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_bread_event_new_sets_current_timestamp", + "target": "bread_shared_src_lib_breadevent_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L137", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "bread_shared_src_lib_breadevent_with_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L137", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "bread_shared_src_lib_now_unix_ms", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "bread_shared_src_lib_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L136", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_new", + "target": "into", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_with_timestamp", + "target": "into", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L147", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_with_timestamp", + "target": "bread_shared_src_lib_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L415", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_bread_event_with_timestamp_preserves_timestamp_and_assigns_id", + "target": "bread_shared_src_lib_breadevent_with_timestamp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L158", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_breadevent_with_timestamp", + "target": "bread_shared_src_lib_new_event_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L365", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_bread_event_new_sets_current_timestamp", + "target": "bread_shared_src_lib_now_unix_ms", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L445", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_now_unix_ms_is_monotonically_non_decreasing_across_calls", + "target": "bread_shared_src_lib_now_unix_ms", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L160", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L114", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_try_enumerate", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L203", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L83", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L47", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L58", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_network_raw_event", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L107", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_run", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L61", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_power_raw_event", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L171", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L130", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_device_event", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L356", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2022", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2758", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2807", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2665", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_fail", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2650", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_finish", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2607", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_register", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2636", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_step", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2682", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_timeout", + "target": "bread_shared_src_lib_now_unix_ms" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L193", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_lib_socketpathconfig", + "target": "bread_shared_src_lib_daemonsection", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L210", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_lib_resolve_socket_path", + "target": "bread_shared_src_lib_expand_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L204", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_lib_resolve_socket_path", + "target": "bread_shared_src_lib_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/lib.rs", + "source_location": "L227", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_lib_expand_path", + "target": "bread_shared_src_lib_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "target": "bread_shared_src_lib_expand_path" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L246", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots", + "target": "bread_shared_src_lib_expand_path" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L67", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_module_host_ipc_hello_round_trips", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_module_host_ipc_modulehosthello", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L47", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_module_host_ipc_modulehostpush", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L84", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_module_host_ipc_push_event_tag_is_distinguishable_from_a_response_envelope", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L97", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_module_host_ipc_push_timer_round_trips", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L22", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L36", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc_modulehosthello", + "target": "bread_shared_src_module_host_ipc_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L35", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc_modulehosthello", + "target": "bread_shared_src_module_host_ipc_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L35", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc_modulehosthello", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/module_host_ipc.rs", + "source_location": "L58", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_module_host_ipc_modulehostpush", + "target": "bread_shared_src_module_host_ipc_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L123", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_exec_permission_with_bin_round_trips", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L177", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_explicit_empty_permissions_deserializes_to_some_empty", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L165", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_missing_permissions_field_deserializes_to_none", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L134", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_permission_list_round_trips_as_array_of_tables", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L111", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_permission_round_trips_through_toml_with_dotted_type_names", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L60", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_permissions", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L33", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_permissions_modulepermission", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L42", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_permissions_modulepermission", + "target": "bread_shared_src_permissions_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/permissions.rs", + "source_location": "L42", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_permissions_modulepermission", + "target": "bread_shared_src_permissions_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L531", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_bin_allowed", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L511", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_path_allowed", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1724", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_build_scoped_env", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1590", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_out_of_process_module", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1642", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L213", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_moduledecl", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2943", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_read_module_permissions", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L458", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_apply_sandbox", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L97", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_pendingmodulehost", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "bread_shared_src_permissions_modulepermission", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L511", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_path_allowed", + "target": "bread_shared_src_permissions_permissionkind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L389", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_accepts_class_with_underscore_and_hyphen", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L421", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_accepts_node_count_at_max", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L404", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_accepts_tree_at_max_depth", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L143", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_align", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_background", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L352", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_box_of", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L76", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_default_orientation", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L218", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_default_visible", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L121", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_fontweight", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L551", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_invalid_style_color_fails_to_deserialize", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L250", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_is_valid_class", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L343", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_label", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L489", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_node_serializes_with_type_tag", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L497", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_node_without_style_omits_it_when_serialized_and_back", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_orientation", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L171", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_padding", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L465", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_placement_serializes_as_snake_case", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L161", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_radius", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L379", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_rejects_class_starting_with_digit", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L384", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_rejects_empty_class", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L369", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_rejects_invalid_class_characters", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L411", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_rejects_too_many_nodes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L394", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_rejects_tree_deeper_than_max", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L10", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L105", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_semanticcolor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L364", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_simple_label_is_valid", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L568", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_style_does_not_affect_validation", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L541", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_style_enums_serialize_as_snake_case", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L506", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_style_field_is_optional_when_absent_from_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L513", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_style_round_trips_through_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L557", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_style_with_all_fields_none_is_equivalent_to_default", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_textsize", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L428", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_widget_spec_round_trips_through_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L183", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_widgetplacement", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L200", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_widgetspec", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L90", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_widgetstyle", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L224", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget", + "target": "bread_shared_src_widget_widgetvalidationerror", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "bread_shared_src_widget", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L76", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_default_orientation", + "target": "bread_shared_src_widget_orientation", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L30", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_orientation", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L352", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_box_of", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L343", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_label", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L72", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L68", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L72", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L40", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L298", + "weight": 1.0, + "_origin": "ast", + "context": "return_type", + "source": "bread_shared_src_widget_widgetnode_children", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L265", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_widgetnode_class", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L289", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_widgetnode_on_click", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L277", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_widgetnode_style", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L307", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_widgetnode_validate", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L312", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_widgetnode_validate_inner", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L70", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode", + "target": "bread_shared_src_widget_widgetstyle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L213", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetspec", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2723", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetregisterargs", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2731", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetupdateargs", + "target": "bread_shared_src_widget_widgetnode", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L343", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_widget_label", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L265", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_class", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L289", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_on_click", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L277", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_style", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L212", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetspec", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L97", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L212", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetspec", + "target": "bread_shared_src_widget_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L227", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetvalidationerror", + "target": "bread_shared_src_widget_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L289", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_on_click", + "target": "bread_shared_src_widget_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L352", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_widget_box_of", + "target": "bread_shared_src_widget_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L277", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_style", + "target": "bread_shared_src_widget_widgetstyle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L94", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_align", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L95", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_background", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L92", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_fontweight", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L97", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_padding", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L96", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_radius", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L91", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_semanticcolor", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L93", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetstyle", + "target": "bread_shared_src_widget_textsize", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L205", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetspec", + "target": "bread_shared_src_widget_widgetplacement", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2716", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetregisterargs", + "target": "bread_shared_src_widget_widgetplacement", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L3", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "bread_shared_src_widget_widgetspec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L22", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "bread_shared_src_widget_widgetspec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "bread_shared_src_widget_widgetspec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "bread_shared_src_widget_widgetspec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L307", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate", + "target": "bread_shared_src_widget_widgetvalidationerror", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L312", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate_inner", + "target": "bread_shared_src_widget_widgetvalidationerror", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L230", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetvalidationerror", + "target": "bread_shared_src_widget_rs_display", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L231", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetvalidationerror", + "target": "bread_shared_src_widget_widgetvalidationerror_fmt", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L245", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetvalidationerror", + "target": "error", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "bread_shared_src_widget_widgetvalidationerror", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "bread_shared_src_widget_widgetvalidationerror", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L231", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetvalidationerror_fmt", + "target": "bread_shared_src_widget_rs_formatter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L231", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetvalidationerror_fmt", + "target": "bread_shared_src_widget_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L307", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate", + "target": "bread_shared_src_widget_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L312", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate_inner", + "target": "bread_shared_src_widget_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L325", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate_inner", + "target": "bread_shared_src_widget_is_valid_class", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L324", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate_inner", + "target": "bread_shared_src_widget_widgetnode_class", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L530", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_style_round_trips_through_json", + "target": "bread_shared_src_widget_widgetnode_style", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L331", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate_inner", + "target": "bread_shared_src_widget_widgetnode_children", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L309", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widgetnode_validate", + "target": "bread_shared_src_widget_widgetnode_validate_inner", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L422", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_accepts_node_count_at_max", + "target": "bread_shared_src_widget_label", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L490", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_node_serializes_with_type_tag", + "target": "bread_shared_src_widget_label", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L498", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_node_without_style_omits_it_when_serialized_and_back", + "target": "bread_shared_src_widget_label", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L412", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_rejects_too_many_nodes", + "target": "bread_shared_src_widget_label", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L423", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_accepts_node_count_at_max", + "target": "bread_shared_src_widget_box_of", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L406", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_accepts_tree_at_max_depth", + "target": "bread_shared_src_widget_box_of", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L413", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_rejects_too_many_nodes", + "target": "bread_shared_src_widget_box_of", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L396", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_rejects_tree_deeper_than_max", + "target": "bread_shared_src_widget_box_of", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "bread-shared/src/widget.rs", + "source_location": "L436", + "weight": 1.0, + "_origin": "ast", + "source": "bread_shared_src_widget_widget_spec_round_trips_through_json", + "target": "bread_shared_src_widget_box_of", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L226", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_address_from_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L239", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_address_from_path_parses_standard_bluez_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L247", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_address_from_path_returns_empty_for_adapter_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L252", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_address_from_path_returns_empty_for_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L15", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_bluetoothadapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L123", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L63", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_bluetooth_try_enumerate", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L24", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter", + "target": "breadd_src_adapters_bluetooth_bluetoothadapter_enumerate_existing", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L34", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter", + "target": "breadd_src_adapters_bluetooth_bluetoothadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L18", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter", + "target": "breadd_src_adapters_bluetooth_bluetoothadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter", + "target": "breadd_src_adapters_bluetooth_bluetoothadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L18", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_new", + "target": "breadd_src_adapters_bluetooth_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L24", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_enumerate_existing", + "target": "breadd_src_adapters_bluetooth_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L25", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_enumerate_existing", + "target": "breadd_src_adapters_bluetooth_try_enumerate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L38", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_run", + "target": "breadd_src_adapters_bluetooth_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L63", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_try_enumerate", + "target": "breadd_src_adapters_bluetooth_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L49", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_run", + "target": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L38", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_bluetoothadapter_run", + "target": "breadd_src_adapters_bluetooth_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L63", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_try_enumerate", + "target": "breadd_src_adapters_bluetooth_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L146", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "target": "breadd_src_adapters_bluetooth_address_from_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L123", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "target": "breadd_src_adapters_bluetooth_rs_message", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L123", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_parse_bluetooth_message", + "target": "breadd_src_adapters_bluetooth_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/bluetooth.rs", + "source_location": "L226", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_bluetooth_address_from_path", + "target": "breadd_src_adapters_bluetooth_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L354", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify_build_artifact_created_in_target", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L404", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify_debounces_rapid_repeat_events_for_same_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L387", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify_file_changed_for_ordinary_source_file", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L371", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify_silent_for_modify_in_target_not_create", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L326", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify_silent_under_git", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L340", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_classify_silent_under_node_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L249", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_detect_markers", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L438", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_detect_markers_empty_for_plain_directory", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L418", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_detect_markers_finds_cargo_toml", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L426", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_detect_markers_finds_multiple", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L235", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_excluded_dir_component", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L300", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_excluded_dir_component_finds_git_at_top_level", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L313", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_excluded_dir_component_finds_node_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L305", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_excluded_dir_component_finds_target_nested_deeply", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L321", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_excluded_dir_component_none_for_ordinary_source_file", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L261", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_expand_glob", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L450", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_expand_glob_expands_star_to_subdirectories", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L466", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_expand_glob_returns_empty_for_nonexistent_parent", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L444", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_expand_glob_returns_single_path_unchanged_without_star", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L34", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_filesystemadapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L2", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L6", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_filesystem_run_watch", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L14", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L60", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L92", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_filesystemadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L40", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L47", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L96", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_filesystemadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L36", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L36", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_filesystem_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L91", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L249", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_detect_markers", + "target": "breadd_src_adapters_filesystem_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L261", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob", + "target": "breadd_src_adapters_filesystem_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L40", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_new", + "target": "breadd_src_adapters_filesystem_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L47", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "target": "breadd_src_adapters_filesystem_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_adapters_filesystem_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L249", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_detect_markers", + "target": "breadd_src_adapters_filesystem_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L40", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_new", + "target": "breadd_src_adapters_filesystem_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L355", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_build_artifact_created_in_target", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L405", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_debounces_rapid_repeat_events_for_same_path", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L388", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_file_changed_for_ordinary_source_file", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L372", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_silent_for_modify_in_target_not_create", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L327", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_silent_under_git", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L341", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_silent_under_node_modules", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L275", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L467", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob_returns_empty_for_nonexistent_parent", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L445", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob_returns_single_path_unchanged_without_star", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L40", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_new", + "target": "breadd_src_adapters_filesystem_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L97", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_run", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L130", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_adapters_filesystem_filesystemadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L61", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "target": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "target": "breadd_src_adapters_filesystem_expand_glob", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L47", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "target": "breadd_src_adapters_filesystem_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L98", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_run", + "target": "breadd_src_adapters_filesystem_filesystemadapter_resolve_roots", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "breadd_src_adapters_filesystem_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L261", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob", + "target": "breadd_src_adapters_filesystem_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_adapters_filesystem_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L70", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "target": "breadd_src_adapters_filesystem_detect_markers", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L60", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_enumerate_existing", + "target": "breadd_src_adapters_filesystem_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L96", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_run", + "target": "breadd_src_adapters_filesystem_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_adapters_filesystem_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L96", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_run", + "target": "breadd_src_adapters_filesystem_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L114", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_filesystemadapter_run", + "target": "breadd_src_adapters_filesystem_run_watch", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L123", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_adapters_filesystem_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L179", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_run_watch", + "target": "breadd_src_core_config_envguard_drop" + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L193", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "breadd_src_adapters_filesystem_excluded_dir_component", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "breadd_src_adapters_filesystem_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "breadd_src_adapters_filesystem_rs_instant", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "breadd_src_adapters_filesystem_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "breadd_src_adapters_filesystem_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L185", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify", + "target": "eventkind", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L358", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_build_artifact_created_in_target", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L410", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_debounces_rapid_repeat_events_for_same_path", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L391", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_file_changed_for_ordinary_source_file", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L375", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_silent_for_modify_in_target_not_create", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L330", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_silent_under_git", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L344", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_classify_silent_under_node_modules", + "target": "breadd_src_adapters_filesystem_classify", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L249", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_detect_markers", + "target": "breadd_src_adapters_filesystem_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L235", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_excluded_dir_component", + "target": "breadd_src_adapters_filesystem_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L261", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob", + "target": "breadd_src_adapters_filesystem_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L235", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_excluded_dir_component", + "target": "breadd_src_adapters_filesystem_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L421", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_detect_markers_finds_cargo_toml", + "target": "breadd_src_adapters_filesystem_detect_markers", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L430", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_detect_markers_finds_multiple", + "target": "breadd_src_adapters_filesystem_detect_markers", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/filesystem.rs", + "source_location": "L457", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_filesystem_expand_glob_expands_star_to_subdirectories", + "target": "breadd_src_adapters_filesystem_expand_glob", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L339", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_check_ahead_behind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L313", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_check_dirty", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L225", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_discover_repos", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L243", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_expand_roots", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L458", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_expand_roots_globs_single_trailing_star", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L477", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_expand_roots_skips_unreadable_glob_parent_without_panicking", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L446", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_expand_roots_uses_literal_path_without_trailing_star", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L65", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_gitadapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L384", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_ahead_behind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L408", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_ahead_behind_handles_zero_zero", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L403", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_ahead_behind_parses_space_separated_counts", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L398", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_ahead_behind_parses_tab_separated_counts", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L413", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_ahead_behind_rejects_malformed_output", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L304", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_gitdir_file", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L422", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_gitdir_file_extracts_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L438", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_gitdir_file_rejects_unrecognized_content", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L430", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_parse_gitdir_file_trims_whitespace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L202", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_repotrack", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L278", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_resolve_git_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L486", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_resolve_git_dir_finds_standard_directory_git", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L496", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_resolve_git_dir_resolves_worktree_style_git_file", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L517", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_resolve_git_dir_returns_none_for_non_repo", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L26", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L38", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L34", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_git", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L92", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_gitadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L72", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_gitadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L96", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_gitadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_gitadapter_with_interval", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L67", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_rs_duration", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L66", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L66", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_git_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L91", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L225", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_discover_repos", + "target": "breadd_src_adapters_git_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L243", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots", + "target": "breadd_src_adapters_git_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L72", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_new", + "target": "breadd_src_adapters_git_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L82", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_with_interval", + "target": "breadd_src_adapters_git_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L339", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_check_ahead_behind", + "target": "breadd_src_adapters_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L225", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_discover_repos", + "target": "breadd_src_adapters_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L243", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots", + "target": "breadd_src_adapters_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L72", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_new", + "target": "breadd_src_adapters_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L82", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_with_interval", + "target": "breadd_src_adapters_git_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L82", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_with_interval", + "target": "breadd_src_adapters_git_rs_duration", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L73", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_new", + "target": "breadd_src_adapters_git_gitadapter_with_interval", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L72", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_new", + "target": "breadd_src_adapters_git_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L82", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_with_interval", + "target": "breadd_src_adapters_git_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L211", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_repotrack_new", + "target": "breadd_src_adapters_git_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L132", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "breadd_src_adapters_git_check_ahead_behind", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L131", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "breadd_src_adapters_git_check_dirty", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L99", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "breadd_src_adapters_git_discover_repos", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L104", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "breadd_src_adapters_git_repotrack_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L96", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "breadd_src_adapters_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L96", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_gitadapter_run", + "target": "breadd_src_adapters_git_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L339", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_check_ahead_behind", + "target": "breadd_src_adapters_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L313", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_check_dirty", + "target": "breadd_src_adapters_git_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L225", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_discover_repos", + "target": "breadd_src_adapters_git_repotrack", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L211", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_repotrack", + "target": "breadd_src_adapters_git_repotrack_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L207", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_git_repotrack", + "target": "breadd_src_adapters_git_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L205", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_git_repotrack", + "target": "breadd_src_adapters_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L243", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots", + "target": "breadd_src_adapters_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L211", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_repotrack_new", + "target": "breadd_src_adapters_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L278", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_resolve_git_dir", + "target": "breadd_src_adapters_git_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L339", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_git_check_ahead_behind", + "target": "breadd_src_adapters_git_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L384", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_parse_ahead_behind", + "target": "breadd_src_adapters_git_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L304", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_parse_gitdir_file", + "target": "breadd_src_adapters_git_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L278", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_resolve_git_dir", + "target": "breadd_src_adapters_git_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L340", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_check_ahead_behind", + "target": "breadd_src_adapters_git_repotrack_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L314", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_check_dirty", + "target": "breadd_src_adapters_git_repotrack_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L226", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_discover_repos", + "target": "breadd_src_adapters_git_repotrack_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L244", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots", + "target": "breadd_src_adapters_git_repotrack_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L227", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_discover_repos", + "target": "breadd_src_adapters_git_expand_roots", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L228", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_discover_repos", + "target": "breadd_src_adapters_git_resolve_git_dir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L468", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots_globs_single_trailing_star", + "target": "breadd_src_adapters_git_expand_roots", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L479", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots_skips_unreadable_glob_parent_without_panicking", + "target": "breadd_src_adapters_git_expand_roots", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L452", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_expand_roots_uses_literal_path_without_trailing_star", + "target": "breadd_src_adapters_git_expand_roots", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L288", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_resolve_git_dir", + "target": "breadd_src_adapters_git_parse_gitdir_file", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L278", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_resolve_git_dir", + "target": "breadd_src_adapters_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L509", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_resolve_git_dir_resolves_worktree_style_git_file", + "target": "breadd_src_adapters_git_resolve_git_dir", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L339", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_check_ahead_behind", + "target": "breadd_src_adapters_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L313", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_git_check_dirty", + "target": "breadd_src_adapters_git_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/git.rs", + "source_location": "L355", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_git_check_ahead_behind", + "target": "breadd_src_adapters_git_parse_ahead_behind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L116", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L57", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_hyprland_event_socket", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L102", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_hyprland_request_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L94", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_hyprland_request_socket", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L15", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_hyprlandadapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L140", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_parse_hyprland_line", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L2", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_hyprland_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L8", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter", + "target": "breadd_src_adapters_hyprland_hyprlandadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L23", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter", + "target": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L18", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L25", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "breadd_src_adapters_hyprland_hyprland_event_socket", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "breadd_src_adapters_hyprland_parse_hyprland_line", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L23", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "breadd_src_adapters_hyprland_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L23", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprlandadapter_run", + "target": "breadd_src_adapters_hyprland_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L116", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "target": "breadd_src_adapters_hyprland_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L116", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "target": "breadd_src_adapters_hyprland_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L57", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_event_socket", + "target": "breadd_src_adapters_hyprland_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L102", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_request_json", + "target": "breadd_src_adapters_hyprland_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L94", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_request_socket", + "target": "breadd_src_adapters_hyprland_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L57", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_event_socket", + "target": "breadd_src_adapters_hyprland_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L95", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_request_socket", + "target": "breadd_src_adapters_hyprland_hyprland_event_socket", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L94", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_request_socket", + "target": "breadd_src_adapters_hyprland_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L103", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_request_json", + "target": "breadd_src_adapters_hyprland_hyprland_request_socket", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L117", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_emit_topology_snapshot", + "target": "breadd_src_adapters_hyprland_hyprland_request_json", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L102", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_hyprland_request_json", + "target": "breadd_src_adapters_hyprland_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/hyprland.rs", + "source_location": "L140", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_hyprland_parse_hyprland_line", + "target": "breadd_src_adapters_hyprland_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_adapters_mod_adapterstatus", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L44", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_adapters_mod_manager", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L6", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_adapters_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L5", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_adapters_mod_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_adapters_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L10", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L7", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_mod", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L48", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_adapterstatus", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_status_handle", + "target": "breadd_src_adapters_mod_adapterstatus", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L22", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_adapters_mod_adapterstatus", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L54", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_adapters_mod_adapterstatus", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_adapters_mod_adapterstatus", + "confidence_score": 1.0 + }, + { + "relation": "inherits", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_adapter", + "target": "send", + "confidence_score": 1.0 + }, + { + "relation": "inherits", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_adapter", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L17", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L26", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L36", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_power", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L25", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L28", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L9", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L35", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_mod_adapter", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L8", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L19", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L34", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L16", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L13", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_main", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L70", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "sync", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_manager_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L140", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_manager_spawn_adapter", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L69", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_manager_start_all", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_manager_status_handle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L48", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L48", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L47", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_rs_receiver", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L48", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L45", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L48", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_adapters_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L46", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_new", + "target": "breadd_src_adapters_mod_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_new", + "target": "breadd_src_adapters_mod_rs_receiver", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_status_handle", + "target": "breadd_src_adapters_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_status_handle", + "target": "breadd_src_adapters_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_status_handle", + "target": "breadd_src_adapters_mod_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L65", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_status_handle", + "target": "breadd_src_adapters_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_new", + "target": "breadd_src_adapters_mod_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_new", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L73", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_start_all", + "target": "breadd_src_adapters_mod_manager_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L75", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_start_all", + "target": "breadd_src_adapters_mod_manager_spawn_adapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L69", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_start_all", + "target": "breadd_src_adapters_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L140", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_spawn_adapter", + "target": "a", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/adapters/mod.rs", + "source_location": "L149", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_mod_manager_spawn_adapter", + "target": "breadd_src_core_supervisor_spawn_supervised" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_has_default_route", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L44", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_network_raw_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L14", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_networkadapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L39", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_networksnapshot", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L62", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_read_network_state", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_rs_btreemap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L4", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_network", + "target": "breadd_src_adapters_network_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L18", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter", + "target": "breadd_src_adapters_network_networkadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L22", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter", + "target": "breadd_src_adapters_network_networkadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L25", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter_run", + "target": "breadd_src_adapters_network_network_raw_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L24", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter_run", + "target": "breadd_src_adapters_network_read_network_state", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L22", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter_run", + "target": "breadd_src_adapters_network_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L22", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_networkadapter_run", + "target": "breadd_src_adapters_network_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L44", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_network_raw_event", + "target": "breadd_src_adapters_network_networksnapshot", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L40", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_network_networksnapshot", + "target": "breadd_src_adapters_network_rs_btreemap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L40", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_network_networksnapshot", + "target": "breadd_src_adapters_network_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L62", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_read_network_state", + "target": "breadd_src_adapters_network_networksnapshot", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network.rs", + "source_location": "L77", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_read_network_state", + "target": "breadd_src_adapters_network_has_default_route", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L179", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink", + "target": "breadd_src_adapters_network_rtnetlink_ip_from_bytes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L15", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink", + "target": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter", + "target": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L18", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter", + "target": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter", + "target": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L181", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_ip_from_bytes", + "target": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L18", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_new", + "target": "breadd_src_adapters_network_rtnetlink_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L18", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_new", + "target": "breadd_src_adapters_network_rtnetlink_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L31", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_run", + "target": "breadd_src_adapters_network_rtnetlink_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L31", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_rtnetlinkadapter_run", + "target": "breadd_src_adapters_network_rtnetlink_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L179", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_ip_from_bytes", + "target": "breadd_src_adapters_network_rtnetlink_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/network_rtnetlink.rs", + "source_location": "L179", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_network_rtnetlink_ip_from_bytes", + "target": "breadd_src_adapters_network_rtnetlink_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L209", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L282", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_ignores_non_container_type", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L260", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_ignores_remove_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L254", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_ignores_stop_event_to_avoid_double_emit_with_died", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L276", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_ignores_unknown_action", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L140", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_map_podman_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L245", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_maps_died_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L266", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_maps_health_status_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L235", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_maps_start_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L292", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_missing_fields_fall_back_to_unknown", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L21", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman", + "target": "breadd_src_adapters_podman_podmanadapter", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L30", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter", + "target": "breadd_src_adapters_podman_podmanadapter_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L37", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter", + "target": "breadd_src_adapters_podman_podmanadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L24", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter", + "target": "breadd_src_adapters_podman_podmanadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L41", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter", + "target": "breadd_src_adapters_podman_podmanadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L29", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter", + "target": "breadd_src_adapters_podman_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_default", + "target": "breadd_src_adapters_podman_podmanadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L24", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_new", + "target": "breadd_src_adapters_podman_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L49", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_run", + "target": "breadd_src_adapters_podman_podmanadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L30", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_default", + "target": "breadd_src_adapters_podman_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L101", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_run", + "target": "breadd_src_adapters_podman_map_podman_event", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L41", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_run", + "target": "breadd_src_adapters_podman_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L41", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_podman_podmanadapter_run", + "target": "breadd_src_adapters_podman_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L140", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_podman_map_podman_event", + "target": "breadd_src_adapters_podman_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L140", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_podman_map_podman_event", + "target": "breadd_src_adapters_podman_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L140", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_podman_map_podman_event", + "target": "breadd_src_adapters_podman_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L247", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_maps_died_event", + "target": "breadd_src_adapters_podman_map_podman_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L268", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_maps_health_status_event", + "target": "breadd_src_adapters_podman_map_podman_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L237", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_maps_start_event", + "target": "breadd_src_adapters_podman_map_podman_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L298", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_missing_fields_fall_back_to_unknown", + "target": "breadd_src_adapters_podman_map_podman_event", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L209", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_podman_container_event", + "target": "breadd_src_adapters_podman_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L261", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_ignores_remove_event", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L255", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_ignores_stop_event_to_avoid_double_emit_with_died", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L277", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_ignores_unknown_action", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L246", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_maps_died_event", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L267", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_maps_health_status_event", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/podman.rs", + "source_location": "L236", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_podman_maps_start_event", + "target": "breadd_src_adapters_podman_container_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L53", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power", + "target": "breadd_src_adapters_power_power_raw_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L14", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power", + "target": "breadd_src_adapters_power_poweradapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power", + "target": "breadd_src_adapters_power_powersnapshot", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L65", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power", + "target": "breadd_src_adapters_power_read_power_state", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L4", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_power", + "target": "breadd_src_adapters_power_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L26", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter", + "target": "breadd_src_adapters_power_poweradapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter", + "target": "breadd_src_adapters_power_poweradapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L30", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter", + "target": "breadd_src_adapters_power_poweradapter_run", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L19", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter_new", + "target": "breadd_src_adapters_power_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L66", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_read_power_state", + "target": "breadd_src_adapters_power_poweradapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L34", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter_run", + "target": "breadd_src_adapters_power_power_raw_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter_run", + "target": "breadd_src_adapters_power_read_power_state", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L30", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter_run", + "target": "breadd_src_adapters_power_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L30", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_poweradapter_run", + "target": "breadd_src_adapters_power_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L53", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_power_raw_event", + "target": "breadd_src_adapters_power_powersnapshot", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L50", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_power_powersnapshot", + "target": "breadd_src_adapters_power_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power.rs", + "source_location": "L65", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_read_power_state", + "target": "breadd_src_adapters_power_powersnapshot", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L76", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower", + "target": "breadd_src_adapters_power_upower_parse_upower_message", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L15", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower", + "target": "breadd_src_adapters_power_upower_upoweradapter", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L29", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter", + "target": "breadd_src_adapters_power_upower_upoweradapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter", + "target": "breadd_src_adapters_power_upower_upoweradapter_probe", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter", + "target": "breadd_src_adapters_power_upower_upoweradapter_run", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L19", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter_probe", + "target": "breadd_src_adapters_power_upower_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L19", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter_probe", + "target": "breadd_src_adapters_power_upower_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L76", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_parse_upower_message", + "target": "breadd_src_adapters_power_upower_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L33", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter_run", + "target": "breadd_src_adapters_power_upower_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L52", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter_run", + "target": "breadd_src_adapters_power_upower_parse_upower_message", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L33", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_upoweradapter_run", + "target": "breadd_src_adapters_power_upower_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/power_upower.rs", + "source_location": "L76", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_power_upower_parse_upower_message", + "target": "breadd_src_adapters_power_upower_rs_message", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L206", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_active_state_to_kind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L249", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_active_state_to_kind_excludes_failed", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L256", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_active_state_to_kind_ignores_transitional_states", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L238", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_active_state_to_kind_maps_active_to_started", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L243", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_active_state_to_kind_maps_inactive_and_dead_to_stopped", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L226", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_failure_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L283", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_failure_result_extracts_reason_when_present", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L289", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_failure_result_is_none_when_absent", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L103", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_get_unit_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_handle_message", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L216", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_is_failed_transition", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L263", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_is_failed_transition_detects_failed_active_state", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L269", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_is_failed_transition_ignores_other_active_states", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L275", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_is_failed_transition_ignores_unrelated_property_changes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L119", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_query_active_state", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L6", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd", + "target": "breadd_src_adapters_systemd_systemdadapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L28", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter", + "target": "breadd_src_adapters_systemd_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L28", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter", + "target": "breadd_src_adapters_systemd_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L39", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter", + "target": "breadd_src_adapters_systemd_systemdadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L32", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter", + "target": "breadd_src_adapters_systemd_systemdadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L43", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter", + "target": "breadd_src_adapters_systemd_systemdadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L32", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_new", + "target": "breadd_src_adapters_systemd_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L226", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_failure_result", + "target": "breadd_src_adapters_systemd_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L103", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_get_unit_path", + "target": "breadd_src_adapters_systemd_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L119", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_query_active_state", + "target": "breadd_src_adapters_systemd_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L32", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_new", + "target": "breadd_src_adapters_systemd_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L32", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_new", + "target": "breadd_src_adapters_systemd_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L68", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_run", + "target": "breadd_src_adapters_systemd_systemdadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L70", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_run", + "target": "breadd_src_adapters_systemd_get_unit_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L86", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_run", + "target": "breadd_src_adapters_systemd_handle_message", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L43", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_run", + "target": "breadd_src_adapters_systemd_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L43", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_systemdadapter_run", + "target": "breadd_src_adapters_systemd_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L103", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_get_unit_path", + "target": "breadd_src_adapters_systemd_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L103", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_get_unit_path", + "target": "breadd_src_adapters_systemd_rs_connection", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L164", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_get_unit_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_rs_connection", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L119", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_query_active_state", + "target": "breadd_src_adapters_systemd_rs_connection", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L165", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_query_active_state", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L119", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_query_active_state", + "target": "breadd_src_adapters_systemd_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L206", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_active_state_to_kind", + "target": "breadd_src_adapters_systemd_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L226", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_failure_result", + "target": "breadd_src_adapters_systemd_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L166", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_active_state_to_kind", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L189", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_failure_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L186", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_is_failed_transition", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L137", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_handle_message", + "target": "breadd_src_adapters_systemd_rs_message", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L216", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_is_failed_transition", + "target": "breadd_src_adapters_systemd_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/systemd.rs", + "source_location": "L226", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_systemd_failure_result", + "target": "breadd_src_adapters_systemd_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L107", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_build_device_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L95", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_build_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L214", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_enumerate_payload_includes_classification_fields", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L195", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_prop_bool", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L203", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_prop_str", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L3", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_run_udev_monitor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_udev_event_payload", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L12", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_udevadapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L137", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev", + "target": "breadd_src_adapters_udev_udevclassification", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L13", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_udev_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L13", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_udev_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L21", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L36", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_udev_udevadapter_name", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L17", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_udev_udevadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L40", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter", + "target": "breadd_src_adapters_udev_udevadapter_run", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "breadd_src_adapters_udev_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L17", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_new", + "target": "breadd_src_adapters_udev_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L203", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_prop_str", + "target": "breadd_src_adapters_udev_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "breadd_src_adapters_udev_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L17", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_new", + "target": "breadd_src_adapters_udev_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L148", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification", + "target": "breadd_src_adapters_udev_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L52", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "breadd_src_adapters_udev_udevadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L22", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "target": "breadd_src_adapters_udev_udevadapter_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L17", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_new", + "target": "breadd_src_adapters_udev_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L152", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification_from_device", + "target": "breadd_src_adapters_udev_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "target": "breadd_src_adapters_udev_build_device_event", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L21", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "target": "breadd_src_adapters_udev_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L21", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_enumerate_existing", + "target": "breadd_src_adapters_udev_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "breadd_src_adapters_udev_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L40", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_run", + "target": "breadd_src_adapters_udev_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L50", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "breadd_src_adapters_udev_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L40", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_run", + "target": "breadd_src_adapters_udev_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L42", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevadapter_run", + "target": "breadd_src_adapters_udev_run_udev_monitor", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L83", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_run_udev_monitor", + "target": "breadd_src_adapters_udev_build_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L100", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_event", + "target": "breadd_src_adapters_udev_build_device_event", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L95", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_event", + "target": "event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L123", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_device_event", + "target": "breadd_src_adapters_udev_udev_event_payload", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L128", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_device_event", + "target": "breadd_src_adapters_udev_udevclassification_from_device", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L107", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_build_device_event", + "target": "breadd_src_core_types_device", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udev_event_payload", + "target": "breadd_src_adapters_udev_udevclassification", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L148", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification", + "target": "breadd_src_adapters_udev_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L152", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification", + "target": "breadd_src_adapters_udev_udevclassification_from_device", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L203", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_prop_str", + "target": "breadd_src_adapters_udev_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L154", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification_from_device", + "target": "breadd_src_adapters_udev_prop_bool", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification_from_device", + "target": "breadd_src_adapters_udev_prop_str", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L152", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udevclassification_from_device", + "target": "breadd_src_core_types_device", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L218", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_adapters_udev_enumerate_payload_includes_classification_fields", + "target": "breadd_src_adapters_udev_udev_event_payload", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L169", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_udev_event_payload", + "target": "breadd_src_adapters_udev_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L195", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_prop_bool", + "target": "breadd_src_core_types_device", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/adapters/udev.rs", + "source_location": "L203", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_adapters_udev_prop_str", + "target": "breadd_src_core_types_device", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_adaptersconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L73", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_adaptertoggle", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L524", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_compat_section_can_disable_legacy_hyprland_names", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L518", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_compat_section_defaults_legacy_hyprland_names_to_true", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L128", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_compatconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L9", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L277", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_config_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L642", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_config_path_falls_back_to_home_when_no_xdg", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L632", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_config_path_respects_xdg_config_home", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_daemonconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L403", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_config_uses_documented_defaults", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L340", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_dedup_window", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L320", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_log_level", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L324", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_lua_entry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L328", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_lua_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L352", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_notify_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L344", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_notify_timeout", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L348", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_notify_urgency", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L336", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_poll_interval", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L332", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L356", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_udev_subsystems", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L425", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_default_udev_subsystems_match_documented_list", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L375", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_envguard", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L119", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_eventsconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L306", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_expand_home", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L622", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_expand_home_handles_missing_home_env", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L534", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_invalid_toml_returns_error", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L578", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_lua_entry_point_and_module_path_expand_tilde", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L594", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_lua_entry_point_and_module_path_prefer_xdg_config_home_when_set", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L615", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_lua_entry_point_returns_absolute_path_unchanged", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L35", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_luaconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L43", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_modulesconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L141", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_notificationsconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L433", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_parse_empty_toml_yields_defaults", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L441", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_parse_full_toml_overrides_all_values", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L504", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_parse_partial_toml_fills_missing_with_defaults", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_powerconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L100", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_rootsconfig", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L5", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L290", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_rules_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L663", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_rules_path_falls_back_to_home_when_no_xdg", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L653", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_rules_path_respects_xdg_config_home", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L547", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_socket_path_expands_tilde_when_explicit", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L559", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_socket_path_falls_back_to_xdg_runtime_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L540", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_socket_path_uses_explicit_path_verbatim", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L570", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_socket_path_uses_tmp_when_no_xdg_runtime_dir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L108", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_systemdconfig", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L79", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config", + "target": "breadd_src_core_config_udevconfig", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L17", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_main", + "target": "breadd_src_core_config", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L17", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_adaptersconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L23", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_compatconfig", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L248", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_config_load", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L268", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_config_lua_entry_point", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L272", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_config_lua_module_path", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L259", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_config_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L11", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_daemonconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L21", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_eventsconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L13", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_luaconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L15", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_modulesconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L19", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_config", + "target": "breadd_src_core_config_notificationsconfig", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L21", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_core_config_config", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_daemonconfig", + "target": "breadd_src_core_config_daemonconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L150", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_daemonconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L31", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_daemonconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L320", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_default_log_level", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L324", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_default_lua_entry", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L328", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_default_lua_modules", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L352", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_default_notify_path", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L348", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_default_notify_urgency", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L356", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_default_udev_subsystems", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L376", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L39", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_luaconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L47", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L147", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L104", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L115", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L83", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig", + "target": "breadd_src_core_config_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L160", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_luaconfig", + "target": "breadd_src_core_config_luaconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_luaconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig", + "target": "breadd_src_core_config_modulesconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L168", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L47", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig", + "target": "breadd_src_core_config_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L249", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_core_config_modulesconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L356", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_default_udev_subsystems", + "target": "breadd_src_core_config_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L376", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "breadd_src_core_config_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L104", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig", + "target": "breadd_src_core_config_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L115", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig", + "target": "breadd_src_core_config_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L83", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig", + "target": "breadd_src_core_config_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L67", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_adaptersconfig", + "target": "breadd_src_core_config_adaptertoggle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L57", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_adaptersconfig", + "target": "breadd_src_core_config_powerconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L69", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_adaptersconfig", + "target": "breadd_src_core_config_rootsconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L65", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_adaptersconfig", + "target": "breadd_src_core_config_systemdconfig", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L55", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_adaptersconfig", + "target": "breadd_src_core_config_udevconfig", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L178", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_adaptertoggle", + "target": "breadd_src_core_config_adaptertoggle_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L177", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_adaptertoggle", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L185", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L186", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig", + "target": "breadd_src_core_config_udevconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L195", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_powerconfig", + "target": "breadd_src_core_config_powerconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L194", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_powerconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L204", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig", + "target": "breadd_src_core_config_rootsconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L203", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L212", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L213", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig", + "target": "breadd_src_core_config_systemdconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L222", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_eventsconfig", + "target": "breadd_src_core_config_eventsconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L221", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_eventsconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L240", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_compatconfig", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L239", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_compatconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L230", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig", + "target": "breadd_src_core_config_notificationsconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L229", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig", + "target": "breadd_src_core_config_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L250", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_core_config_notificationsconfig", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L153", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_daemonconfig_default", + "target": "breadd_src_core_config_default_log_level", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L154", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_daemonconfig_default", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L151", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_daemonconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L178", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_adaptertoggle_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L240", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_compatconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L248", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_config_load", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L381", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_envguard_new", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L222", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_eventsconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L160", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_luaconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L169", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L230", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L195", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_powerconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L204", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L213", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L186", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig_default", + "target": "breadd_src_core_config_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L162", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_luaconfig_default", + "target": "breadd_src_core_config_default_lua_entry", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L163", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_luaconfig_default", + "target": "breadd_src_core_config_default_lua_modules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L171", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L172", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_modulesconfig_default", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L180", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_adaptertoggle_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L188", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L189", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_udevconfig_default", + "target": "breadd_src_core_config_default_udev_subsystems", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L198", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_powerconfig_default", + "target": "breadd_src_core_config_default_poll_interval", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L197", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_powerconfig_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L206", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L207", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rootsconfig_default", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L215", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L216", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_systemdconfig_default", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L224", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_eventsconfig_default", + "target": "breadd_src_core_config_default_dedup_window", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L234", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig_default", + "target": "breadd_src_core_config_default_notify_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L232", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig_default", + "target": "breadd_src_core_config_default_notify_timeout", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L233", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_notificationsconfig_default", + "target": "breadd_src_core_config_default_notify_urgency", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L519", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_compat_section_defaults_legacy_hyprland_names_to_true", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L242", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_compatconfig_default", + "target": "breadd_src_core_config_default_true", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L251", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_load", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L404", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_default_config_uses_documented_defaults", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L582", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_lua_entry_point_and_module_path_expand_tilde", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L603", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_lua_entry_point_and_module_path_prefer_xdg_config_home_when_set", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L616", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_lua_entry_point_returns_absolute_path_unchanged", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L550", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_expands_tilde_when_explicit", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L562", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_falls_back_to_xdg_runtime_dir", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L541", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_uses_explicit_path_verbatim", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L573", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_uses_tmp_when_no_xdg_runtime_dir", + "target": "breadd_src_core_config_compatconfig_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L249", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_load", + "target": "breadd_src_core_config_config_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L248", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_config_load", + "target": "breadd_src_core_config_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L265", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_socket_path", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L261", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_socket_path", + "target": "breadd_src_core_config_expand_home", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L259", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_config_socket_path", + "target": "breadd_src_core_config_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L268", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_config_lua_entry_point", + "target": "breadd_src_core_config_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L272", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_config_lua_module_path", + "target": "breadd_src_core_config_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L277", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_config_path", + "target": "breadd_src_core_config_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L306", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_expand_home", + "target": "breadd_src_core_config_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L290", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_config_rules_path", + "target": "breadd_src_core_config_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L269", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_lua_entry_point", + "target": "breadd_src_core_config_expand_home", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L273", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_lua_module_path", + "target": "breadd_src_core_config_expand_home", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L279", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_path", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L282", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_path", + "target": "breadd_src_core_config_expand_home", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L292", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rules_path", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L295", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rules_path", + "target": "breadd_src_core_config_expand_home", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L309", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_expand_home", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L392", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "breadd_src_core_config_envguard_drop", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L381", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L391", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "breadd_src_core_config_rs_drop", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L376", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "breadd_src_core_config_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L377", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_config_envguard", + "target": "mutexguard", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L643", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_path_falls_back_to_home_when_no_xdg", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L633", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_config_path_respects_xdg_config_home", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L623", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_expand_home_handles_missing_home_env", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L579", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_lua_entry_point_and_module_path_expand_tilde", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L600", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_lua_entry_point_and_module_path_prefer_xdg_config_home_when_set", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L664", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rules_path_falls_back_to_home_when_no_xdg", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L654", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_rules_path_respects_xdg_config_home", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L548", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_expands_tilde_when_explicit", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L560", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_falls_back_to_xdg_runtime_dir", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/config.rs", + "source_location": "L571", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_config_socket_path_uses_tmp_when_no_xdg_runtime_dir", + "target": "breadd_src_core_config_envguard_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L86", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "breadd_src_core_config_envguard_drop" + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1497", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_core_config_envguard_drop" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1499", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_app_command_to_another_known_app_passes_through", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1524", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_app_command_to_unknown_or_reserved_target_is_dropped", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1486", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_app_own_namespace_passes_through", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1512", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_app_wrong_namespace_is_dropped", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1267", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_bluetooth_connected_emits_device_connected", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1293", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_bluetooth_disconnected_emits_device_disconnected", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1310", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_bluetooth_enumerate_includes_name", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1365", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_bluetooth_name_falls_back_to_properties", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1329", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_bluetooth_paired_emits_bluetooth_specific_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1348", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_bluetooth_unpaired_emits_bluetooth_specific_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1432", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_dedup_allows_after_window_elapses", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1442", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_dedup_distinguishes_different_payloads", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1422", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_dedup_drops_duplicate_within_window", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1467", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_dedup_window_of_zero_allows_everything", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L13", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_eventnormalizer", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L842", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_active_window_v2_parses_address_from_fields", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L940", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_dual_emit_covers_all_ten_mappings_by_default", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1055", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_legacy_names_suppressed_when_compat_disabled", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L903", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_monitor_lifecycle", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1160", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L862", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_openwindow_splits_all_fields", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L886", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_unknown_kind_falls_through_to_generic_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L825", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_hyprland_workspace_change", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1384", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_network_online_and_offline", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1251", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_power_ac_and_battery_can_both_fire", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1199", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_power_ac_connected_emits_named_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1212", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_power_battery_thresholds_select_correct_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1238", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_power_mid_range_battery_emits_generic_changed", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L679", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L2", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1545", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_split_fields_handles_empty_and_single", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L668", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_split_hyprland_fields", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1405", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_system_events_pass_through_unchanged", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L691", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_udev_add_emits_connected_with_identity_fields", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L756", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_udev_anonymous_child_interface_is_dropped", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L739", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_udev_bind_action_is_suppressed", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L772", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_udev_dedupes_child_nodes_of_same_physical_device", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L798", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_udev_disconnect_does_not_share_dedup_with_connect", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L718", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer", + "target": "breadd_src_core_normalizer_udev_remove_emits_disconnected", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L624", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_accept", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L304", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L28", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L604", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L392", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_bluetooth", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L554", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_filesystem", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L543", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_git", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L198", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L477", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_network", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L579", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_podman", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L335", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L532", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_remote", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L565", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_systemd", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L521", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_terminal", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L91", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_udev", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L43", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_eventnormalizer_with_legacy_hyprland_event_names", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L19", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L19", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L19", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer", + "target": "breadd_src_core_normalizer_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1500", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_command_to_another_known_app_passes_through", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1525", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_command_to_unknown_or_reserved_target_is_dropped", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1487", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_own_namespace_passes_through", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1513", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_wrong_namespace_is_dropped", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1268", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_connected_emits_device_connected", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1294", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_disconnected_emits_device_disconnected", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1311", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_enumerate_includes_name", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1366", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_name_falls_back_to_properties", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1330", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_paired_emits_bluetooth_specific_event", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1349", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_unpaired_emits_bluetooth_specific_event", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1433", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_allows_after_window_elapses", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1443", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_distinguishes_different_payloads", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1423", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_drops_duplicate_within_window", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1468", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_window_of_zero_allows_everything", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L28", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_new", + "target": "breadd_src_core_normalizer_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L336", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L843", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_active_window_v2_parses_address_from_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L941", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_dual_emit_covers_all_ten_mappings_by_default", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1056", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_legacy_names_suppressed_when_compat_disabled", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L904", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_monitor_lifecycle", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1175", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L863", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_openwindow_splits_all_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L890", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_unknown_kind_falls_through_to_generic_event", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L826", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_workspace_change", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1385", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_network_online_and_offline", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1252", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_ac_and_battery_can_both_fire", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1200", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_ac_connected_emits_named_event", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1213", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_battery_thresholds_select_correct_event", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1239", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_mid_range_battery_emits_generic_changed", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L670", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_split_hyprland_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1406", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_system_events_pass_through_unchanged", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L692", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_add_emits_connected_with_identity_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L757", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_anonymous_child_interface_is_dropped", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L740", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_bind_action_is_suppressed", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L773", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_dedupes_child_nodes_of_same_physical_device", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L799", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_disconnect_does_not_share_dedup_with_connect", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L719", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_remove_emits_disconnected", + "target": "breadd_src_core_normalizer_eventnormalizer_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L43", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_with_legacy_hyprland_event_names", + "target": "breadd_src_core_normalizer_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1056", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_legacy_names_suppressed_when_compat_disabled", + "target": "breadd_src_core_normalizer_eventnormalizer_with_legacy_hyprland_event_names", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1175", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat", + "target": "breadd_src_core_normalizer_eventnormalizer_with_legacy_hyprland_event_names", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1501", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_command_to_another_known_app_passes_through", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1526", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_command_to_unknown_or_reserved_target_is_dropped", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1488", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_own_namespace_passes_through", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1514", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_wrong_namespace_is_dropped", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1279", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_connected_emits_device_connected", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1295", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_disconnected_emits_device_disconnected", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1312", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_enumerate_includes_name", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1367", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_name_falls_back_to_properties", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1331", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_paired_emits_bluetooth_specific_event", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1350", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_unpaired_emits_bluetooth_specific_event", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_accept", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L61", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L54", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_bluetooth", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L57", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_filesystem", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L56", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_git", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L53", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_network", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L59", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_podman", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L52", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L60", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_remote", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L58", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_systemd", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L55", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_terminal", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize_udev", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L48", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L850", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_active_window_v2_parses_address_from_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1018", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_dual_emit_covers_all_ten_mappings_by_default", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1127", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_legacy_names_suppressed_when_compat_disabled", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L905", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_monitor_lifecycle", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1177", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L870", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_openwindow_splits_all_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L897", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_unknown_kind_falls_through_to_generic_event", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L833", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_workspace_change", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1386", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_network_online_and_offline", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1253", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_ac_and_battery_can_both_fire", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1201", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_ac_connected_emits_named_event", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1224", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_battery_thresholds_select_correct_event", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1240", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_mid_range_battery_emits_generic_changed", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1407", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_system_events_pass_through_unchanged", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L707", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_add_emits_connected_with_identity_fields", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L733", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_remove_emits_disconnected", + "target": "breadd_src_core_normalizer_eventnormalizer_normalize", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L304", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L604", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_app", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L392", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_bluetooth", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L554", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_filesystem", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L543", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_git", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L198", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L477", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_network", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L579", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_podman", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L335", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_power", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L532", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_remote", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L565", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_systemd", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L521", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_terminal", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L91", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_udev", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L668", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_split_hyprland_fields", + "target": "breadd_src_core_normalizer_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L223", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "target": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L245", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_normalize_hyprland", + "target": "breadd_src_core_normalizer_split_hyprland_fields", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L304", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_eventnormalizer_emit_hyprland_dual", + "target": "breadd_src_core_normalizer_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L679", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_normalizer_raw", + "target": "breadd_src_core_normalizer_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1501", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_command_to_another_known_app_passes_through", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1526", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_command_to_unknown_or_reserved_target_is_dropped", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1488", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_own_namespace_passes_through", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1514", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_app_wrong_namespace_is_dropped", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1269", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_connected_emits_device_connected", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1295", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_disconnected_emits_device_disconnected", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1312", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_enumerate_includes_name", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1367", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_name_falls_back_to_properties", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1331", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_paired_emits_bluetooth_specific_event", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1350", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_bluetooth_unpaired_emits_bluetooth_specific_event", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1434", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_allows_after_window_elapses", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1444", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_distinguishes_different_payloads", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1424", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_dedup_drops_duplicate_within_window", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L844", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_active_window_v2_parses_address_from_fields", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1012", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_dual_emit_covers_all_ten_mappings_by_default", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1121", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_legacy_names_suppressed_when_compat_disabled", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L905", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_monitor_lifecycle", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1177", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_namespace_only_subscriber_gets_full_coverage_regardless_of_compat", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L864", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_openwindow_splits_all_fields", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L891", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_unknown_kind_falls_through_to_generic_event", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L827", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_hyprland_workspace_change", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1386", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_network_online_and_offline", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1253", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_ac_and_battery_can_both_fire", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1201", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_ac_connected_emits_named_event", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1224", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_battery_thresholds_select_correct_event", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1240", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_power_mid_range_battery_emits_generic_changed", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L1407", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_system_events_pass_through_unchanged", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L693", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_add_emits_connected_with_identity_fields", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L759", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_anonymous_child_interface_is_dropped", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L741", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_bind_action_is_suppressed", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L775", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_dedupes_child_nodes_of_same_physical_device", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L800", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_disconnect_does_not_share_dedup_with_connect", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/normalizer.rs", + "source_location": "L720", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_normalizer_udev_remove_emits_disconnected", + "target": "breadd_src_core_normalizer_raw", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L219", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_absent_file_is_not_an_error", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L235", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_empty_file_loads_with_no_rules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L323", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_empty_on_is_treated_as_missing", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L226", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_invalid_toml_is_fatal", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L126", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L305", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_missing_on_is_reported_with_index_and_no_on", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L356", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_multiple_action_keys_is_reported", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L375", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_one_bad_rule_does_not_block_other_valid_rules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L67", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_parsedrule", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L42", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_rawrule", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L31", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L208", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L399", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_rule_issue_display_includes_index_and_on", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_ruleaction", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L80", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_ruleissue", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L36", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_rulesfile", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L100", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_rulesloadoutcome", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L153", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_validate_rule", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L247", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_well_formed_rules_all_three_action_kinds_parse", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L289", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_wildcard_on_is_passed_through_unvalidated", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L210", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L339", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules", + "target": "breadd_src_core_rules_zero_action_keys_is_reported", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L22", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_core_rules", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L38", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_rules_rulesfile", + "target": "breadd_src_core_rules_rawrule", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L38", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_rulesfile", + "target": "breadd_src_core_rules_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L113", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_rulesloadoutcome", + "target": "breadd_src_core_rules_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L46", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_rawrule", + "target": "breadd_src_core_rules_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L46", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_rules_rawrule", + "target": "breadd_src_core_rules_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L153", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_rules_validate_rule", + "target": "breadd_src_core_rules_rawrule", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L85", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_ruleissue", + "target": "breadd_src_core_rules_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L72", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_parsedrule", + "target": "breadd_src_core_rules_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L62", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_ruleaction", + "target": "breadd_src_core_rules_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L86", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_ruleissue", + "target": "breadd_src_core_rules_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L106", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_rulesloadoutcome", + "target": "breadd_src_core_rules_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L73", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_rules_parsedrule", + "target": "breadd_src_core_rules_ruleaction", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L112", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_rules_rulesloadoutcome", + "target": "breadd_src_core_rules_parsedrule", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L153", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_rules_validate_rule", + "target": "breadd_src_core_rules_parsedrule", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L89", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_ruleissue", + "target": "breadd_src_core_rules_rs_display", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L90", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_ruleissue", + "target": "breadd_src_core_rules_ruleissue_fmt", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L113", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_rules_rulesloadoutcome", + "target": "breadd_src_core_rules_ruleissue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L153", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_rules_validate_rule", + "target": "breadd_src_core_rules_ruleissue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_rules_ruleissue_fmt", + "target": "breadd_src_core_rules_rs_formatter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L90", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_rules_ruleissue_fmt", + "target": "breadd_src_core_rules_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L153", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_rules_validate_rule", + "target": "breadd_src_core_rules_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L126", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_rules_load_rules", + "target": "breadd_src_core_rules_rulesloadoutcome", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L331", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_empty_on_is_treated_as_missing", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L228", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_invalid_toml_is_fatal", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L126", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_rules_load_rules", + "target": "breadd_src_core_rules_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L144", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_load_rules", + "target": "breadd_src_core_rules_validate_rule", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L312", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_missing_on_is_reported_with_index_and_no_on", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L365", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_multiple_action_keys_is_reported", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L390", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_one_bad_rule_does_not_block_other_valid_rules", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L263", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_well_formed_rules_all_three_action_kinds_parse", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L297", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_wildcard_on_is_passed_through_unvalidated", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L346", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_zero_action_keys_is_reported", + "target": "breadd_src_core_rules_load_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L236", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_empty_file_loads_with_no_rules", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L324", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_empty_on_is_treated_as_missing", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L227", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_invalid_toml_is_fatal", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L306", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_missing_on_is_reported_with_index_and_no_on", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L357", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_multiple_action_keys_is_reported", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L376", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_one_bad_rule_does_not_block_other_valid_rules", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L248", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_well_formed_rules_all_three_action_kinds_parse", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L290", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_wildcard_on_is_passed_through_unvalidated", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L210", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_rules_write_temp", + "target": "breadd_src_core_rules_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L210", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_rules_write_temp", + "target": "breadd_src_core_rules_rs_tempdir", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/rules.rs", + "source_location": "L340", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_rules_zero_action_keys_is_reported", + "target": "breadd_src_core_rules_write_temp", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L440", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_active_window_from_data", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L752", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_apply_device_change", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L529", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L480", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_apply_hyprland_snapshot", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1209", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_empty_matches_anything", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1198", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_id_usb_class_accepts_with_or_without_0x_prefix", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1158", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_input_flags_match_booleans", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L634", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_matches", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1147", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_name_contains_searches_name_and_vendor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1176", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_usb_hub_requires_hub_and_secondary_class", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1137", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_condition_vendor_id_matches_case_insensitively", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L979", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_device_connect_adds_device_with_all_fields", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1004", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_device_connect_is_idempotent_for_same_id", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1025", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_device_disconnect_of_unknown_id_is_noop", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1013", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_device_disconnect_removes_matching_id", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_dispatch_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L801", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_handle_command", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L949", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_hyprland_snapshot_replaces_topology", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L401", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_hyprland_state_key", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L420", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_json_stringish", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L836", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_monitor_connect_adds_new_monitor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L867", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_monitor_disconnect_keeps_record_but_flips_connected_flag", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L853", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_monitor_reconnect_does_not_duplicate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L916", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_namespaced_hyprland_events_update_the_same_state", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1069", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_network_event_updates_online_flag_and_interfaces", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1057", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_power_clamps_battery_percent_to_100", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1035", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_power_event_updates_ac_and_battery_low_flag", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1093", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_profile_activated_pushes_previous_to_history", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1112", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_profile_activated_to_same_name_is_noop", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L624", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_resolve_device", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1218", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_resolve_device_returns_first_matching_rule", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1250", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_resolve_device_skips_rules_with_no_conditions", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1259", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_resolve_device_with_empty_ruleset_returns_unknown", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L3", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L5", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_run_state_engine", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L23", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_statecommand", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L18", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1123", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_unknown_event_does_not_mutate_state", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L452", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_upsert_monitor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L387", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_value_at_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L821", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_value_at_path_navigates_nested_keys", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L827", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_value_at_path_returns_none_on_missing_key", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L815", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_value_at_path_returns_root_for_empty_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L900", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_window_focus_change_updates_active_window", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L884", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_workspace_changed_updates_active_workspace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L428", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_state_engine_workspace_id_from_data", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L15", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_subscriptions", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L12", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_state_engine", + "target": "breadd_src_core_types", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L19", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_main", + "target": "breadd_src_core_state_engine", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L19", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L19", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L20", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L20", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statecommand", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L118", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_clear_modules", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L114", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_clear_subscriptions", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L122", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_clear_widgets", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_register_subscription", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L104", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_register_watch", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L98", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_remove_subscription", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L110", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_remove_watch", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L164", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_set_device_rules", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L126", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_set_module_status", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L143", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_set_module_status_ex", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L160", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_set_profile", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L63", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_state_arc", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_state_dump", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L67", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_state_engine_statehandle_state_get", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L19", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L23", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L49", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L23", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L244", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_core_state_engine_statehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_new", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L63", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_state_arc", + "target": "breadd_src_core_state_engine_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_new", + "target": "breadd_src_core_state_engine_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L63", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_state_arc", + "target": "breadd_src_core_state_engine_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "breadd_src_core_state_engine_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_new", + "target": "breadd_src_core_state_engine_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_statecommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_statecommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L45", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statecommand", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L50", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statecommand", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L52", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statecommand", + "target": "breadd_src_core_state_engine_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L37", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statecommand", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L52", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statecommand", + "target": "breadd_src_core_types_devicerule", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L44", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statecommand", + "target": "breadd_src_core_types_moduleloadstate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_new", + "target": "breadd_src_core_state_engine_statecommand", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L440", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_active_window_from_data", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L420", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_json_stringish", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L624", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_resolve_device", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_register_subscription", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L104", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_register_watch", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L126", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L143", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status_ex", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L160", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_profile", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L428", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_workspace_id_from_data", + "target": "breadd_src_core_state_engine_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L440", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_active_window_from_data", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L401", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_hyprland_state_key", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L420", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_json_stringish", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L126", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L143", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status_ex", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L67", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_state_get", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L387", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_value_at_path", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L428", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_workspace_id_from_data", + "target": "breadd_src_core_state_engine_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L164", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_device_rules", + "target": "breadd_src_core_state_engine_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L341", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_statehandle_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L179", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_statehandle_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_new", + "target": "breadd_src_core_state_engine_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L56", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_new", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L63", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_state_arc", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L67", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_state_get", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L440", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_active_window_from_data", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L752", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_device_change", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L480", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_hyprland_snapshot", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L634", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_condition_matches", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L801", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_ev", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L420", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_json_stringish", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L624", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_resolve_device", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L82", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_state_dump", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L452", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_upsert_monitor", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L387", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_value_at_path", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L428", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_workspace_id_from_data", + "target": "breadd_src_core_state_engine_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L87", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_register_subscription", + "target": "breadd_src_core_state_engine_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_register_subscription", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L104", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_register_watch", + "target": "breadd_src_core_state_engine_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L98", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_remove_subscription", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L104", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_register_watch", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L110", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_remove_watch", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status", + "target": "breadd_src_core_state_engine_statehandle_set_module_status_ex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L126", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status", + "target": "breadd_src_core_types_moduleloadstate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L143", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_module_status_ex", + "target": "breadd_src_core_types_moduleloadstate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L164", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_statehandle_set_device_rules", + "target": "breadd_src_core_types_devicerule", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_rs_receiver", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_state_engine_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L169", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_run_state_engine", + "target": "unboundedreceiver", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "INFERRED", + "confidence_score": 0.8, + "source_file": "breadd/src/main.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_main_main", + "target": "breadd_src_core_state_engine_run_state_engine" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "breadd_src_core_state_engine_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "breadd_src_core_state_engine_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_state_engine_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_subscriptions_subscriptiontable", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L287", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_handle_command", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "breadd_src_core_subscriptions_subscriptiontable", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L362", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_state_engine_dispatch_event", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L535", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_hyprland_state_key", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L441", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_active_window_from_data", + "target": "breadd_src_core_state_engine_json_stringish", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L553", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_json_stringish", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L510", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_hyprland_snapshot", + "target": "breadd_src_core_state_engine_json_stringish", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L429", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_workspace_id_from_data", + "target": "breadd_src_core_state_engine_json_stringish", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L546", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_workspace_id_from_data", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L564", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_active_window_from_data", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L537", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_upsert_monitor", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L452", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_upsert_monitor", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L531", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_apply_hyprland_snapshot", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L480", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_hyprland_snapshot", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L573", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_state_engine_apply_device_change", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L529", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_event_to_state", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L951", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_hyprland_snapshot_replaces_topology", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L838", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_monitor_connect_adds_new_monitor", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L869", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_monitor_disconnect_keeps_record_but_flips_connected_flag", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L856", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_monitor_reconnect_does_not_duplicate", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L918", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_namespaced_hyprland_events_update_the_same_state", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1071", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_network_event_updates_online_flag_and_interfaces", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1059", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_power_clamps_battery_percent_to_100", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1037", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_power_event_updates_ac_and_battery_low_flag", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1096", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_profile_activated_pushes_previous_to_history", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1114", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_profile_activated_to_same_name_is_noop", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1126", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_unknown_event_does_not_mutate_state", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L902", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_window_focus_change_updates_active_window", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L886", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_workspace_changed_updates_active_workspace", + "target": "breadd_src_core_state_engine_apply_event_to_state", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L626", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_resolve_device", + "target": "breadd_src_core_state_engine_condition_matches", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L624", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_resolve_device", + "target": "breadd_src_core_types_devicerule", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L634", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_condition_matches", + "target": "breadd_src_core_types_matchcondition", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L752", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_state_engine_apply_device_change", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L981", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_device_connect_adds_device_with_all_fields", + "target": "breadd_src_core_state_engine_apply_device_change", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1007", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_device_connect_is_idempotent_for_same_id", + "target": "breadd_src_core_state_engine_apply_device_change", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1027", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_device_disconnect_of_unknown_id_is_noop", + "target": "breadd_src_core_state_engine_apply_device_change", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1015", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_device_disconnect_removes_matching_id", + "target": "breadd_src_core_state_engine_apply_device_change", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L953", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_hyprland_snapshot_replaces_topology", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L840", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_monitor_connect_adds_new_monitor", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L871", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_monitor_disconnect_keeps_record_but_flips_connected_flag", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L855", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_monitor_reconnect_does_not_duplicate", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L920", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_namespaced_hyprland_events_update_the_same_state", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1073", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_network_event_updates_online_flag_and_interfaces", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1061", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_power_clamps_battery_percent_to_100", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1039", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_power_event_updates_ac_and_battery_low_flag", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1098", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_profile_activated_pushes_previous_to_history", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1116", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_profile_activated_to_same_name_is_noop", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L1128", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_unknown_event_does_not_mutate_state", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L904", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_window_focus_change_updates_active_window", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/state_engine.rs", + "source_location": "L888", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_state_engine_workspace_changed_updates_active_workspace", + "target": "breadd_src_core_state_engine_ev", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L1", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L7", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_subscription", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L4", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L14", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_subscriptiontable", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_add_assigns_provided_id_and_finds_match", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L137", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_clear_removes_all", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L95", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_match_returns_all_matching_subscriptions", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L149", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_match_returns_empty_for_unmatched_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L156", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_once_flag_is_preserved_in_match_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L122", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_remove_preserves_other_entries_after_swap_remove", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L111", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions", + "target": "breadd_src_core_subscriptions_table_remove_returns_true_only_for_known_ids", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L8", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscription", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L16", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L21", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L35", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable_remove", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L84", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_add_assigns_provided_id_and_finds_match", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L139", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_clear_removes_all", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L97", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_match_returns_all_matching_subscriptions", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_match_returns_empty_for_unmatched_event", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L158", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_once_flag_is_preserved_in_match_result", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L124", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_remove_preserves_other_entries_after_swap_remove", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L113", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_remove_returns_true_only_for_known_ids", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L24", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L223", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2014", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1841", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L358", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1936", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_remove_handler", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L37", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luamessage", + "target": "breadd_src_core_subscriptions_subscriptionid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L9", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscription", + "target": "breadd_src_core_subscriptions_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L15", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_subscription", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L60", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "target": "breadd_src_core_subscriptions_subscription", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L21", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "target": "breadd_src_core_subscriptions_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L16", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L15", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L21", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L55", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_subscriptiontable_clear", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L60", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L35", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable", + "target": "breadd_src_core_subscriptions_subscriptiontable_remove", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L60", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "target": "breadd_src_core_subscriptions_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L84", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_add_assigns_provided_id_and_finds_match", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L139", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_clear_removes_all", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L97", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_match_returns_all_matching_subscriptions", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L151", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_match_returns_empty_for_unmatched_event", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L158", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_once_flag_is_preserved_in_match_result", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L124", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_remove_preserves_other_entries_after_swap_remove", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L113", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_remove_returns_true_only_for_known_ids", + "target": "breadd_src_core_subscriptions_subscriptiontable_add_with_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L141", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_clear_removes_all", + "target": "breadd_src_core_subscriptions_subscriptiontable_clear", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_add_assigns_provided_id_and_finds_match", + "target": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L102", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_match_returns_all_matching_subscriptions", + "target": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/subscriptions.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_subscriptions_table_once_flag_is_preserved_in_match_result", + "target": "breadd_src_core_subscriptions_subscriptiontable_match_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/supervisor.rs", + "source_location": "L7", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_supervisor", + "target": "breadd_src_core_supervisor_spawn_supervised", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/supervisor.rs", + "source_location": "L7", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_supervisor_spawn_supervised", + "target": "breadd_src_core_supervisor_rs_f", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/supervisor.rs", + "source_location": "L7", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_core_supervisor_spawn_supervised", + "target": "breadd_src_core_supervisor_rs_receiver", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L45", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_device", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L77", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_devicerule", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L40", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_devicetopology", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L89", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_interfacestate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L58", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_matchcondition", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L139", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_moduleloadstate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L118", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_modulestatus", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L26", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_monitor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L83", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_networkstate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L94", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_powerstate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L101", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_profilestate", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L5", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L8", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L166", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_workflowstate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L152", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_workflowstatus", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L34", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types", + "target": "breadd_src_core_types_workspace", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L25", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_core_types", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L13", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_devicetopology", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L17", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_modulestatus", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L9", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_monitor", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L14", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_networkstate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L15", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_powerstate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L16", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_profilestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L12", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L12", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L22", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L18", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_workflowstatus", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L10", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_runtimestate", + "target": "breadd_src_core_types_workspace", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_get", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_set", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2825", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_list_json", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2811", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_remove", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2654", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_fail", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2640", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_finish", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2699", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_list_json", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2599", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_register", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_status_json", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2626", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_step", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2669", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_timeout", + "target": "breadd_src_core_types_runtimestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L79", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_devicerule", + "target": "breadd_src_core_types_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L41", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_devicetopology", + "target": "breadd_src_core_types_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L103", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_profilestate", + "target": "breadd_src_core_types_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L53", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_device", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L70", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_matchcondition", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L121", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_modulestatus", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L30", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_monitor", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L96", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_powerstate", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L161", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_workflowstatus", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L36", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_workspace", + "target": "breadd_src_core_types_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L53", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_device", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L78", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_devicerule", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L70", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_matchcondition", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L125", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_modulestatus", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L30", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_monitor", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L84", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_networkstate", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L104", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_profilestate", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L161", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_workflowstatus", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L36", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_workspace", + "target": "breadd_src_core_types_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L41", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_devicetopology", + "target": "breadd_src_core_types_device", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L79", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_devicerule", + "target": "breadd_src_core_types_matchcondition", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3524", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_parse_match_condition", + "target": "breadd_src_core_types_matchcondition", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L84", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_networkstate", + "target": "breadd_src_core_types_interfacestate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L84", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_networkstate", + "target": "breadd_src_core_types_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L125", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_modulestatus", + "target": "breadd_src_core_types_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L108", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types_profilestate", + "target": "breadd_src_core_types_profilestate_default", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L104", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_profilestate", + "target": "breadd_src_core_types_rs_btreemap", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L107", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_core_types_profilestate", + "target": "breadd_src_core_types_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L108", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_core_types_profilestate_default", + "target": "breadd_src_core_types_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L120", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_modulestatus", + "target": "breadd_src_core_types_moduleloadstate", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L125", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_core_types_modulestatus", + "target": "breadd_src_core_types_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/core/types.rs", + "source_location": "L154", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_core_types_workflowstatus", + "target": "breadd_src_core_types_workflowstate", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L67", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_ipcrequest", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L75", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_ipcresponse", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L7", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L6", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L8", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_rs_instant", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L4", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L47", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_ipc_mod_server", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L24", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_lua_mod_runtimehandle", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L25", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_mod", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L56", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L55", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L54", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L57", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_instant", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L56", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_mutex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L48", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L54", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L53", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L54", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L56", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_rs_vecdeque", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L159", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_server_handle_connection", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L235", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_server_handle_request", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L445", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_server_manual_emit", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_server_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L115", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_server_serve", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L463", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_ipc_mod_server_stream_events", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L51", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_lua_mod_runtimehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L63", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L69", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_ipcrequest", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L80", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_ipcresponse", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L235", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L445", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L463", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_stream_events", + "target": "breadd_src_ipc_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_mutex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_vecdeque", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L71", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_ipcrequest", + "target": "breadd_src_ipc_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L235", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "breadd_src_ipc_mod_ipcrequest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_mod_ipcrequest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "breadd_src_ipc_mod_ipcrequest", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L78", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_ipcresponse", + "target": "breadd_src_ipc_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L235", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "breadd_src_ipc_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L445", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "breadd_src_ipc_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L80", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_ipc_mod_ipcresponse", + "target": "breadd_src_ipc_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L463", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_stream_events", + "target": "breadd_src_ipc_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L161", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_connection", + "target": "breadd_src_ipc_mod_server_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L296", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "breadd_src_ipc_mod_server_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L455", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "breadd_src_ipc_mod_server_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_ipc_mod_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_lua_mod_runtimehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L87", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_new", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L131", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_serve", + "target": "breadd_src_ipc_mod_server_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L115", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_serve", + "target": "breadd_src_ipc_mod_rs_receiver", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L115", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_serve", + "target": "breadd_src_ipc_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L159", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_connection", + "target": "breadd_src_ipc_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L235", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "breadd_src_ipc_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L445", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_manual_emit", + "target": "breadd_src_ipc_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L463", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_stream_events", + "target": "breadd_src_ipc_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L214", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_connection", + "target": "breadd_src_ipc_mod_server_handle_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L196", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_connection", + "target": "breadd_src_ipc_mod_server_stream_events", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L159", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_connection", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L32", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "unixstream", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L385", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_handle_request", + "target": "breadd_src_ipc_mod_server_manual_emit", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/mod.rs", + "source_location": "L463", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_mod_server_stream_events", + "target": "breadd_src_ipc_mod_rs_ownedwritehalf", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L531", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "breadd_src_ipc_module_host_bridge_bin_allowed", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L511", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "breadd_src_ipc_module_host_bridge_path_allowed", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L27", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "breadd_src_ipc_module_host_bridge_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L40", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "breadd_src_module_host_modulehostoutcome", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L35", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge", + "target": "joinhandle", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server", + "target": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server", + "target": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "breadd_src_ipc_module_host_bridge_rs_ownedwritehalf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "breadd_src_ipc_module_host_bridge_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L146", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "bufreader", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "lines", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L51", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_handle_module_host_connection", + "target": "ownedreadhalf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L414", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_bin_allowed", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L364", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_path_allowed", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_ipc_module_host_bridge_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "breadd_src_module_host_modulehostoutcome", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/ipc/module_host_bridge.rs", + "source_location": "L195", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_ipc_module_host_bridge_server_dispatch_module_host_method", + "target": "joinhandle", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3669", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_connect", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3684", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_disconnect", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3611", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_find_adapter", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3652", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_get_powered", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3725", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_list_devices", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3588", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_query", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3634", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_set_powered", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3699", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_set_scanning", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3566", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetooth_spawn", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3718", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_bluetoothdevice", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3441", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_builtin_module_decls", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2740", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_default_widget_visible", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3091", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_dirs_home", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L49", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_errorentry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L171", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_handlerentry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L180", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_handlerkind", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3512", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_hyprland_request", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3478", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_hyprland_request_socket", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2920", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_is_lib_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2979", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3540", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_list_lua_files", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3069", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_lua_expand_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3111", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_lua_hostname", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3098", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_lua_machine_name", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3135", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_lua_machine_tags", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L220", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_luaengine", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2911", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_module_name_from_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_module_store_get", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_module_store_set", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L197", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L216", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_moduleinfo", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2837", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_order_module_decls", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3524", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_parse_match_condition", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2943", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_read_module_permissions", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3151", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_read_sync_toml", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L4", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L56", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_runtimehandle", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3087", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_shell_quote", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_spawn_runtime", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_state_value_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L185", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_timerentry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_timerid", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2825", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_widget_list_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_widget_register", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2811", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_widget_remove", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_widget_update", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2714", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_widgetregisterargs", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2729", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_widgetupdateargs", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2654", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_fail", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2640", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_finish", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2699", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_list_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2599", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_register", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_status_json", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2626", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_step", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2669", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_lua_mod_workflow_timeout", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L28", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_lua_mod", + "target": "breadd_src_module_host", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L246", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L43", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luamessage", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L43", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luamessage", + "target": "breadd_src_lua_mod_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L43", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luamessage", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L40", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luamessage", + "target": "breadd_src_lua_mod_timerid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L57", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L62", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle_sender", + "target": "breadd_src_lua_mod_luamessage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L188", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_timerentry", + "target": "breadd_src_lua_mod_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3669", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_connect", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3684", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_disconnect", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3611", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_find_adapter", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3652", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_get_powered", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3725", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_list_devices", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3588", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_query", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3634", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_set_powered", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3699", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_set_scanning", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3512", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_hyprland_request", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3478", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_hyprland_request_socket", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2979", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_json_to_lua", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3540", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_list_lua_files", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1724", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_build_scoped_env", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1841", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1912", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_timer", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L347", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2176", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_debounce", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2117", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_log_helpers", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2273", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_require_loader", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2315", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_wait_helper", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2370", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1280", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_device_rules", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1436", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1612", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_lua_file", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1833", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_lua_source", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1539", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1590", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_out_of_process_module", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1335", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_profiles", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1381", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_rules_toml", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1642", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L294", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1942", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_load", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2209", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_scan_module_decl", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3151", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_read_sync_toml", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L66", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle_reload", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "breadd_src_lua_mod_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3669", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_connect", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3684", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_disconnect", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3611", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_find_adapter", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3720", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetoothdevice", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3441", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_builtin_module_decls", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L52", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_errorentry", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L175", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_handlerentry", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3512", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_hyprland_request", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3111", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_hostname", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3098", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_machine_name", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3135", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_machine_tags", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L243", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2102", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_set_current_dispatch_id", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2091", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_set_current_module", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2911", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_name_from_path", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_set", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L200", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_moduledecl", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2837", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_order_module_decls", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3087", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_shell_quote", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L193", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_timerentry", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2722", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetregisterargs", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2733", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetupdateargs", + "target": "breadd_src_lua_mod_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L51", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_errorentry", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L251", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_errorentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_errorentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L58", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_errorentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L82", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle_recent_errors", + "target": "breadd_src_lua_mod_errorentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3091", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_dirs_home", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L175", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_handlerentry", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L240", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2051", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_get_module_hook", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2014", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1642", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2102", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_set_current_dispatch_id", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2091", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_set_current_module", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_get", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L213", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_moduledecl", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2943", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_read_module_permissions", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L193", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_timerentry", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2722", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetregisterargs", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2737", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_widgetupdateargs", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_status_json", + "target": "breadd_src_lua_mod_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L58", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L58", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_rs_mutex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L57", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L58", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_rs_vecdeque", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_runtimehandle_recent_errors", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L66", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_runtimehandle_reload", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L62", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_runtimehandle_sender", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L78", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle", + "target": "breadd_src_lua_mod_runtimehandle_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_runtimehandle", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L246", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L62", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle_sender", + "target": "breadd_src_lua_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L251", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_get", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_set", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2825", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_list_json", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2811", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_remove", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2654", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_fail", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2640", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_finish", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2699", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_list_json", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2599", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_register", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_status_json", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2626", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_step", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2669", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_timeout", + "target": "breadd_src_lua_mod_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L251", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_mutex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_rs_mutex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L251", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_vecdeque", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_rs_vecdeque", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L82", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_runtimehandle_recent_errors", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3725", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_list_devices", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3441", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_builtin_module_decls", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3540", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_list_lua_files", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3135", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_machine_tags", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L243", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L213", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_moduledecl", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2837", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_order_module_decls", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2943", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_read_module_permissions", + "target": "breadd_src_lua_mod_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L138", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_luaengine_handle_event", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L146", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_luaengine_handle_timer", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L97", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L128", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_luaengine_reload_internal", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L143", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_lua_mod_luaengine_remove_handler", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L90", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_spawn_runtime", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L224", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_timerid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1912", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_timer", + "target": "breadd_src_lua_mod_timerid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L734", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_timerid", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L176", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_handlerentry", + "target": "breadd_src_lua_mod_handlerkind", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L173", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_handlerentry", + "target": "breadd_src_lua_mod_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L222", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_handlerentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L217", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_moduleinfo", + "target": "breadd_src_lua_mod_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L186", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_timerentry", + "target": "breadd_src_lua_mod_rs_registrykey", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L224", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_timerentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3441", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_builtin_module_decls", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L242", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1539", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1590", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_out_of_process_module", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2209", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_scan_module_decl", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L201", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_moduledecl", + "target": "breadd_src_lua_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2837", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_order_module_decls", + "target": "breadd_src_lua_mod_moduledecl", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3091", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_dirs_home", + "target": "breadd_src_lua_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3478", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_hyprland_request_socket", + "target": "breadd_src_lua_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3540", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_list_lua_files", + "target": "breadd_src_lua_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3069", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_expand_path", + "target": "breadd_src_lua_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L256", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L241", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_moduleinfo", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1724", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_build_scoped_env", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2109", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_cancel_all_timers", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2051", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_get_module_hook", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2014", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_handle_callback_error", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1841", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_handle_event", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1912", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_handle_timer", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L347", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_install_api", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2176", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_install_debounce", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2117", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_install_log_helpers", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2273", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_install_require_loader", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2315", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_install_wait_helper", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2370", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1280", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_device_rules", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1436", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1612", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_lua_file", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1833", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_lua_source", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1539", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_module", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1590", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_out_of_process_module", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1335", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_profiles", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1381", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_rules_toml", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1642", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2068", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_module_is_builtin", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2061", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_module_is_registered", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2080", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_module_ungated", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L294", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_reload_internal", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1936", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_remove_handler", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1942", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_run_on_load", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1962", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_run_on_reload", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1988", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_run_on_unload", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2209", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_scan_module_decl", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2102", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_set_current_dispatch_id", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2091", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L226", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_atomicu64", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L242", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L223", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_hashset", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L221", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_lua_mod_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L255", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2979", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_json_to_lua", + "target": "breadd_src_lua_mod_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_lua_mod_rs_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3441", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_builtin_module_decls", + "target": "breadd_src_lua_mod_rs_hashset", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3742", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_list_devices", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3442", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_builtin_module_decls", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3519", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_hyprland_request", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2985", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_json_to_lua", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3541", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_list_lua_files", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L498", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1305", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_device_rules", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1444", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_lua_mod_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L260", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_new", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L300", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2211", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_scan_module_decl", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3054", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_set", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2838", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_order_module_decls", + "target": "breadd_src_lua_mod_luaengine_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L296", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_cancel_all_timers", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L322", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_install_api", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L323", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_load_device_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L326", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L324", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_load_profiles", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L325", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_load_rules_toml", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L327", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_run_on_reload", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L295", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_reload_internal", + "target": "breadd_src_lua_mod_luaengine_run_on_unload", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1223", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_bluetooth_connect", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1233", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_bluetooth_disconnect", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1218", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_bluetooth_query", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1208", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_bluetooth_set_powered", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1243", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_bluetooth_set_scanning", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1207", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_bluetooth_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L834", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_hyprland_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L861", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1145", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_lua_expand_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1119", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_lua_machine_name", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1123", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_lua_machine_tags", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1276", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_luaengine_install_debounce", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1275", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_luaengine_install_log_helpers", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1272", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_luaengine_install_require_loader", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1273", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_luaengine_install_wait_helper", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1274", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L963", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_module_store_get", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L976", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_module_store_set", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1018", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L511", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_state_value_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1105", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_widget_list_json", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1022", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_widget_register", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1083", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_widget_remove", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1054", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_api", + "target": "breadd_src_lua_mod_widget_update", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1320", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_device_rules", + "target": "breadd_src_lua_mod_parse_match_condition", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1402", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_rules_toml", + "target": "breadd_src_lua_mod_lua_expand_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1403", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_rules_toml", + "target": "breadd_src_lua_mod_shell_quote", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1446", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_builtin_module_decls", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1450", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_is_lib_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1439", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_list_lua_files", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1437", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_luaengine_load_lua_file", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1512", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_luaengine_load_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1465", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_luaengine_scan_module_decl", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1452", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_module_name_from_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1490", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_order_module_decls", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1476", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_init_and_modules", + "target": "breadd_src_lua_mod_read_module_permissions", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1566", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_luaengine_load_lua_source", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1558", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_luaengine_load_out_of_process_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1570", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1575", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_luaengine_module_is_registered", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1579", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_luaengine_run_on_load", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1562", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_module", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1612", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_lua_file", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2920", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_is_lib_path", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3540", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_list_lua_files", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1642", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2209", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_scan_module_decl", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2911", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_name_from_path", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2943", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_read_module_permissions", + "target": "breadd_src_lua_mod_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1672", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_load_scoped_lua_file", + "target": "breadd_src_lua_mod_luaengine_build_scoped_env", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1724", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_build_scoped_env", + "target": "breadd_src_lua_mod_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3524", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_parse_match_condition", + "target": "breadd_src_lua_mod_rs_table", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1874", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "breadd_src_lua_mod_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1907", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "breadd_src_lua_mod_luaengine_handle_callback_error", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1886", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "breadd_src_lua_mod_luaengine_set_current_dispatch_id", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1881", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_event", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1921", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_timer", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2038", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "breadd_src_lua_mod_luaengine_remove_handler", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1943", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_load", + "target": "breadd_src_lua_mod_luaengine_get_module_hook", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1944", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_load", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1969", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_reload", + "target": "breadd_src_lua_mod_luaengine_get_module_hook", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1975", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_reload", + "target": "breadd_src_lua_mod_luaengine_module_is_builtin", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1981", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_reload", + "target": "breadd_src_lua_mod_luaengine_module_ungated", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1970", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_reload", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1995", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_unload", + "target": "breadd_src_lua_mod_luaengine_get_module_hook", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2001", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_unload", + "target": "breadd_src_lua_mod_luaengine_module_is_builtin", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2007", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_unload", + "target": "breadd_src_lua_mod_luaengine_module_ungated", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L1996", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_run_on_unload", + "target": "breadd_src_lua_mod_luaengine_set_current_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2034", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "breadd_src_lua_mod_luaengine_get_module_hook", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2016", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "breadd_src_lua_mod_luaengine_module_is_builtin", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2032", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "breadd_src_lua_mod_luaengine_module_ungated", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2014", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_handle_callback_error", + "target": "luaerror", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2051", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_get_module_hook", + "target": "breadd_src_lua_mod_rs_function", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2292", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_require_loader", + "target": "breadd_src_lua_mod_rs_function", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2416", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2401", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_fail", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2392", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_finish", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2424", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_list_json", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2376", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_register", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2415", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_status_json", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2385", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_step", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2408", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_luaengine_install_workflow_helpers", + "target": "breadd_src_lua_mod_workflow_timeout", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2599", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_register", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_get", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_set", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2825", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_list_json", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2811", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_remove", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2654", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_fail", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2640", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_finish", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2699", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_list_json", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_status_json", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2626", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_step", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2669", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_timeout", + "target": "breadd_src_lua_mod_rs_rwlock", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2687", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_status_json", + "target": "breadd_src_lua_mod_rs_jsonvalue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3020", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_get", + "target": "breadd_src_lua_mod_rs_jsonvalue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3036", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_module_store_set", + "target": "breadd_src_lua_mod_rs_jsonvalue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2825", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_list_json", + "target": "breadd_src_lua_mod_rs_jsonvalue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2699", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_workflow_list_json", + "target": "breadd_src_lua_mod_rs_jsonvalue", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2744", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_register", + "target": "breadd_src_lua_mod_widgetregisterargs", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2775", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_widget_update", + "target": "breadd_src_lua_mod_widgetupdateargs", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2979", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_json_to_lua", + "target": "breadd_src_lua_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2979", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_json_to_lua", + "target": "t", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3009", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_lua_mod_json_to_lua", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3588", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_query", + "target": "t", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3151", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_read_sync_toml", + "target": "breadd_src_lua_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L2991", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_state_value_to_lua", + "target": "breadd_src_lua_mod_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3071", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_expand_path", + "target": "breadd_src_lua_mod_dirs_home", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3108", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_machine_name", + "target": "breadd_src_lua_mod_lua_hostname", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3099", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_machine_name", + "target": "breadd_src_lua_mod_read_sync_toml", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3136", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_lua_machine_tags", + "target": "breadd_src_lua_mod_read_sync_toml", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3516", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_hyprland_request", + "target": "breadd_src_lua_mod_hyprland_request_socket", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3566", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_spawn", + "target": "breadd_src_lua_mod_rs_f", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3588", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_query", + "target": "breadd_src_lua_mod_rs_f", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3671", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_connect", + "target": "breadd_src_lua_mod_bluetooth_find_adapter", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3686", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_disconnect", + "target": "breadd_src_lua_mod_bluetooth_find_adapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3611", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_find_adapter", + "target": "breadd_src_lua_mod_rs_connection", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3654", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_get_powered", + "target": "breadd_src_lua_mod_bluetooth_find_adapter", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3636", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_set_powered", + "target": "breadd_src_lua_mod_bluetooth_find_adapter", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3701", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_set_scanning", + "target": "breadd_src_lua_mod_bluetooth_find_adapter", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/lua/mod.rs", + "source_location": "L3725", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_lua_mod_bluetooth_list_devices", + "target": "breadd_src_lua_mod_bluetoothdevice", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L23", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_main", + "target": "breadd_src_main_main", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L11", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_main", + "target": "breadd_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L150", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_main", + "target": "breadd_src_main_wait_for_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/main.rs", + "source_location": "L23", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_main_main", + "target": "breadd_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L101", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_activemodulehost", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L458", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_apply_sandbox", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L354", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_describe_exit", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L114", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_inner", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L647", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_landlock_denies_reads_outside_granted_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L86", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_modulehostoutcome", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L109", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L725", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_no_exec_permission_means_binary_cannot_be_executed_at_all", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L95", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_pendingmodulehost", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L616", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_resolve_bin_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L377", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_resolve_module_host_binary", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L66", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L68", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L79", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L350", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_short", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_spawn_module_host", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L771", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host", + "target": "breadd_src_module_host_which_sh", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L88", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostoutcome", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L98", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_pendingmodulehost", + "target": "breadd_src_module_host_modulehostoutcome", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostoutcome", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L354", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_describe_exit", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L116", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_inner", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L152", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_insert_active", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L132", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_insert_pending", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L96", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_module_host_pendingmodulehost", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L350", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_short", + "target": "breadd_src_module_host_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L115", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_inner", + "target": "breadd_src_module_host_pendingmodulehost", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L132", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_insert_pending", + "target": "breadd_src_module_host_pendingmodulehost", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L144", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_take_pending", + "target": "breadd_src_module_host_pendingmodulehost", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L98", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_module_host_pendingmodulehost", + "target": "breadd_src_module_host_rs_sender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L97", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_module_host_pendingmodulehost", + "target": "breadd_src_module_host_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L116", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_inner", + "target": "breadd_src_module_host_activemodulehost", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L110", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_inner", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L120", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_default", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L152", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_insert_active", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L132", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_insert_pending", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L126", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L160", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_remove_active", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L193", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_shutdown_all", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L144", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_take_pending", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L178", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_modulehostregistry_terminate_existing", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L110", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_rs_arc", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L119", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_rs_default", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L110", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry", + "target": "breadd_src_module_host_rs_mutex", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L116", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_src_module_host_inner", + "target": "breadd_src_module_host_rs_hashmap", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L472", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_apply_sandbox", + "target": "breadd_src_module_host_modulehostregistry_default", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L121", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_default", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L120", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_default", + "target": "breadd_src_module_host_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L126", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_new", + "target": "breadd_src_module_host_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L479", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_apply_sandbox", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L680", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_landlock_denies_reads_outside_granted_path", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L744", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_no_exec_permission_means_binary_cannot_be_executed_at_all", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L617", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_resolve_bin_path", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L254", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry_new", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L243", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry_insert_pending", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L144", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_modulehostregistry_take_pending", + "target": "breadd_src_module_host_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L291", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry_take_pending", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L354", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_describe_exit", + "target": "breadd_src_module_host_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L616", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_resolve_bin_path", + "target": "breadd_src_module_host_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L300", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry_insert_active", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L318", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry_remove_active", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L239", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_modulehostregistry_terminate_existing", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L274", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_apply_sandbox", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L319", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_describe_exit", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L252", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_resolve_module_host_binary", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L231", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_spawn_module_host", + "target": "breadd_src_module_host_rs_unboundedsender", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L458", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_apply_sandbox", + "target": "breadd_src_module_host_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L458", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_apply_sandbox", + "target": "breadd_src_module_host_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L354", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_src_module_host_describe_exit", + "target": "breadd_src_module_host_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L354", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_describe_exit", + "target": "exitstatus", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L377", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_resolve_module_host_binary", + "target": "breadd_src_module_host_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L616", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_src_module_host_resolve_bin_path", + "target": "breadd_src_module_host_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L771", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_src_module_host_which_sh", + "target": "breadd_src_module_host_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L579", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_apply_sandbox", + "target": "breadd_src_module_host_resolve_bin_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L693", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_landlock_denies_reads_outside_granted_path", + "target": "breadd_src_module_host_apply_sandbox", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L753", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_no_exec_permission_means_binary_cannot_be_executed_at_all", + "target": "breadd_src_module_host_apply_sandbox", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L665", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_landlock_denies_reads_outside_granted_path", + "target": "breadd_src_module_host_resolve_bin_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L679", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_landlock_denies_reads_outside_granted_path", + "target": "breadd_src_module_host_which_sh", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/src/module_host.rs", + "source_location": "L743", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_src_module_host_no_exec_permission_means_binary_cannot_be_executed_at_all", + "target": "breadd_src_module_host_which_sh", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L821", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L454", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L357", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L479", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L253", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L294", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L277", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L92", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_event_errors", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L385", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L184", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L104", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L412", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L129", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L160", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L434", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1062", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L902", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L871", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L989", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L749", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L674", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L541", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_modules_list_returns_array", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L808", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_modules_reload_succeeds", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L955", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L15", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1518", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_poll_workflow_status", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L53", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_profile_activate_updates_state", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L78", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L3", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L9", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_rs_tempdir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1299", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1447", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1329", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L577", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L527", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L505", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1543", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_testharness", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L36", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_unknown_method_returns_error", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1502", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_wait_for_file", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1268", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1203", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1240", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration", + "target": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L15", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L16", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L17", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_ping_and_state_dump_work", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L821", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L454", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L357", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L479", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L253", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L294", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L277", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L92", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_event_errors", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L385", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L184", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L104", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L412", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L129", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L160", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L434", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1062", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L902", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L871", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L989", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L749", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L674", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L541", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_list_returns_array", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L808", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_reload_succeeds", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L955", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1518", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_poll_workflow_status", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L53", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_updates_state", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L78", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1299", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1447", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1329", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L577", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L527", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L505", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1722", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_send_request", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1550", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1554", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1562", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1630", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1794", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1757", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1707", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L36", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_unknown_method_returns_error", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1502", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_wait_for_file", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1268", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1203", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1240", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "target": "breadd_tests_ipc_integration_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L40", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_unknown_method_returns_error", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_unknown_method_returns_error", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L37", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_unknown_method_returns_error", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_unknown_method_returns_error", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L57", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_updates_state", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L73", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_updates_state", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L54", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_updates_state", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L55", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_updates_state", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L82", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L79", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L80", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_profile_activate_without_name_errors", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L96", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_event_errors", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L99", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_event_errors", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L93", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_event_errors", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L94", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_event_errors", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L111", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L124", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L105", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L106", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_adapter_owned_event_name", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L146", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L155", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L130", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L131", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_every_adapter_owned_domain", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L167", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L179", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L161", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L162", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_allows_custom_event_names", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L214", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L248", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L188", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L185", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L186", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_is_tagged_manual_not_system", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L259", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L272", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L254", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L255", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_internal_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L281", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L289", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L278", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L279", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_unregistered_app_source_is_rejected", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L315", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L352", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L298", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L295", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L296", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_known_app_source_routes_through_normalizer", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L363", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L380", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L358", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L359", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_rejects_wrong_namespace", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L392", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L407", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L386", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L387", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_allows_well_formed_command_event", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L418", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L429", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L413", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L414", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_rejects_command_to_non_app", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L438", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L449", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L435", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L436", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_without_source_still_rejects_hyprland_namespace", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L459", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L474", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L455", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L456", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_allows_command_to_another_app", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L485", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L500", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L480", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L481", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_emit_with_app_source_still_rejects_foreign_app_namespace", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L509", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L522", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L506", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L507", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_returns_specific_subtree", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L531", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L536", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L528", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L529", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_state_get_missing_key_returns_error", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L545", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_list_returns_array", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L548", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_list_returns_array", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L542", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_list_returns_array", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L543", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_list_returns_array", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L614", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L664", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L610", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L637", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L612", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L611", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_scoped_module_sees_only_granted_state_read_permission", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L699", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L734", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L687", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L697", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L688", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_module_with_no_manifest_keeps_full_access_but_is_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L776", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L803", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L772", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L797", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L774", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L773", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_explicit_empty_permissions_is_scoped_but_not_flagged_ungated", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L812", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_reload_succeeds", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L816", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_reload_succeeds", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L809", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_reload_succeeds", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L810", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_modules_reload_succeeds", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L826", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L866", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L822", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L823", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_daemon_survives_repeated_reloads_and_pipeline_resumes", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L876", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L897", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L872", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L873", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_replay_returns_buffered_events", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L924", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L950", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L906", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L903", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L904", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_stream_filter_excludes_non_matching_events", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L984", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L958", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L956", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L957", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_multiple_concurrent_clients_each_get_response", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1026", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1050", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L993", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L990", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L991", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_events_stream_receives_emitted_events", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1111", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1198", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1083", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1063", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1081", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_event_causality_chain_threads_caused_by_across_handlers", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1232", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "target": "breadd_tests_ipc_integration_poll_workflow_status", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1222", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1235", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1204", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1220", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_reaches_done_via_wait_any_happy_path", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1260", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "target": "breadd_tests_ipc_integration_poll_workflow_status", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1256", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1263", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1241", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1254", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_times_out_when_deadline_exceeded", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1287", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "target": "breadd_tests_ipc_integration_poll_workflow_status", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1283", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1294", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1269", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1281", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_workflow_captures_error_on_failure", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1306", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1324", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1303", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1304", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_absent_is_a_no_op", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1383", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1442", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1376", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1380", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1405", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_well_formed_all_action_kinds_work_end_to_end", + "target": "breadd_tests_ipc_integration_wait_for_file", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1464", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1495", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1458", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1462", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_rules_toml_malformed_rule_surfaces_doctor_visible_error", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1502", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_wait_for_file", + "target": "breadd_tests_ipc_integration_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1703", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_socket_path", + "target": "breadd_tests_ipc_integration_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1518", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_poll_workflow_status", + "target": "breadd_tests_ipc_integration_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1525", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_poll_workflow_status", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1518", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_poll_workflow_status", + "target": "testharness", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1722", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_send_request", + "target": "breadd_tests_ipc_integration_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1794", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "target": "breadd_tests_ipc_integration_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1545", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_rs_child", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1828", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_rs_drop", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1546", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1544", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_rs_tempdir", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1840", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_drop", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1722", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1822", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1703", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1550", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1554", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1562", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1630", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1794", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1757", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1707", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness", + "target": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1550", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn", + "target": "breadd_tests_ipc_integration_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1551", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1608", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1687", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "target": "breadd_tests_ipc_integration_testharness_spawn", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1554", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "target": "breadd_tests_ipc_integration_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1562", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "target": "breadd_tests_ipc_integration_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1630", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "target": "breadd_tests_ipc_integration_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1555", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init", + "target": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1562", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_init_and_rules", + "target": "breadd_tests_ipc_integration_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1630", + "weight": 1.0, + "context": "parameter_type", + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_spawn_with_module", + "target": "breadd_tests_ipc_integration_rs_option", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1723", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_send_request", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1795", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "target": "breadd_tests_ipc_integration_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1711", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_wait_until_ready", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1808", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_trigger_and_await_result", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1763", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_wait_for_module_loaded", + "target": "breadd_tests_ipc_integration_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/ipc_integration.rs", + "source_location": "L1824", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_ipc_integration_testharness_shutdown", + "target": "breadd_tests_ipc_integration_testharness_drop", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L438", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L291", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L24", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "breadd_tests_module_host_sandbox_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L30", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "breadd_tests_module_host_sandbox_rs_tempdir", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L47", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox", + "target": "breadd_tests_module_host_sandbox_testharness", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L49", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_rs_child", + "confidence_score": 1.0 + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L252", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_rs_drop", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L52", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L48", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_rs_tempdir", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L260", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_drop", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L212", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_find_module_host_pid", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L183", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L244", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L60", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_spawn_with_modules", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L156", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L137", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness", + "target": "breadd_tests_module_host_sandbox_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L465", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_spawn_with_modules", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L378", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_testharness_spawn_with_modules", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L60", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_spawn_with_modules", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L60", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_spawn_with_modules", + "target": "breadd_tests_module_host_sandbox_rs_self", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L438", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L291", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L212", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_find_module_host_pid", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L183", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_send_request", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L156", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_wait_for_module_loaded", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L137", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_wait_until_ready", + "target": "breadd_tests_module_host_sandbox_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L473", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L388", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L184", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_send_request", + "target": "breadd_tests_module_host_sandbox_testharness_socket_path", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L133", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_socket_path", + "target": "breadd_tests_module_host_sandbox_rs_path", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L469", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L379", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_testharness_wait_until_ready", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L141", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_wait_until_ready", + "target": "breadd_tests_module_host_sandbox_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L470", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L386", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_testharness_wait_for_module_loaded", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L162", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_wait_for_module_loaded", + "target": "breadd_tests_module_host_sandbox_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L496", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L401", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_testharness_send_request", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L183", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_send_request", + "target": "breadd_tests_module_host_sandbox_rs_value", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L491", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_find_module_host_pid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L560", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_killing_a_module_host_child_does_not_take_down_breadd_or_other_modules", + "target": "breadd_tests_module_host_sandbox_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L431", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_os_execute_and_io_open_are_denied_at_the_kernel_level_outside_granted_scope", + "target": "breadd_tests_module_host_sandbox_testharness_shutdown", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "breadd/tests/module_host_sandbox.rs", + "source_location": "L248", + "weight": 1.0, + "_origin": "ast", + "source": "breadd_tests_module_host_sandbox_testharness_shutdown", + "target": "breadd_tests_module_host_sandbox_testharness_drop", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "ci/build.sh", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "source": "ci_build", + "target": "ci_build_sh__entry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L14", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_active_window_widget", + "target": "examples_modules_active_window_widget_label_for", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_active_window_widget", + "target": "examples_modules_active_window_widget_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L29", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_active_window_widget", + "target": "examples_modules_active_window_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L30", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_active_window_widget_widget_root", + "target": "examples_modules_active_window_widget_label_for", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/active-window-widget.lua", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_active_window_widget_m_on_load", + "target": "examples_modules_active_window_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/bluetooth-toggle-widget.lua", + "source_location": "L43", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_bluetooth_toggle_widget", + "target": "examples_modules_bluetooth_toggle_widget_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/bluetooth-toggle-widget.lua", + "source_location": "L14", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_bluetooth_toggle_widget", + "target": "examples_modules_bluetooth_toggle_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/bluetooth-toggle-widget.lua", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_bluetooth_toggle_widget_m_on_load", + "target": "examples_modules_bluetooth_toggle_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L60", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_cpu_temp_widget_init", + "target": "examples_modules_cpu_temp_widget_init_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L32", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_cpu_temp_widget_init", + "target": "examples_modules_cpu_temp_widget_init_read_temp_c", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L40", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_cpu_temp_widget_init", + "target": "examples_modules_cpu_temp_widget_init_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L65", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_cpu_temp_widget_init_m_on_load", + "target": "examples_modules_cpu_temp_widget_init_read_temp_c", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/cpu-temp-widget/init.lua", + "source_location": "L65", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_cpu_temp_widget_init_m_on_load", + "target": "examples_modules_cpu_temp_widget_init_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/dock-monitors.lua", + "source_location": "L21", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_dock_monitors", + "target": "examples_modules_dock_monitors_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/dock-workflow.lua", + "source_location": "L44", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_dock_workflow", + "target": "examples_modules_dock_workflow_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L132", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_apply", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L103", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_apply_monitor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L87", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_connected", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L58", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_drm_first_mode", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_drm_status", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L28", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_inhibit_lid", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L44", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_is_internal", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L71", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_list_connectors", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L166", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L38", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors", + "target": "examples_modules_external_monitors_release_lid", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L91", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors_connected", + "target": "examples_modules_external_monitors_is_internal", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L202", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors_m_on_load", + "target": "examples_modules_external_monitors_is_internal", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L90", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors_connected", + "target": "examples_modules_external_monitors_drm_status", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L153", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors_apply", + "target": "examples_modules_external_monitors_drm_first_mode", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L89", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors_connected", + "target": "examples_modules_external_monitors_list_connectors", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/external-monitors.lua", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_external_monitors_apply", + "target": "examples_modules_external_monitors_apply_monitor", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L22", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_focus_mode_widget", + "target": "examples_modules_focus_mode_widget_is_focused", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L35", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_focus_mode_widget", + "target": "examples_modules_focus_mode_widget_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L26", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_focus_mode_widget", + "target": "examples_modules_focus_mode_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L54", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_focus_mode_widget_m_on_load", + "target": "examples_modules_focus_mode_widget_is_focused", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L30", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_focus_mode_widget_widget_root", + "target": "examples_modules_focus_mode_widget_is_focused", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/focus-mode-widget.lua", + "source_location": "L40", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_focus_mode_widget_m_on_load", + "target": "examples_modules_focus_mode_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget", + "target": "examples_modules_git_branch_widget_focused_tab_cwd", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L88", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget", + "target": "examples_modules_git_branch_widget_git_info", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L133", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget", + "target": "examples_modules_git_branch_widget_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L41", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget", + "target": "examples_modules_git_branch_widget_shell_quote", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L122", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget", + "target": "examples_modules_git_branch_widget_update", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L111", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget", + "target": "examples_modules_git_branch_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L89", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_git_info", + "target": "examples_modules_git_branch_widget_shell_quote", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L134", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_m_on_load", + "target": "examples_modules_git_branch_widget_focused_tab_cwd", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L123", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_update", + "target": "examples_modules_git_branch_widget_focused_tab_cwd", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L135", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_m_on_load", + "target": "examples_modules_git_branch_widget_git_info", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L124", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_update", + "target": "examples_modules_git_branch_widget_git_info", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L142", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_m_on_load", + "target": "examples_modules_git_branch_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/git-branch-widget.lua", + "source_location": "L129", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_git_branch_widget_update", + "target": "examples_modules_git_branch_widget_widget_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/low-battery-warning.lua", + "source_location": "L11", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_low_battery_warning", + "target": "examples_modules_low_battery_warning_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/pause-media-on-headphone-unplug.lua", + "source_location": "L8", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_pause_media_on_headphone_unplug", + "target": "examples_modules_pause_media_on_headphone_unplug_looks_like_headphones", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/pause-media-on-headphone-unplug.lua", + "source_location": "L17", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_pause_media_on_headphone_unplug", + "target": "examples_modules_pause_media_on_headphone_unplug_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/pause-media-on-headphone-unplug.lua", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_pause_media_on_headphone_unplug_m_on_load", + "target": "examples_modules_pause_media_on_headphone_unplug_looks_like_headphones", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L63", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_workflow_status_widget", + "target": "examples_modules_workflow_status_widget_m_on_load", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L20", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_workflow_status_widget", + "target": "examples_modules_workflow_status_widget_most_relevant", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_workflow_status_widget", + "target": "examples_modules_workflow_status_widget_widget_update", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L32", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_workflow_status_widget_widget_update", + "target": "examples_modules_workflow_status_widget_most_relevant", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "examples/modules/workflow-status-widget.lua", + "source_location": "L64", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_workflow_status_widget_m_on_load", + "target": "examples_modules_workflow_status_widget_widget_update", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "scripts/install.sh", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "source": "scripts_install", + "target": "scripts_install_sh__entry", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L20", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "xtask_src_main", + "target": "btreeset", + "confidence_score": 1.0 + }, + { + "relation": "imports_from", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L22", + "weight": 1.0, + "context": "import", + "_origin": "ast", + "source": "xtask_src_main", + "target": "exitcode", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L481", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L396", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_checkreport", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L756", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_clean_state_passes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L346", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extract_cli_commands", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L315", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extract_enum_variants", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L230", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extract_ipc_methods", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L158", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extract_lua_bindings", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L839", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extracts_cli_commands_with_subcommand_groups_dotted", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L743", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extracts_ipc_methods_without_leaking_nested_match_arms", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L724", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_extracts_lua_bindings_precisely", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L704", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L143", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_ident_at", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L152", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_ident_upto_quote", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L381", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_ipc_section", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L295", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_kebab", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L832", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_kebab_converts_pascal_case_correctly", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L377", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_lua_api_section", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L27", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_main", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L804", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_missing_doc_heading_is_caught_as_drift", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L875", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_missing_readme_cli_line_is_caught_as_drift", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L388", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_readme_cli_section", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L786", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_removed_ipc_method_is_caught_as_drift", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L852", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_renamed_cli_command_is_caught_as_drift", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L762", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_renamed_schema_entry_is_caught_as_drift", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L76", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_repo_root", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L55", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_run_check_docs", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L90", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_schema", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L694", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_schema_toml_for", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L96", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_schemaentry", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L366", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_section", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L822", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_unknown_kind_is_rejected", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L49", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main", + "target": "xtask_src_main_usage", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L27", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_main", + "target": "exitcode", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L30", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_main", + "target": "xtask_src_main_run_check_docs", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L71", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_run_check_docs", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L73", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_run_check_docs", + "target": "xtask_src_main_checkreport_is_clean", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L56", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_run_check_docs", + "target": "xtask_src_main_repo_root", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L55", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_run_check_docs", + "target": "xtask_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L481", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L76", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_repo_root", + "target": "xtask_src_main_rs_result", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L76", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_repo_root", + "target": "xtask_src_main_rs_pathbuf", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L92", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "xtask_src_main_schema", + "target": "xtask_src_main_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L92", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_schema", + "target": "xtask_src_main_schemaentry", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L410", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "xtask_src_main_checkreport", + "target": "xtask_src_main_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L315", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_extract_enum_variants", + "target": "xtask_src_main_rs_vec", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L100", + "weight": 1.0, + "context": "field", + "_origin": "ast", + "source": "xtask_src_main_schemaentry", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L410", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_checkreport", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L346", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_extract_cli_commands", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L315", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_extract_enum_variants", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L230", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_extract_ipc_methods", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L158", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_extract_lua_bindings", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L704", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_full_schema", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L295", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_kebab", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L694", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_schema_toml_for", + "target": "xtask_src_main_rs_string", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L189", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extract_lua_bindings", + "target": "xtask_src_main_ident_at", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L163", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extract_lua_bindings", + "target": "xtask_src_main_ident_upto_quote", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L508", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_extract_lua_bindings", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L158", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_extract_lua_bindings", + "target": "btreeset", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L725", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extracts_lua_bindings_precisely", + "target": "xtask_src_main_extract_lua_bindings", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L346", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_extract_cli_commands", + "target": "btreeset", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L230", + "weight": 1.0, + "context": "return_type", + "_origin": "ast", + "source": "xtask_src_main_extract_ipc_methods", + "target": "btreeset", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L523", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_extract_ipc_methods", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L744", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extracts_ipc_methods_without_leaking_nested_match_arms", + "target": "xtask_src_main_extract_ipc_methods", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L350", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extract_cli_commands", + "target": "xtask_src_main_kebab", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L348", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extract_cli_commands", + "target": "xtask_src_main_extract_enum_variants", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L542", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_extract_cli_commands", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L840", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_extracts_cli_commands_with_subcommand_groups_dotted", + "target": "xtask_src_main_extract_cli_commands", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L382", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_ipc_section", + "target": "xtask_src_main_section", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L378", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_lua_api_section", + "target": "xtask_src_main_section", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L389", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_readme_cli_section", + "target": "xtask_src_main_section", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L562", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_lua_api_section", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L563", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_ipc_section", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L581", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_readme_cli_section", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L481", + "weight": 1.0, + "context": "generic_arg", + "_origin": "ast", + "source": "xtask_src_main_check", + "target": "xtask_src_main_checkreport", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L414", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_checkreport", + "target": "xtask_src_main_checkreport_is_clean", + "confidence_score": 1.0 + }, + { + "relation": "method", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L423", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_checkreport", + "target": "xtask_src_main_checkreport_print", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L424", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_checkreport_print", + "target": "xtask_src_main_checkreport_is_clean", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L757", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_clean_state_passes", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L806", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_missing_doc_heading_is_caught_as_drift", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L880", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_missing_readme_cli_line_is_caught_as_drift", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L788", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_removed_ipc_method_is_caught_as_drift", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L856", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_renamed_cli_command_is_caught_as_drift", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L767", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_renamed_schema_entry_is_caught_as_drift", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L824", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_unknown_kind_is_rejected", + "target": "xtask_src_main_check", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L705", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_full_schema", + "target": "xtask_src_main_schema_toml_for", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L823", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_unknown_kind_is_rejected", + "target": "xtask_src_main_schema_toml_for", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L757", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_clean_state_passes", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L810", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_missing_doc_heading_is_caught_as_drift", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L884", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_missing_readme_cli_line_is_caught_as_drift", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L792", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_removed_ipc_method_is_caught_as_drift", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L860", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_renamed_cli_command_is_caught_as_drift", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "calls", + "context": "call", + "confidence": "EXTRACTED", + "source_file": "xtask/src/main.rs", + "source_location": "L771", + "weight": 1.0, + "_origin": "ast", + "source": "xtask_src_main_renamed_schema_entry_is_caught_as_drift", + "target": "xtask_src_main_full_schema", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "AGENTS.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "source": "agents", + "target": "agents_agents_md_repo_hygiene", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "AGENTS.md", + "source_location": "L22", + "weight": 1.0, + "_origin": "ast", + "source": "agents_agents_md_repo_hygiene", + "target": "agents_ci", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "AGENTS.md", + "source_location": "L39", + "weight": 1.0, + "_origin": "ast", + "source": "agents_agents_md_repo_hygiene", + "target": "agents_don_t", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "AGENTS.md", + "source_location": "L31", + "weight": 1.0, + "_origin": "ast", + "source": "agents_agents_md_repo_hygiene", + "target": "agents_local_architecture_still_true", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "AGENTS.md", + "source_location": "L16", + "weight": 1.0, + "_origin": "ast", + "source": "agents_agents_md_repo_hygiene", + "target": "agents_remotes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CLAUDE.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "source": "claude", + "target": "claude_claude_md_repo_hygiene", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CLAUDE.md", + "source_location": "L14", + "weight": 1.0, + "_origin": "ast", + "source": "claude_claude_md_repo_hygiene", + "target": "claude_ci", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CLAUDE.md", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "claude_claude_md_repo_hygiene", + "target": "claude_don_t", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CLAUDE.md", + "source_location": "L10", + "weight": 1.0, + "_origin": "ast", + "source": "claude_claude_md_repo_hygiene", + "target": "claude_remotes", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "DEPRECATIONS.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "source": "deprecations", + "target": "deprecations_deprecations", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "DEPRECATIONS.md", + "source_location": "L4", + "weight": 1.0, + "_origin": "ast", + "source": "deprecations", + "target": "documentation", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "DEPRECATIONS.md", + "source_location": "L8", + "weight": 1.0, + "_origin": "ast", + "source": "deprecations_deprecations", + "target": "deprecations_hyprland_legacy_flat_event_names_since_v1_5", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "examples/modules/README.md", + "source_location": "L19", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_readme", + "target": "documentation", + "confidence_score": 1.0 + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "examples/modules/README.md", + "source_location": "L4", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_readme", + "target": "examples", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/README.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_readme", + "target": "examples_modules_readme_example_bread_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/README.md", + "source_location": "L7", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_readme_example_bread_modules", + "target": "examples_modules_readme_installing", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "examples/modules/README.md", + "source_location": "L33", + "weight": 1.0, + "_origin": "ast", + "source": "examples_modules_readme_example_bread_modules", + "target": "examples_modules_readme_modules", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "packaging/README.md", + "source_location": "L17", + "weight": 1.0, + "_origin": "ast", + "source": "packaging_readme", + "target": "packaging_readme_systemd_user_service", + "confidence_score": 1.0 + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing", + "target": "contributing_contributing" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L8", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_contributing", + "target": "contributing_branches" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L94", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_contributing", + "target": "contributing_ci" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L63", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_contributing", + "target": "contributing_local_development" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L106", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_contributing", + "target": "contributing_questions" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L26", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_contributing", + "target": "contributing_the_release_cycle" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L43", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_contributing", + "target": "contributing_tracks_from_a_user_s_perspective" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "CONTRIBUTING.md", + "source_location": "L70", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "contributing_local_development", + "target": "contributing_keeping_the_api_docs_honest" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation", + "target": "documentation_bread_documentation" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L742", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation", + "target": "examples" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L181", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme", + "target": "documentation" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L37", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_api_stability_versioning" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L223", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_capability_scoped_modules_since_v1_5" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L3", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_contents" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L638", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_debugging_tips" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1165", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_dictionary_built_in_modules" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1373", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_dictionary_event_reference" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1700", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_dictionary_ipc_protocol" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L651", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_dictionary_lua_api" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1615", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_dictionary_runtime_state_schema" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L48", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_getting_started" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1598", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_integrating_a_bread_app" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L169", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_modules_install_and_manage" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1582", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_namespaces" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L351", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_out_of_process_module_sandboxing_since_v1_6" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L25", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_overview" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L157", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_run_reload_and_watch" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L127", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_documentation", + "target": "documentation_your_first_module" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L50", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_getting_started", + "target": "documentation_1_create_a_minimal_config" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L57", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_getting_started", + "target": "documentation_2_the_fast_path_rules_toml_since_v1_5" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L102", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_getting_started", + "target": "documentation_3_minimal_init_lua" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L111", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_getting_started", + "target": "documentation_4_start_the_daemon" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L120", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_getting_started", + "target": "documentation_5_check_that_it_s_running" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L241", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_capability_scoped_modules_since_v1_5", + "target": "documentation_baseline_always_available_no_manifest_entry_needed" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L334", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_capability_scoped_modules_since_v1_5", + "target": "documentation_bread_modules_audit_name" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L251", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_capability_scoped_modules_since_v1_5", + "target": "documentation_gated_requires_a_matching_permissions_entry" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L296", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_capability_scoped_modules_since_v1_5", + "target": "documentation_path_bin_enforcement_depends_on_where_the_module_runs" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L317", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_capability_scoped_modules_since_v1_5", + "target": "documentation_require_bread_devices_still_works_from_a_scoped_module" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L387", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_architecture" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L564", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_crash_isolation" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L583", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_new_ipc_methods" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L521", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_rpc_bridge_coverage" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L353", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_the_gap_this_closes" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L450", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_the_landlock_sandbox" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L424", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_the_token_identity_handshake" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L592", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_what_s_implemented_vs_deferred" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L372", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_out_of_process_module_sandboxing_since_v1_6", + "target": "documentation_what_still_runs_in_process" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1051", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_bluetooth" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L671", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_events" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L916", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_execution" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1023", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_hyprland" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L986", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_machine_and_filesystem" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L655", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_module_declaration" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1128", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_module_lifecycle_hooks" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1152", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_module_storage" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L944", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_notifications" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L911", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_profiles" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L878", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_state" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L960", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_timers" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L971", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_utilities" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L779", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_widgets_since_v1_3" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L740", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_lua_api", + "target": "documentation_workflows_since_v1_2" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L704", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_emit_event_data" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L688", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_filter_pattern_fn_opts_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L701", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_off_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L673", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_on_pattern_fn_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L685", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_once_pattern_fn_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L719", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_spawn_fn" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L737", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_wait_all_patterns_opts_table_since_v1_2" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L722", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_wait_any_patterns_opts_event_nil_since_v1_2" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L707", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_events", + "target": "documentation_bread_wait_pattern_opts_event_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L744", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_workflows_since_v1_2", + "target": "documentation_bread_workflow_define_name_fn" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L776", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_workflows_since_v1_2", + "target": "documentation_bread_workflow_list_table" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L747", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_workflows_since_v1_2", + "target": "documentation_bread_workflow_start_name_opts" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L760", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_workflows_since_v1_2", + "target": "documentation_bread_workflow_status_name_table_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L757", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_workflows_since_v1_2", + "target": "documentation_bread_workflow_step_label" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L863", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_widgets_since_v1_3", + "target": "documentation_bread_widget_list_table" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L785", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_widgets_since_v1_3", + "target": "documentation_bread_widget_register_spec_ok_err" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L860", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_widgets_since_v1_3", + "target": "documentation_bread_widget_remove_id_bool" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L851", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_widgets_since_v1_3", + "target": "documentation_bread_widget_update_id_patch_ok_err" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L799", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_widget_register_spec_ok_err", + "target": "documentation_node_types" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L827", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_widget_register_spec_ok_err", + "target": "documentation_style_since_v1_4" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L847", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_widget_register_spec_ok_err", + "target": "documentation_style_vs_class" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L866", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_widget_list_table", + "target": "documentation_click_events" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L880", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_state", + "target": "documentation_bread_state_get_path" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L900", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_state", + "target": "documentation_bread_state_watch_path_fn_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L888", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_state", + "target": "documentation_typed_shorthands" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L913", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_profiles", + "target": "documentation_bread_profile_activate_name" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L921", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_execution", + "target": "documentation_bread_exec_capture_cmd_opts_ok_stdout" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L918", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_execution", + "target": "documentation_bread_exec_cmd" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L946", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_notifications", + "target": "documentation_bread_notify_message_opts" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L962", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_timers", + "target": "documentation_bread_after_delay_ms_fn_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L968", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_timers", + "target": "documentation_bread_cancel_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L965", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_timers", + "target": "documentation_bread_every_interval_ms_fn_id" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L973", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_utilities", + "target": "documentation_bread_debounce_delay_ms_fn_wrapped_fn" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L983", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_utilities", + "target": "documentation_bread_log_msg_bread_warn_msg_bread_error_msg" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1006", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_fs_exists_path_bool" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1015", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_fs_expand_path_string" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1003", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_fs_read_path_string_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1009", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_fs_readlink_path_string_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1000", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_fs_write_path_content" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1018", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_json_decode_str_table_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L997", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_machine_has_tag_tag_bool" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L988", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_machine_name_string" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L993", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_machine_and_filesystem", + "target": "documentation_bread_machine_tags_string" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1067", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_bread_bluetooth_connect_address" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1080", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_bread_bluetooth_devices_table_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1074", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_bread_bluetooth_disconnect_address" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1055", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_bread_bluetooth_power_enabled" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1058", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_bread_bluetooth_powered_bool_nil" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1077", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_bread_bluetooth_scan_enabled" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1102", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_example_auto_connect_headphones_on_ac_power" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1120", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bluetooth", + "target": "documentation_example_turn_off_bluetooth_on_battery" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1350", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_built_in_modules", + "target": "documentation_bread_binds" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1226", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_built_in_modules", + "target": "documentation_bread_devices" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1200", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_built_in_modules", + "target": "documentation_bread_monitors" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1169", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_built_in_modules", + "target": "documentation_bread_rules_since_v1_5" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1333", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_built_in_modules", + "target": "documentation_bread_workspaces" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1264", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_devices", + "target": "documentation_device_rule_options" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1309", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_devices", + "target": "documentation_example_dock_specific_setup" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1296", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_devices", + "target": "documentation_example_keyboard_configuration_on_connect" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1258", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_bread_devices", + "target": "documentation_functions" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1400", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_event_reference", + "target": "documentation_normalized_events" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1391", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_dictionary_event_reference", + "target": "documentation_pattern_matching" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1427", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_bluetooth_bluez" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1409", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_devices_udev_bluetooth" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1541", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_filesystem_project_detection" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1529", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_git_hooks_dirty_state_poller" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1440", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_hyprland_1440" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1491", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_network" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1561", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_podman_containers" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1479", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_power" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1571", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_remote_ssh_session_detection" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1402", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_system" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1498", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_system_events" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1551", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_systemd_systemd_user_units" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1517", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_terminal_shell_precmd_preexec_hooks" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1506", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_normalized_events", + "target": "documentation_widgets_since_v1_3_1506" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Documentation.md", + "source_location": "L1470", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "documentation_hyprland_1440", + "target": "documentation_compatibility_compat_config" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples", + "target": "examples_bread_examples" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L7", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples_bread_examples", + "target": "examples_example_1_porting_keyboard_and_display_watcher_sh_system_script" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L93", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples_bread_examples", + "target": "examples_example_2_porting_autostart_lua" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L130", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples_bread_examples", + "target": "examples_example_3_porting_display_monitors_lua" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L182", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples_bread_examples", + "target": "examples_example_4_multi_step_automation_workflows" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L241", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples_bread_examples", + "target": "examples_example_5_a_live_widget_in_breadbar" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "Examples.md", + "source_location": "L313", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "examples_bread_examples", + "target": "examples_tips_for_porting_your_own_scripts" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L1", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme", + "target": "readme_bread" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L42", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_architecture" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L199", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_cli_reference" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L120", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_configuration" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L315", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_contributing" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L303", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_event_reference_lua_api_and_ipc_protocol" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L13", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_how_it_works" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L76", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_installation" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L323", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_license" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L244", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_module_system" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L62", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_bread", + "target": "readme_requirements" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L78", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_installation", + "target": "readme_from_source" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L109", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_installation", + "target": "readme_systemd_user_service" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L101", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_installation", + "target": "readme_via_bakery" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L248", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_module_system", + "target": "readme_installing_modules" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "source_file": "README.md", + "source_location": "L269", + "weight": 1.0, + "_origin": "ast", + "confidence_score": 1.0, + "source": "readme_module_system", + "target": "readme_writing_a_module" + }, + { + "relation": "configures", + "confidence": "EXTRACTED", + "reasoning": "breadd.toml configuration file controls daemon behavior and adapter settings", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "config_breadd_toml", + "target": "sys_bread_daemon" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Daemon controls Bluetooth via BlueZ adapter", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "adapter_bluetooth" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Daemon ingests signals from Hyprland adapter as documented in README and Documentation", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "adapter_hyprland" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Daemon monitors network connectivity via network adapter", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "adapter_network" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Daemon monitors power state via power adapter", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "adapter_power" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Daemon monitors USB/input devices via udev adapter", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "adapter_udev" + }, + { + "relation": "maintains", + "confidence": "EXTRACTED", + "reasoning": "Daemon maintains the complete RuntimeState and exposes it via IPC", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "state_runtime_schema" + }, + { + "relation": "communicates_with", + "confidence": "EXTRACTED", + "reasoning": "CLI talks to daemon over Unix socket at $XDG_RUNTIME_DIR/bread/breadd.sock", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "sys_bread_cli" + }, + { + "relation": "contains", + "confidence": "EXTRACTED", + "reasoning": "Lua runtime is a dedicated thread inside the daemon", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_daemon", + "target": "sys_lua_runtime" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "CLI communicates with daemon using newline-delimited JSON IPC protocol", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_bread_cli", + "target": "ipc_protocol" + }, + { + "relation": "initializes", + "confidence": "EXTRACTED", + "reasoning": "init.lua is the entry point loaded first by the Lua runtime", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "config_init_lua", + "target": "sys_lua_runtime" + }, + { + "relation": "provides", + "confidence": "EXTRACTED", + "reasoning": "modules/ directory auto-discovered and loaded by Lua runtime after init.lua", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "config_modules_dir", + "target": "sys_lua_runtime" + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "reasoning": "Lua runtime provides bread.on API for module event subscriptions", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_lua_runtime", + "target": "api_bread_on" + }, + { + "relation": "loads", + "confidence": "EXTRACTED", + "reasoning": "Built-in devices module is loaded by the Lua runtime", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_lua_runtime", + "target": "module_devices" + }, + { + "relation": "loads", + "confidence": "EXTRACTED", + "reasoning": "Built-in modules are loaded by the Lua runtime before user modules", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "sys_lua_runtime", + "target": "module_monitors" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Hyprland adapter detects and emits monitor connection events", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_hyprland", + "target": "event_monitor_connected" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Hyprland adapter emits monitor disconnection events", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_hyprland", + "target": "event_monitor_disconnected" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Hyprland adapter monitors window creation and emits window opened events", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_hyprland", + "target": "event_window_opened" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Hyprland adapter emits workspace change events", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_hyprland", + "target": "event_workspace_changed" + }, + { + "relation": "differs_from", + "confidence": "INFERRED", + "reasoning": "App namespace convention is for sibling bread* apps; daemon-internal domains like hyprland have their own reservation", + "source_file": "Documentation.md", + "confidence_score": 0.5, + "_origin": "semantic", + "source": "app_namespace_convention", + "target": "adapter_hyprland" + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "reasoning": "Event-driven architecture is implemented through adapters like Hyprland", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "pattern_event_driven", + "target": "adapter_hyprland" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "udev adapter emits device connection events when hardware connects", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_udev", + "target": "event_device_connected" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "udev adapter emits device disconnection events when hardware disconnects", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_udev", + "target": "event_device_disconnected" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Power adapter detects AC power connection and emits event", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_power", + "target": "event_power_ac_connected" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Power adapter monitors battery level and emits low battery event", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_power", + "target": "event_power_battery_low" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Network adapter emits connection established event", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_network", + "target": "event_network_connected" + }, + { + "relation": "emits", + "confidence": "EXTRACTED", + "reasoning": "Bluetooth adapter emits device paired event when BlueZ learns about a device", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "adapter_bluetooth", + "target": "event_bluetooth_device_paired" + }, + { + "relation": "subscribes_to", + "confidence": "EXTRACTED", + "reasoning": "Monitors module listens for monitor connection events to apply layouts", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "module_monitors", + "target": "event_monitor_connected" + }, + { + "relation": "subscribes_to", + "confidence": "EXTRACTED", + "reasoning": "Devices module matches device connection events against configured rules", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "module_devices", + "target": "event_device_connected" + }, + { + "relation": "subscribes_to", + "confidence": "EXTRACTED", + "reasoning": "Devices module handles device disconnection events", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "module_devices", + "target": "event_device_disconnected" + }, + { + "relation": "subscribes_to", + "confidence": "INFERRED", + "reasoning": "Workspaces module likely responds to workspace changes to maintain assignments", + "source_file": "Documentation.md", + "confidence_score": 0.5, + "_origin": "semantic", + "source": "module_workspaces", + "target": "event_workspace_changed" + }, + { + "relation": "complements", + "confidence": "INFERRED", + "reasoning": "bread.wait provides coroutine-based synchronous waiting alternative to bread.on callbacks", + "source_file": "Documentation.md", + "confidence_score": 0.5, + "_origin": "semantic", + "source": "api_bread_on", + "target": "api_bread_wait" + }, + { + "relation": "governs", + "confidence": "EXTRACTED", + "reasoning": "API stability guarantees apply to bread.on and all documented APIs", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "api_stability_versioning", + "target": "api_bread_on" + }, + { + "relation": "enables", + "confidence": "EXTRACTED", + "reasoning": "Event-driven pattern enables the bread.on subscription API", + "source_file": "README.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "pattern_event_driven", + "target": "api_bread_on" + }, + { + "relation": "requires", + "confidence": "EXTRACTED", + "reasoning": "bread.wait must be used with bread.spawn to run in a coroutine", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "api_bread_wait", + "target": "api_bread_spawn" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Workflows use bread.wait internally for multi-step orchestration", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "api_bread_workflow", + "target": "api_bread_wait" + }, + { + "relation": "uses", + "confidence": "EXTRACTED", + "reasoning": "Workflows spawn coroutines internally for multi-step automation", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "api_bread_workflow", + "target": "api_bread_spawn" + }, + { + "relation": "demonstrates", + "confidence": "EXTRACTED", + "reasoning": "Dock workflow example demonstrates bread.workflow API usage", + "source_file": "Examples.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "example_dock_workflow", + "target": "api_bread_workflow" + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "reasoning": "Coroutine workflow pattern is implemented by bread.workflow API", + "source_file": "Examples.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "pattern_coroutine_workflow", + "target": "api_bread_workflow" + }, + { + "relation": "demonstrates", + "confidence": "EXTRACTED", + "reasoning": "CPU temp widget example demonstrates bread.widget registration and updates", + "source_file": "Examples.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "example_widget_cpu_temp", + "target": "api_bread_widget" + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "reasoning": "Widget live update pattern is implemented by bread.widget API", + "source_file": "Examples.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "pattern_widget_live_update", + "target": "api_bread_widget" + }, + { + "relation": "demonstrated_by", + "confidence": "EXTRACTED", + "reasoning": "Autostart example shows the module skeleton pattern in practice", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "pattern_module_skeleton", + "target": "example_autostart" + }, + { + "relation": "complements", + "confidence": "EXTRACTED", + "reasoning": "Command namespace is the outbound complement to the bread..* inbound namespace", + "source_file": "Documentation.md", + "confidence_score": 1.0, + "_origin": "semantic", + "source": "command_namespace_convention", + "target": "app_namespace_convention" + } + ], + "hyperedges": [ + { + "name": "event_normalization_flow", + "nodes": [ + "adapter_udev", + "adapter_hyprland", + "adapter_power", + "sys_bread_daemon", + "api_bread_on", + "sys_lua_runtime" + ], + "relation": "implements", + "description": "Event normalization flow: raw signals from adapters \u2192 daemon normalizer \u2192 semantic events \u2192 Lua subscriptions" + }, + { + "name": "module_lifecycle", + "nodes": [ + "config_init_lua", + "config_modules_dir", + "pattern_module_skeleton", + "api_bread_on", + "sys_lua_runtime" + ], + "relation": "orchestrates", + "description": "Module lifecycle: init.lua runs first \u2192 modules/ auto-discovered \u2192 skeleton pattern \u2192 subscriptions registered on_load" + }, + { + "name": "workflow_execution_flow", + "nodes": [ + "api_bread_workflow", + "api_bread_spawn", + "api_bread_wait", + "example_dock_workflow", + "api_bread_notify" + ], + "relation": "enables", + "description": "Workflow execution: define body \u2192 start workflow \u2192 spawn coroutine \u2192 wait for events \u2192 step tracking \u2192 completion" + }, + { + "name": "widget_rendering_flow", + "nodes": [ + "api_bread_widget", + "api_bread_every", + "example_widget_cpu_temp", + "api_bread_state_watch" + ], + "relation": "enables", + "description": "Widget rendering: register widget with typed tree \u2192 update on timer or state change \u2192 breadbar renders live" + } + ], + "built_at_commit": "cdd5de8f58e437b3fc6d9b9087eb7b3d0fd09704" +} \ No newline at end of file diff --git a/graphify-out/manifest.json b/graphify-out/manifest.json new file mode 100644 index 0000000..81564d9 --- /dev/null +++ b/graphify-out/manifest.json @@ -0,0 +1,352 @@ +{ + "bread-cli/src/hooks_git.rs": { + "mtime": 1784781158.0572724, + "ast_hash": "7a29b5d5d90170f0aef9cececc7d8656", + "semantic_hash": "7a29b5d5d90170f0aef9cececc7d8656" + }, + "bread-cli/src/hooks_shell.rs": { + "mtime": 1784781158.0582726, + "ast_hash": "c5d5b8922fcff79954ddb00496721603", + "semantic_hash": "c5d5b8922fcff79954ddb00496721603" + }, + "bread-cli/src/lib.rs": { + "mtime": 1778512393.4941568, + "ast_hash": "d1bf6e1c239498521c42418f672bc400", + "semantic_hash": "d1bf6e1c239498521c42418f672bc400" + }, + "bread-cli/src/main.rs": { + "mtime": 1785882914.3322613, + "ast_hash": "e1fbe63ea3b10e0887072ab7133d0508", + "semantic_hash": "" + }, + "bread-cli/src/modules_mgmt.rs": { + "mtime": 1785882914.3322613, + "ast_hash": "1cb6f3e4fa26108f81215ab57bb02b91", + "semantic_hash": "" + }, + "bread-cli/tests/modules.rs": { + "mtime": 1784781158.0602725, + "ast_hash": "84fca8f87dc915b1cb523f8199e78521", + "semantic_hash": "84fca8f87dc915b1cb523f8199e78521" + }, + "bread-emit/src/main.rs": { + "mtime": 1784781158.0616376, + "ast_hash": "350cefbf697cfd93f7df7b7bcc45a101", + "semantic_hash": "350cefbf697cfd93f7df7b7bcc45a101" + }, + "bread-shared/src/apps.rs": { + "mtime": 1786805047.7009091, + "ast_hash": "e8419571e7a322019d71c89559fb02fb", + "semantic_hash": "" + }, + "bread-shared/src/glob.rs": { + "mtime": 1784781158.0616376, + "ast_hash": "0594a313cb1909d1cca5fd5b8f241b68", + "semantic_hash": "0594a313cb1909d1cca5fd5b8f241b68" + }, + "bread-shared/src/lib.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "236b73bad29f1544a28fbf3ee1ccc795", + "semantic_hash": "" + }, + "bread-shared/src/widget.rs": { + "mtime": 1784781173.9236407, + "ast_hash": "33272eb38c7fffbfa180cef7c5a286fc", + "semantic_hash": "33272eb38c7fffbfa180cef7c5a286fc" + }, + "breadd/src/adapters/bluetooth.rs": { + "mtime": 1778843727.5135255, + "ast_hash": "4d1df67347d5b7c9cdbcb12921a6ae28", + "semantic_hash": "4d1df67347d5b7c9cdbcb12921a6ae28" + }, + "breadd/src/adapters/filesystem.rs": { + "mtime": 1784781158.0616376, + "ast_hash": "8ec9dcd8de13f30922cfbe9b4a3fff56", + "semantic_hash": "8ec9dcd8de13f30922cfbe9b4a3fff56" + }, + "breadd/src/adapters/git.rs": { + "mtime": 1784781158.0616376, + "ast_hash": "6e6ff6ca318e28cd94690c30d41b520b", + "semantic_hash": "6e6ff6ca318e28cd94690c30d41b520b" + }, + "breadd/src/adapters/hyprland.rs": { + "mtime": 1786805047.7042425, + "ast_hash": "86056a351db61eb1788a2147d859fc5c", + "semantic_hash": "" + }, + "breadd/src/adapters/mod.rs": { + "mtime": 1784781158.0616376, + "ast_hash": "63885887c2fc3ea2314d7fe095e5df61", + "semantic_hash": "63885887c2fc3ea2314d7fe095e5df61" + }, + "breadd/src/adapters/network.rs": { + "mtime": 1778470615.8460202, + "ast_hash": "8706dc546b7e08d5aa084ca58c48559c", + "semantic_hash": "8706dc546b7e08d5aa084ca58c48559c" + }, + "breadd/src/adapters/network_rtnetlink.rs": { + "mtime": 1784781158.0616376, + "ast_hash": "0c9d0bb2693bc46b11807f6b8ebb7c4c", + "semantic_hash": "0c9d0bb2693bc46b11807f6b8ebb7c4c" + }, + "breadd/src/adapters/podman.rs": { + "mtime": 1784781158.0622723, + "ast_hash": "97c08551c0fe53b0a5888d98730d35db", + "semantic_hash": "97c08551c0fe53b0a5888d98730d35db" + }, + "breadd/src/adapters/power.rs": { + "mtime": 1778470615.838569, + "ast_hash": "987d202ec0d30ec26b1d747a6e320ed7", + "semantic_hash": "987d202ec0d30ec26b1d747a6e320ed7" + }, + "breadd/src/adapters/power_upower.rs": { + "mtime": 1784781158.0622723, + "ast_hash": "fc0a36ca76d340c8be77644f63e462bf", + "semantic_hash": "fc0a36ca76d340c8be77644f63e462bf" + }, + "breadd/src/adapters/systemd.rs": { + "mtime": 1784781158.0622723, + "ast_hash": "b3884dbecd39acc38abdf67589a8b954", + "semantic_hash": "b3884dbecd39acc38abdf67589a8b954" + }, + "breadd/src/adapters/udev.rs": { + "mtime": 1786805047.7042425, + "ast_hash": "568993c8c2dd218879eec57aee50a6b9", + "semantic_hash": "" + }, + "breadd/src/core/config.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "7f479bfb51647e6131c14f0c2f153d95", + "semantic_hash": "" + }, + "breadd/src/core/mod.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "e38bfdb894eabd208941bd3ffb1ef464", + "semantic_hash": "" + }, + "breadd/src/core/normalizer.rs": { + "mtime": 1786805047.7042425, + "ast_hash": "3e0e6e0b46cc3d42dbfd6348fc5f0bb1", + "semantic_hash": "" + }, + "breadd/src/core/state_engine.rs": { + "mtime": 1786805047.7042425, + "ast_hash": "0e54b3b7d1de26db074454d469543192", + "semantic_hash": "" + }, + "breadd/src/core/subscriptions.rs": { + "mtime": 1784781158.0632722, + "ast_hash": "8735d4717b74523c787dab9ea2b0bbd8", + "semantic_hash": "8735d4717b74523c787dab9ea2b0bbd8" + }, + "breadd/src/core/supervisor.rs": { + "mtime": 1778680581.3778126, + "ast_hash": "403f7ba1807c71f9b89d81bfeff2681a", + "semantic_hash": "403f7ba1807c71f9b89d81bfeff2681a" + }, + "breadd/src/core/types.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "8bd070d4c09725d8717749a79aa42a92", + "semantic_hash": "" + }, + "breadd/src/ipc/mod.rs": { + "mtime": 1786805047.7042425, + "ast_hash": "d5bc8f1194e7356de3fe181c68133cba", + "semantic_hash": "" + }, + "breadd/src/lua/mod.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "ed13e2495399d532625653a22a4fee14", + "semantic_hash": "" + }, + "breadd/src/main.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "4b31888cc9e76210df0c7cff3a8b1e42", + "semantic_hash": "" + }, + "breadd/tests/ipc_integration.rs": { + "mtime": 1786805047.7042425, + "ast_hash": "2b5bade2cc2e189a3af9c692232be258", + "semantic_hash": "" + }, + "examples/modules/active-window-widget.lua": { + "mtime": 1784781173.9256406, + "ast_hash": "a5f6fb2c54775a49ddaf29674f86571d", + "semantic_hash": "a5f6fb2c54775a49ddaf29674f86571d" + }, + "examples/modules/bluetooth-toggle-widget.lua": { + "mtime": 1784781173.9256406, + "ast_hash": "c8529dc45862adf4f63db48674a28277", + "semantic_hash": "c8529dc45862adf4f63db48674a28277" + }, + "examples/modules/dock-monitors.lua": { + "mtime": 1784781158.0663679, + "ast_hash": "4abe51f19614d2bf117ac35e95324801", + "semantic_hash": "4abe51f19614d2bf117ac35e95324801" + }, + "examples/modules/dock-workflow.lua": { + "mtime": 1785882914.337525, + "ast_hash": "84cf81cfb7780e89a46e96a6ccfbad15", + "semantic_hash": "" + }, + "examples/modules/focus-mode-widget.lua": { + "mtime": 1784781173.9256406, + "ast_hash": "f62c366c2c85cfbe59eef663fc607230", + "semantic_hash": "f62c366c2c85cfbe59eef663fc607230" + }, + "examples/modules/git-branch-widget.lua": { + "mtime": 1785882914.337525, + "ast_hash": "ebeeaebab5b5b29619f3db65c1df57d8", + "semantic_hash": "" + }, + "examples/modules/low-battery-warning.lua": { + "mtime": 1784781158.0663679, + "ast_hash": "e0ba79860562fc36fa8cb183bc576fb7", + "semantic_hash": "e0ba79860562fc36fa8cb183bc576fb7" + }, + "examples/modules/pause-media-on-headphone-unplug.lua": { + "mtime": 1784781158.0663679, + "ast_hash": "6c4cf82b6963eb93df224bed60d06c2d", + "semantic_hash": "6c4cf82b6963eb93df224bed60d06c2d" + }, + "examples/modules/workflow-status-widget.lua": { + "mtime": 1784781173.9256406, + "ast_hash": "9f913a66a0f8654dadc1c5d6c2be0938", + "semantic_hash": "9f913a66a0f8654dadc1c5d6c2be0938" + }, + "scripts/install.sh": { + "mtime": 1786805047.710909, + "ast_hash": "35d1a7f63824e9176bd105ab3d699576", + "semantic_hash": "" + }, + "CONTRIBUTING.md": { + "mtime": 1785909683.2691193, + "ast_hash": "6d056fcf0dae29949d19c41b41792879", + "semantic_hash": "" + }, + "Documentation.md": { + "mtime": 1786805047.7009091, + "ast_hash": "e219e52fae2208f771d9b77d87d6790b", + "semantic_hash": "" + }, + "Examples.md": { + "mtime": 1784781173.9236407, + "ast_hash": "6bcd7a14be53a9f67ef6912b160da8bc", + "semantic_hash": "6bcd7a14be53a9f67ef6912b160da8bc" + }, + "README.md": { + "mtime": 1786805047.7009091, + "ast_hash": "97ae9f7efb9f2cdceb615a47cf3dfa1a", + "semantic_hash": "" + }, + "bread-module-host/src/io.rs": { + "mtime": 1786805041.5686455, + "ast_hash": "dbe04e05d1cfb02770db8d7c0bcc0b68", + "semantic_hash": "" + }, + "bread-module-host/src/lua_env.rs": { + "mtime": 1786805041.5686455, + "ast_hash": "97d009846e18d3c809663b1185c98bbb", + "semantic_hash": "" + }, + "bread-module-host/src/main.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "9a93253ae44c764b8273df40999ddede", + "semantic_hash": "" + }, + "bread-shared/src/module_host_ipc.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "fcdb4c03f242a5ea51fd3a096b711363", + "semantic_hash": "" + }, + "bread-shared/src/permissions.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "800445ef9c90bdbf8f3ac9d4f1afd98e", + "semantic_hash": "" + }, + "breadd/src/core/rules.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "bd430cf213f400b8d4e96ccc35a76ff1", + "semantic_hash": "" + }, + "breadd/src/ipc/module_host_bridge.rs": { + "mtime": 1785882914.3346088, + "ast_hash": "caa9cf82695e48c88758fcfa835e1871", + "semantic_hash": "" + }, + "breadd/src/module_host.rs": { + "mtime": 1785895235.7449324, + "ast_hash": "228826ff3c8941ea5f9bb28b66d637a9", + "semantic_hash": "" + }, + "breadd/tests/module_host_sandbox.rs": { + "mtime": 1786805041.5686455, + "ast_hash": "7e637b3a950c510215a6f6a7b88dd404", + "semantic_hash": "" + }, + "examples/modules/cpu-temp-widget/init.lua": { + "mtime": 1785882914.337525, + "ast_hash": "5ac893dd2f6af6d8b22dd290e3021f77", + "semantic_hash": "" + }, + "xtask/src/main.rs": { + "mtime": 1785909683.2724528, + "ast_hash": "e914dd77ac3241df09e3a681228961db", + "semantic_hash": "" + }, + ".forgejo/workflows/dev-release.yml": { + "mtime": 1786805047.7009091, + "ast_hash": "ee3f41732b4ca3f34718b9c4fee68a4c", + "semantic_hash": "" + }, + ".forgejo/workflows/rc-release.yml": { + "mtime": 1786805047.7009091, + "ast_hash": "ce93aea449f6698edb5e993a9f658392", + "semantic_hash": "" + }, + ".forgejo/workflows/release.yml": { + "mtime": 1786805047.7009091, + "ast_hash": "aa3e2461c895d0e8ff0cf0fa5556694d", + "semantic_hash": "" + }, + "DEPRECATIONS.md": { + "mtime": 1786805047.7009091, + "ast_hash": "f3eb8f249d81c7c4faf2a131e890f459", + "semantic_hash": "" + }, + "examples/modules/README.md": { + "mtime": 1786858478.390548, + "ast_hash": "d47ad6c1a9775a44212b89e281aae907", + "semantic_hash": "" + }, + "packaging/README.md": { + "mtime": 1786805047.710909, + "ast_hash": "caa295eed64de126874a2e48b8aed8a2", + "semantic_hash": "" + }, + "ci/build.sh": { + "mtime": 1786805047.7071788, + "ast_hash": "363dbb1a10cf8e098a0451f43ff101cf", + "semantic_hash": "" + }, + "examples/modules/external-monitors.lua": { + "mtime": 1786858478.390548, + "ast_hash": "ba0f44a4d84889b9828201aff9186466", + "semantic_hash": "" + }, + ".forgejo/workflows/check.yml": { + "mtime": 1786805047.7009091, + "ast_hash": "4ceb400224458b1a43c5ddc44cfbd187", + "semantic_hash": "" + }, + "AGENTS.md": { + "mtime": 1786805047.7009091, + "ast_hash": "513e4a05cbbcdcb47b208b781f4d78bb", + "semantic_hash": "" + }, + "CLAUDE.md": { + "mtime": 1784778267.6147587, + "ast_hash": "589cfefd400c641c059a2f8516ff2037", + "semantic_hash": "" + } +} \ No newline at end of file diff --git a/packaging/README.md b/packaging/README.md index 18256de..d5fa606 100644 --- a/packaging/README.md +++ b/packaging/README.md @@ -5,29 +5,21 @@ This directory contains distribution packaging for Bread. ``` packaging/ -├── arch/ -│ └── PKGBUILD ← Arch Linux package build script └── systemd/ └── breadd.service ← systemd user service unit ``` -## Arch Linux - -```bash -cd packaging/arch -makepkg -si -``` - -The PKGBUILD builds both `breadd` and `bread` from source and installs them to `/usr/bin`. It also installs the systemd user service unit to `/usr/lib/systemd/user/`. - -Before publishing to the AUR, update `pkgver`, `source`, and `sha256sums` to point at a tagged release tarball. +Prebuilt binaries are distributed exclusively via `bakery` (see the main +README) — there is no Arch/pacman package for `bread` anymore. `bakery` +installs the systemd user service unit itself, matching the `packaging/systemd/breadd.service` +file here. ## systemd user service The service unit starts `breadd` as a user service after the graphical session is available. ```bash -# Install and enable manually (if not using the PKGBUILD) +# Install and enable manually (if not using bakery) mkdir -p ~/.config/systemd/user cp systemd/breadd.service ~/.config/systemd/user/ systemctl --user daemon-reload diff --git a/packaging/arch/PKGBUILD b/packaging/arch/PKGBUILD deleted file mode 100644 index b3af1c0..0000000 --- a/packaging/arch/PKGBUILD +++ /dev/null @@ -1,39 +0,0 @@ -# Maintainer: Breadway - -pkgname=bread -pkgver=0.6.6 -pkgrel=1 -pkgdesc="A reactive automation fabric for Linux desktops" -arch=('x86_64') -url="https://git.breadway.dev/Breadway/bread" -license=('MIT') -# mlua builds Lua from vendored C source. makepkg's default -flto=auto would -# emit GCC LTO bitcode into liblua5.4.a, which the Rust (lld) link can't read, -# leaving all lua_* symbols undefined. Disable LTO for a clean static link. -options=(!lto !debug) -depends=('glibc') -optdepends=( - 'libnotify: desktop notifications via bread.notify()' - 'upower: D-Bus battery events (sysfs polling used otherwise)' -) -makedepends=('rust' 'cargo') -source=("${pkgname}-${pkgver}.tar.gz") -sha256sums=('SKIP') - -build() { - cd "${srcdir}/${pkgname}-${pkgver}" - cargo build --release --locked -} - -check() { - cd "${srcdir}/${pkgname}-${pkgver}" - cargo test --release --locked --workspace -} - -package() { - cd "${srcdir}/${pkgname}-${pkgver}" - install -Dm755 target/release/breadd "${pkgdir}/usr/bin/breadd" - install -Dm755 target/release/bread "${pkgdir}/usr/bin/bread" - install -Dm644 packaging/systemd/breadd.service "${pkgdir}/usr/lib/systemd/user/breadd.service" - install -Dm644 LICENSE "${pkgdir}/usr/share/licenses/${pkgname}/LICENSE" -} diff --git a/packaging/arch/README.md b/packaging/arch/README.md deleted file mode 100644 index f7de16e..0000000 --- a/packaging/arch/README.md +++ /dev/null @@ -1,28 +0,0 @@ -Arch packaging -============== - -`PKGBUILD` builds and installs both `breadd` and `bread` from source. - -## Local build - -```bash -makepkg -si -``` - -## Before publishing to AUR - -1. Tag a release on GitHub. -2. Update `pkgver` to match the tag. -3. Update `source` to the release tarball URL. -4. Run `updpkgsums` (or manually set `sha256sums`). -5. Update `url` if the repository has moved. -6. Set `depends` accurately — at minimum: `glibc`. Add `udev` if not linking statically. - -## Runtime dependencies - -| Package | Required | Notes | -|---------|----------|-------| -| `glibc` | yes | always | -| `udev` | yes | device events | -| `dbus` | optional | UPower battery events | -| `libnotify` | optional | `bread.notify()` (uses `notify-send`) | diff --git a/scripts/install.sh b/scripts/install.sh index 7a16cd9..8dc133c 100755 --- a/scripts/install.sh +++ b/scripts/install.sh @@ -17,8 +17,12 @@ echo "symlinking binaries into $BIN_DIR..." mkdir -p "$BIN_DIR" ln -sf "$REPO_ROOT/target/release/breadd" "$BIN_DIR/breadd" ln -sf "$REPO_ROOT/target/release/bread" "$BIN_DIR/bread" +ln -sf "$REPO_ROOT/target/release/bread-emit" "$BIN_DIR/bread-emit" +ln -sf "$REPO_ROOT/target/release/bread-module-host" "$BIN_DIR/bread-module-host" echo " $BIN_DIR/breadd -> $REPO_ROOT/target/release/breadd" echo " $BIN_DIR/bread -> $REPO_ROOT/target/release/bread" +echo " $BIN_DIR/bread-emit -> $REPO_ROOT/target/release/bread-emit" +echo " $BIN_DIR/bread-module-host -> $REPO_ROOT/target/release/bread-module-host" if [[ ":$PATH:" != *":$BIN_DIR:"* ]]; then echo "" diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml new file mode 100644 index 0000000..a6beaa9 --- /dev/null +++ b/xtask/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "xtask" +version = "0.1.0" +edition = "2021" +publish = false + +[[bin]] +name = "xtask" +path = "src/main.rs" + +[dependencies] +anyhow.workspace = true +serde.workspace = true +toml = "0.8" diff --git a/xtask/src/main.rs b/xtask/src/main.rs new file mode 100644 index 0000000..2ae2534 --- /dev/null +++ b/xtask/src/main.rs @@ -0,0 +1,894 @@ +//! Repo maintenance tasks that don't belong in the `breadd`/`bread-cli` +//! binaries themselves. +//! +//! Currently just `check-docs`: a drift detector between the actual +//! `bread.*` Lua binding surface + IPC method surface + `bread` CLI command +//! surface (as implemented in `breadd/src/lua/mod.rs`, `breadd/src/ipc/mod.rs`, +//! and `bread-cli/src/main.rs`) and the checked-in registry at +//! `api-schema.toml`, cross-referenced against `Documentation.md` (Lua/IPC) +//! and `README.md` (CLI commands). See `api-schema.toml`'s header comment for +//! why this exists and why it's a *drift detector*, not a doc generator. +//! +//! The CLI-command coverage exists specifically because README's "CLI +//! reference" section drifted from `Documentation.md`/the real `bread-cli` +//! source (missing `modules audit`, `hooks install-shell`/`install-git`, +//! `events --tree`) — a live instance of exactly the drift this whole +//! workstream exists to prevent, found and fixed by hand once the schema +//! didn't cover it yet. See `api-schema.toml`'s header for how CLI commands +//! are named and versioned differently from the Lua/IPC entries. + +use std::collections::BTreeSet; +use std::path::{Path, PathBuf}; +use std::process::ExitCode; + +use anyhow::{Context, Result}; +use serde::Deserialize; + +fn main() -> ExitCode { + let args: Vec = std::env::args().skip(1).collect(); + match args.first().map(String::as_str) { + Some("check-docs") => match run_check_docs() { + Ok(true) => ExitCode::SUCCESS, + Ok(false) => ExitCode::FAILURE, + Err(err) => { + eprintln!("xtask check-docs: error: {err:#}"); + ExitCode::FAILURE + } + }, + Some(other) => { + eprintln!("unknown xtask command '{other}'\n{}", usage()); + ExitCode::FAILURE + } + None => { + eprintln!("{}", usage()); + ExitCode::FAILURE + } + } +} + +fn usage() -> &'static str { + "usage: cargo run -p xtask -- \n\n\ + Available commands:\n \ + check-docs verify api-schema.toml matches breadd's Lua/IPC surface and Documentation.md" +} + +fn run_check_docs() -> Result { + let root = repo_root()?; + + let lua_src = std::fs::read_to_string(root.join("breadd/src/lua/mod.rs")) + .context("reading breadd/src/lua/mod.rs")?; + let ipc_src = std::fs::read_to_string(root.join("breadd/src/ipc/mod.rs")) + .context("reading breadd/src/ipc/mod.rs")?; + let cli_src = std::fs::read_to_string(root.join("bread-cli/src/main.rs")) + .context("reading bread-cli/src/main.rs")?; + let schema_toml = std::fs::read_to_string(root.join("api-schema.toml")) + .context("reading api-schema.toml")?; + let doc_md = + std::fs::read_to_string(root.join("Documentation.md")).context("reading Documentation.md")?; + let readme_md = + std::fs::read_to_string(root.join("README.md")).context("reading README.md")?; + + let report = check(&lua_src, &ipc_src, &cli_src, &schema_toml, &doc_md, &readme_md)?; + report.print(); + Ok(report.is_clean()) +} + +fn repo_root() -> Result { + // xtask's own Cargo.toml lives at /xtask/Cargo.toml, so its + // parent is the workspace root regardless of the caller's cwd (`cargo + // run -p xtask` sets CARGO_MANIFEST_DIR to xtask/, not the invocation dir). + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .parent() + .map(Path::to_path_buf) + .context("xtask has no parent directory (unexpected workspace layout)") +} + +// --------------------------------------------------------------------------- +// Schema + +#[derive(Debug, Deserialize)] +struct Schema { + #[serde(default)] + entry: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +struct SchemaEntry { + name: String, + kind: String, + #[serde(default)] + since: String, +} + +const VALID_KINDS: &[&str] = &["lua_function", "lua_table", "ipc_method", "cli_command"]; + +// --------------------------------------------------------------------------- +// Extraction: breadd/src/lua/mod.rs -> the current bread.* Lua API surface. +// +// This is deliberately line/substring scanning, not a real Lua or Rust +// parser (see api-schema.toml's header comment) — precise enough because +// `install_api` and its `install_*_helpers` siblings follow a small, stable +// set of textual patterns: +// +// 1. `bread.set("name", ...)` - a top-level binding (function or, +// for the known sub-table variables +// below, a table). +// 2. `_tbl.set("name", ...)` - a method nested under table ``. +// 3. `function _bread.name(` / +// `function bread.name(` - a plain-Lua-defined top-level +// function (log/warn/error/debounce). +// 4. `bread.name = function` - ditto, assignment form +// (spawn/wait/wait_any/wait_all). +// 5. `bread.workflow = {}` and +// `bread.workflow.name = function` - the `bread.workflow` table and its +// members. + +/// Sub-table variables built in `install_api` and registered onto the +/// `bread` global, mapped to the dotted parent name they hang off. +/// Deliberately excludes `module_tbl` / `store_tbl`: those back the +/// per-module `M` object returned by `bread.module(...)` (i.e. `M.store.get` +/// etc.), which is a different namespace from `bread.*` itself. +const TABLE_VARS: &[(&str, &str)] = &[ + ("state_tbl", "state"), + ("profile_tbl", "profile"), + ("hyprland_tbl", "hyprland"), + ("widget_tbl", "widget"), + ("machine_tbl", "machine"), + ("fs_tbl", "fs"), + ("json_tbl", "json"), + ("bluetooth_tbl", "bluetooth"), +]; + +/// Read a bare identifier (`[A-Za-z0-9_]+`) starting at byte offset `start`. +fn ident_at(text: &str, start: usize) -> &str { + let rest = &text[start..]; + let end = rest + .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) + .unwrap_or(rest.len()); + &rest[..end] +} + +/// Read up to (not including) the next `"` starting at byte offset `start`. +fn ident_upto_quote(text: &str, start: usize) -> &str { + let rest = &text[start..]; + let end = rest.find('"').unwrap_or(rest.len()); + &rest[..end] +} + +fn extract_lua_bindings(src: &str) -> BTreeSet<(String, String)> { + let mut out = BTreeSet::new(); + + // 1. Top-level `bread.set("name", ...)`. + for (idx, _) in src.match_indices("bread.set(\"") { + let name = ident_upto_quote(src, idx + "bread.set(\"".len()); + if name.is_empty() || name.starts_with("__") { + continue; // internal Rust<->Lua bridge fn (e.g. __log_info), not public API + } + let is_table = TABLE_VARS.iter().any(|(_, parent)| *parent == name); + out.insert(( + (if is_table { "lua_table" } else { "lua_function" }).to_string(), + name.to_string(), + )); + } + + // 2. Nested `_tbl.set("name", ...)` for the known sub-tables. + for (var, parent) in TABLE_VARS { + let prefix = format!("{var}.set(\""); + for (idx, _) in src.match_indices(prefix.as_str()) { + let name = ident_upto_quote(src, idx + prefix.len()); + if name.is_empty() { + continue; + } + out.insert(("lua_function".to_string(), format!("{parent}.{name}"))); + } + } + + // 3. `function _bread.name(` / `function bread.name(`. + for prefix in ["function _bread.", "function bread."] { + for (idx, _) in src.match_indices(prefix) { + let name = ident_at(src, idx + prefix.len()); + if !name.is_empty() { + out.insert(("lua_function".to_string(), name.to_string())); + } + } + } + + // 4. `bread.name = function` (top-level only; `bread.workflow.*` is + // handled separately in step 5 since it's a nested table's members). + for (idx, _) in src.match_indices("bread.") { + let name_start = idx + "bread.".len(); + let name = ident_at(src, name_start); + if name.is_empty() || name == "workflow" { + continue; + } + if src[name_start + name.len()..].trim_start().starts_with("= function") { + out.insert(("lua_function".to_string(), name.to_string())); + } + } + + // 5. `bread.workflow = {}` and `bread.workflow.name = function`. + if src.contains("bread.workflow = {}") { + out.insert(("lua_table".to_string(), "workflow".to_string())); + } + for (idx, _) in src.match_indices("bread.workflow.") { + let name_start = idx + "bread.workflow.".len(); + let name = ident_at(src, name_start); + if name.is_empty() { + continue; + } + if src[name_start + name.len()..].trim_start().starts_with("= function") { + out.insert(("lua_function".to_string(), format!("workflow.{name}"))); + } + } + + out +} + +// --------------------------------------------------------------------------- +// Extraction: breadd/src/ipc/mod.rs -> the current IPC method surface. + +fn extract_ipc_methods(src: &str) -> BTreeSet { + let mut out = BTreeSet::new(); + + // `events.subscribe` is special-cased ahead of the dispatch `match` + // (it upgrades the connection to a streaming socket instead of + // returning a single response), so it never appears as a match arm. + if src.contains("req.method == \"events.subscribe\"") { + out.insert("events.subscribe".to_string()); + } + + let Some(match_start) = src.find("match req.method.as_str() {") else { + return out; + }; + + // Track brace depth so a `"literal" => ...` pattern belonging to some + // *other*, nested match inside an arm's body (e.g. the `"emit"` arm's + // own `match source_str { "terminal" => ..., "git" => ... }`) isn't + // mistaken for a top-level IPC method arm. Only depth == 1 (directly + // inside the outer `match req.method.as_str() { ... }`) counts. + let mut depth: i32 = 0; + for line in src[match_start..].lines() { + let pre_depth = depth; + let trimmed = line.trim_start(); + + if pre_depth == 1 { + if let Some(rest) = trimmed.strip_prefix('"') { + if let Some(end) = rest.find('"') { + let name = &rest[..end]; + if rest[end + 1..].trim_start().starts_with("=>") { + out.insert(name.to_string()); + } + } + } + } + + depth += line.matches('{').count() as i32; + depth -= line.matches('}').count() as i32; + if pre_depth >= 1 && depth <= 0 { + break; // closed the outer match block + } + } + + out +} + +// --------------------------------------------------------------------------- +// Extraction: bread-cli/src/main.rs -> the current `bread` CLI command +// surface. +// +// Same deliberate textual-scanning approach as the Lua/IPC extractors +// above, not a real Rust/clap-derive-macro-expanding parser. + +/// Top-level `Commands` variants that delegate to a nested subcommand enum +/// via `#[command(subcommand)] subcommand: XCommand` rather than being a +/// leaf command themselves — each such variant's own leaf commands are +/// named `.` (e.g. `modules.audit`, +/// `hooks.install-shell`) instead of the group variant itself being a leaf. +/// Update this list if `bread-cli/src/main.rs` gains another subcommand +/// group (the same kind of manual-update-needed list as `TABLE_VARS` above). +const SUBCOMMAND_GROUPS: &[(&str, &str)] = &[("Modules", "ModulesCommand"), ("Hooks", "HooksCommand")]; + +/// clap's default rename for a derived `Subcommand` variant: PascalCase -> +/// kebab-case (`ProfileList` -> `profile-list`, `InstallShell` -> +/// `install-shell`). This is what actually shows up as `bread ` on +/// the command line and in README's CLI reference. +fn kebab(pascal: &str) -> String { + let mut out = String::new(); + for (i, c) in pascal.chars().enumerate() { + if c.is_ascii_uppercase() { + if i != 0 { + out.push('-'); + } + out.push(c.to_ascii_lowercase()); + } else { + out.push(c); + } + } + out +} + +/// Scan a `#[derive(Subcommand, ...)] enum { ... }` block for +/// its variant names, in source order. Depth-tracked the same way +/// `extract_ipc_methods` tracks match-arm depth, so a variant's own nested +/// struct-style fields (and their attributes/doc comments) aren't mistaken +/// for sibling variants. +fn extract_enum_variants(src: &str, enum_name: &str) -> Vec { + let marker = format!("enum {enum_name} {{"); + let Some(start) = src.find(&marker) else { + return Vec::new(); + }; + + let mut out = Vec::new(); + let mut depth: i32 = 0; + for line in src[start..].lines() { + let pre_depth = depth; + let trimmed = line.trim_start(); + + if pre_depth == 1 { + let name_end = trimmed + .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) + .unwrap_or(trimmed.len()); + let name = &trimmed[..name_end]; + if !name.is_empty() && name.starts_with(|c: char| c.is_ascii_uppercase()) { + out.push(name.to_string()); + } + } + + depth += line.matches('{').count() as i32; + depth -= line.matches('}').count() as i32; + if pre_depth >= 1 && depth <= 0 { + break; // closed the enum block + } + } + out +} + +fn extract_cli_commands(src: &str) -> BTreeSet { + let mut out = BTreeSet::new(); + for variant in extract_enum_variants(src, "Commands") { + if let Some((_, sub_enum)) = SUBCOMMAND_GROUPS.iter().find(|(v, _)| *v == variant) { + let group = kebab(&variant); + for sub in extract_enum_variants(src, sub_enum) { + out.insert(format!("{group}.{}", kebab(&sub))); + } + } else { + out.insert(kebab(&variant)); + } + } + out +} + +// --------------------------------------------------------------------------- +// Documentation.md cross-checks + +/// Slice out a `## `-level section (from its heading up to, but not +/// including, the next `## `-level heading). +fn section<'a>(doc: &'a str, heading: &str) -> &'a str { + let Some(start) = doc.find(heading) else { + return ""; + }; + let rest = &doc[start..]; + match rest[3..].find("\n## ") { + Some(i) => &rest[..i + 3], + None => rest, + } +} + +fn lua_api_section(doc: &str) -> &str { + section(doc, "## Dictionary: Lua API") +} + +fn ipc_section(doc: &str) -> &str { + section(doc, "## Dictionary: IPC protocol") +} + +// --------------------------------------------------------------------------- +// README.md cross-check + +fn readme_cli_section(readme: &str) -> &str { + section(readme, "## CLI reference") +} + +// --------------------------------------------------------------------------- +// Report + +#[derive(Debug, Default)] +struct CheckReport { + /// In code, not in api-schema.toml. + missing_from_schema: Vec<(String, String)>, + /// In api-schema.toml, no longer in code. + stale_in_schema: Vec<(String, String)>, + /// In api-schema.toml (and in code), but Documentation.md has no + /// heading/row for it (lua_function/lua_table/ipc_method only). + undocumented: Vec<(String, String)>, + /// In api-schema.toml (and in code), but README's "CLI reference" + /// section has no `bread ` line for it (cli_command only). + missing_from_readme: Vec<(String, String)>, + /// Schema entries with an unrecognized `kind`. + bad_kind: Vec<(String, String)>, + /// Schema entries with an empty `since`. + missing_since: Vec<(String, String)>, +} + +impl CheckReport { + fn is_clean(&self) -> bool { + self.missing_from_schema.is_empty() + && self.stale_in_schema.is_empty() + && self.undocumented.is_empty() + && self.missing_from_readme.is_empty() + && self.bad_kind.is_empty() + && self.missing_since.is_empty() + } + + fn print(&self) { + if self.is_clean() { + println!("check-docs: OK — api-schema.toml matches breadd's Lua/IPC/CLI surface, Documentation.md, and README.md."); + return; + } + + if !self.bad_kind.is_empty() { + println!("Schema entries with an unrecognized `kind` (expected one of {VALID_KINDS:?}):"); + for (kind, name) in &self.bad_kind { + println!(" - {name} (kind = \"{kind}\")"); + } + println!(); + } + + if !self.missing_from_schema.is_empty() { + println!("Added but undocumented in api-schema.toml (present in code, missing from schema):"); + for (kind, name) in &self.missing_from_schema { + println!(" - [{kind}] {name}"); + } + println!(); + } + + if !self.stale_in_schema.is_empty() { + println!("Stale in api-schema.toml (no longer found in code):"); + for (kind, name) in &self.stale_in_schema { + println!(" - [{kind}] {name}"); + } + println!(); + } + + if !self.undocumented.is_empty() { + println!("In api-schema.toml but missing from Documentation.md (no `#### bread.` heading for a lua_function/lua_table, or no `` row in the IPC Methods table):"); + for (kind, name) in &self.undocumented { + println!(" - [{kind}] {name}"); + } + println!(); + } + + if !self.missing_from_readme.is_empty() { + println!("In api-schema.toml but missing from README.md's \"CLI reference\" section (no `bread ` line):"); + for (kind, name) in &self.missing_from_readme { + println!(" - [{kind}] {name}"); + } + println!(); + } + + if !self.missing_since.is_empty() { + println!("Schema entries with an empty `since`:"); + for (kind, name) in &self.missing_since { + println!(" - [{kind}] {name}"); + } + println!(); + } + + println!("check-docs: FAILED — see above."); + } +} + +fn check( + lua_src: &str, + ipc_src: &str, + cli_src: &str, + schema_toml: &str, + doc_md: &str, + readme_md: &str, +) -> Result { + let schema: Schema = toml::from_str(schema_toml).context("parsing api-schema.toml")?; + + let mut report = CheckReport::default(); + + let mut schema_set: BTreeSet<(String, String)> = BTreeSet::new(); + for entry in &schema.entry { + if !VALID_KINDS.contains(&entry.kind.as_str()) { + report.bad_kind.push((entry.kind.clone(), entry.name.clone())); + continue; + } + if entry.since.trim().is_empty() { + report + .missing_since + .push((entry.kind.clone(), entry.name.clone())); + } + schema_set.insert((entry.kind.clone(), entry.name.clone())); + } + + // --- code vs schema: Lua --- + let code_lua = extract_lua_bindings(lua_src); + let schema_lua: BTreeSet<(String, String)> = schema_set + .iter() + .filter(|(kind, _)| kind == "lua_function" || kind == "lua_table") + .cloned() + .collect(); + + for entry in code_lua.difference(&schema_lua) { + report.missing_from_schema.push(entry.clone()); + } + for entry in schema_lua.difference(&code_lua) { + report.stale_in_schema.push(entry.clone()); + } + + // --- code vs schema: IPC --- + let code_ipc = extract_ipc_methods(ipc_src); + let schema_ipc: BTreeSet = schema_set + .iter() + .filter(|(kind, _)| kind == "ipc_method") + .map(|(_, name)| name.clone()) + .collect(); + + for name in code_ipc.difference(&schema_ipc) { + report + .missing_from_schema + .push(("ipc_method".to_string(), name.clone())); + } + for name in schema_ipc.difference(&code_ipc) { + report + .stale_in_schema + .push(("ipc_method".to_string(), name.clone())); + } + + // --- code vs schema: CLI --- + let code_cli = extract_cli_commands(cli_src); + let schema_cli: BTreeSet = schema_set + .iter() + .filter(|(kind, _)| kind == "cli_command") + .map(|(_, name)| name.clone()) + .collect(); + + for name in code_cli.difference(&schema_cli) { + report + .missing_from_schema + .push(("cli_command".to_string(), name.clone())); + } + for name in schema_cli.difference(&code_cli) { + report + .stale_in_schema + .push(("cli_command".to_string(), name.clone())); + } + + // --- schema vs Documentation.md (lua_function/lua_table/ipc_method only — + // cli_command is checked against README.md separately, below) --- + let lua_section = lua_api_section(doc_md); + let ipc_tbl_section = ipc_section(doc_md); + for entry in &schema.entry { + if !VALID_KINDS.contains(&entry.kind.as_str()) || entry.kind == "cli_command" { + continue; // already reported above, or checked against README instead + } + let documented = if entry.kind == "ipc_method" { + ipc_tbl_section.contains(&format!("`{}`", entry.name)) + } else { + lua_section.contains(&format!("bread.{}", entry.name)) + }; + if !documented { + report + .undocumented + .push((entry.kind.clone(), entry.name.clone())); + } + } + + // --- schema vs README.md (cli_command only) --- + let readme_cli = readme_cli_section(readme_md); + for entry in &schema.entry { + if entry.kind != "cli_command" { + continue; + } + let cmd_text = format!("bread {}", entry.name.replace('.', " ")); + if !readme_cli.contains(cmd_text.as_str()) { + report + .missing_from_readme + .push((entry.kind.clone(), entry.name.clone())); + } + } + + report.missing_from_schema.sort(); + report.stale_in_schema.sort(); + report.undocumented.sort(); + report.missing_from_readme.sort(); + report.bad_kind.sort(); + report.missing_since.sort(); + + Ok(report) +} + +#[cfg(test)] +mod tests { + use super::*; + + const LUA_SRC: &str = r#" + bread.set("on", on_fn)?; + bread.set("state", state_tbl)?; + state_tbl.set("get", get_fn)?; + state_tbl.set("watch", watch_fn)?; + bread.set("__log_info", info_fn)?; + function bread.debounce(delay_ms, fn) + bread.spawn = function(fn) + bread.workflow = {} + bread.workflow.define = function(name, fn) + "#; + + const IPC_SRC: &str = r#" + if req.method == "events.subscribe" { + } + let result = match req.method.as_str() { + "ping" => Ok(json!({ "ok": true })), + "emit" => { + let source = match source_str { + "terminal" => AdapterSource::Terminal, + "git" => AdapterSource::Git, + other => AdapterSource::App(other.to_string()), + }; + Ok(json!({ "emitted": true })) + } + _ => Err("unknown method".to_string()), + }; + "#; + + const DOC_MD: &str = r#" +## Dictionary: Lua API + +#### `bread.on(pattern, fn) -> id` +#### `bread.state.get(path)` +#### `bread.state.watch(path, fn) -> id` +#### `bread.debounce(delay_ms, fn) -> wrapped_fn` +#### `bread.spawn(fn)` +### Workflows +#### `bread.workflow.define(name, fn)` + +## Dictionary: IPC protocol + +| Method | Params | Description | +|--------|--------|-------------| +| `ping` | - | Connectivity check | +| `emit` | - | Inject an event | +| `events.subscribe` | - | Upgrade to streaming mode | +"#; + + /// Mirrors the real `bread-cli/src/main.rs` shape closely enough to + /// exercise both a flat leaf command (`Ping`) and a subcommand group + /// (`Modules` -> `ModulesCommand`), including a struct-style variant + /// with fields (`Info { name: String }`). + const CLI_SRC: &str = r#" +enum Commands { + /// Health check daemon connectivity + Ping, + /// Manage installed Lua modules + Modules { + #[command(subcommand)] + subcommand: ModulesCommand, + }, +} + +enum ModulesCommand { + /// List all installed modules + List, + /// Show full manifest details for a module + Info { name: String }, +} +"#; + + const README_MD: &str = r#" +## CLI reference + +```bash +bread ping +bread modules list +bread modules info +``` + +--- + +## Module system +"#; + + fn schema_toml_for(entries: &[(&str, &str, &str)]) -> String { + let mut out = String::new(); + for (name, kind, since) in entries { + out.push_str(&format!( + "[[entry]]\nname = \"{name}\"\nkind = \"{kind}\"\nsince = \"{since}\"\n\n" + )); + } + out + } + + fn full_schema() -> String { + schema_toml_for(&[ + ("on", "lua_function", "1.0"), + ("state", "lua_table", "1.0"), + ("state.get", "lua_function", "1.0"), + ("state.watch", "lua_function", "1.0"), + ("debounce", "lua_function", "1.0"), + ("spawn", "lua_function", "1.0"), + ("workflow", "lua_table", "1.2"), + ("workflow.define", "lua_function", "1.2"), + ("ping", "ipc_method", "1.0"), + ("emit", "ipc_method", "1.0"), + ("events.subscribe", "ipc_method", "1.0"), + ("ping", "cli_command", "0.7"), + ("modules.list", "cli_command", "0.7"), + ("modules.info", "cli_command", "0.7"), + ]) + } + + #[test] + fn extracts_lua_bindings_precisely() { + let got = extract_lua_bindings(LUA_SRC); + let want: BTreeSet<(String, String)> = [ + ("lua_function", "on"), + ("lua_table", "state"), + ("lua_function", "state.get"), + ("lua_function", "state.watch"), + ("lua_function", "debounce"), + ("lua_function", "spawn"), + ("lua_table", "workflow"), + ("lua_function", "workflow.define"), + ] + .into_iter() + .map(|(k, n)| (k.to_string(), n.to_string())) + .collect(); + assert_eq!(got, want, "must exclude __-prefixed internals"); + } + + #[test] + fn extracts_ipc_methods_without_leaking_nested_match_arms() { + let got = extract_ipc_methods(IPC_SRC); + let want: BTreeSet = ["events.subscribe", "ping", "emit"] + .into_iter() + .map(String::from) + .collect(); + assert_eq!( + got, want, + "must not pick up \"terminal\"/\"git\" from the nested `match source_str` inside the emit arm" + ); + } + + #[test] + fn clean_state_passes() { + let report = check(LUA_SRC, IPC_SRC, CLI_SRC, &full_schema(), DOC_MD, README_MD).unwrap(); + assert!(report.is_clean(), "{report:#?}"); + } + + #[test] + fn renamed_schema_entry_is_caught_as_drift() { + // Simulate a contributor renaming `bread.debounce` in code without + // updating api-schema.toml: schema still says "debounce", code no + // longer does (only "debounce_v2" now exists). + let renamed_lua_src = LUA_SRC.replace("bread.debounce", "bread.debounce_v2"); + let report = check( + &renamed_lua_src, + IPC_SRC, + CLI_SRC, + &full_schema(), + DOC_MD, + README_MD, + ) + .unwrap(); + assert!(!report.is_clean()); + assert!(report + .missing_from_schema + .contains(&("lua_function".to_string(), "debounce_v2".to_string()))); + assert!(report + .stale_in_schema + .contains(&("lua_function".to_string(), "debounce".to_string()))); + } + + #[test] + fn removed_ipc_method_is_caught_as_drift() { + let without_emit = IPC_SRC.replacen("\"emit\" => {", "\"emit_removed\" => {", 1); + let report = check( + LUA_SRC, + &without_emit, + CLI_SRC, + &full_schema(), + DOC_MD, + README_MD, + ) + .unwrap(); + assert!(!report.is_clean()); + assert!(report + .stale_in_schema + .contains(&("ipc_method".to_string(), "emit".to_string()))); + } + + #[test] + fn missing_doc_heading_is_caught_as_drift() { + let doc_without_spawn_heading = DOC_MD.replace("#### `bread.spawn(fn)`\n", ""); + let report = check( + LUA_SRC, + IPC_SRC, + CLI_SRC, + &full_schema(), + &doc_without_spawn_heading, + README_MD, + ) + .unwrap(); + assert!(!report.is_clean()); + assert!(report + .undocumented + .contains(&("lua_function".to_string(), "spawn".to_string()))); + } + + #[test] + fn unknown_kind_is_rejected() { + let bad_schema = schema_toml_for(&[("on", "lua_thing", "1.0")]); + let report = check(LUA_SRC, IPC_SRC, CLI_SRC, &bad_schema, DOC_MD, README_MD).unwrap(); + assert!(!report.is_clean()); + assert!(report + .bad_kind + .contains(&("lua_thing".to_string(), "on".to_string()))); + } + + #[test] + fn kebab_converts_pascal_case_correctly() { + assert_eq!(kebab("Ping"), "ping"); + assert_eq!(kebab("ProfileList"), "profile-list"); + assert_eq!(kebab("InstallShell"), "install-shell"); + } + + #[test] + fn extracts_cli_commands_with_subcommand_groups_dotted() { + let got = extract_cli_commands(CLI_SRC); + let want: BTreeSet = ["ping", "modules.list", "modules.info"] + .into_iter() + .map(String::from) + .collect(); + assert_eq!( + got, want, + "flat leaf commands stay bare; subcommand-group members get `.` names" + ); + } + + #[test] + fn renamed_cli_command_is_caught_as_drift() { + // Simulate a contributor renaming the `modules info` subcommand in + // code (e.g. to `Show`) without updating api-schema.toml. + let renamed_cli_src = CLI_SRC.replace("Info { name: String }", "Show { name: String }"); + let report = check( + LUA_SRC, + IPC_SRC, + &renamed_cli_src, + &full_schema(), + DOC_MD, + README_MD, + ) + .unwrap(); + assert!(!report.is_clean()); + assert!(report + .missing_from_schema + .contains(&("cli_command".to_string(), "modules.show".to_string()))); + assert!(report + .stale_in_schema + .contains(&("cli_command".to_string(), "modules.info".to_string()))); + } + + #[test] + fn missing_readme_cli_line_is_caught_as_drift() { + // The exact class of drift this coverage exists to catch: a real + // command exists in code and api-schema.toml, but README's "CLI + // reference" section never got a line added for it. + let readme_without_modules_info = README_MD.replace("bread modules info \n", ""); + let report = check( + LUA_SRC, + IPC_SRC, + CLI_SRC, + &full_schema(), + DOC_MD, + &readme_without_modules_info, + ) + .unwrap(); + assert!(!report.is_clean()); + assert!(report + .missing_from_readme + .contains(&("cli_command".to_string(), "modules.info".to_string()))); + } +}