ci: trigger rust ci for generated bare artifacts #3346

NathanFlurry · 2025-11-04T19:57:08Z

No description provided.

vercel · 2025-11-04T19:57:11Z

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Preview	Comments	Updated (UTC)
rivetkit-serverless	Ready	Preview	Comment	Nov 5, 2025 2:14am

3 Skipped Deployments

Project	Deployment	Preview	Updated (UTC)
rivet-cloud	Ignored		Nov 5, 2025 2:14am
rivet-inspector	Ignored	Preview	Nov 5, 2025 2:14am
rivet-site	Ignored	Preview	Nov 5, 2025 2:14am

NathanFlurry · 2025-11-04T19:58:07Z

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

How to use the Graphite Merge Queue

Add the label merge-queue to this PR to add it to the merge queue.

You must have a Graphite account in order to use the merge queue. Sign up using this link.

_{An organization admin has enabled the Graphite Merge Queue in this repository.} _{Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.}

This stack of pull requests is managed by Graphite. Learn more about stacking.

claude · 2025-11-04T19:58:59Z

PR Review: Trigger Rust CI for Generated BARE Artifacts

Overview

This PR adds **/*.bare to the Rust CI trigger paths to ensure CI runs when BARE schema files are modified. This is a small but important configuration change.

Code Quality: ✅ Excellent

Strengths:

Clean, minimal change that addresses a specific gap in CI coverage
Properly placed alongside related file patterns (*.rs, Cargo.toml, Cargo.lock)
Follows existing YAML formatting conventions

Correctness: ✅ Correct

Analysis:

BARE (.bare) files are schema definitions used by the vbare-compiler during the build process (build.rs scripts)
These schemas generate Rust code via vbare_compiler::process_schemas_with_config() in packages like:
- engine/sdks/rust/ups-protocol/
- engine/sdks/rust/data/
- engine/sdks/rust/runner-protocol/
- engine/sdks/rust/epoxy-protocol/
Changes to .bare files directly affect generated Rust code, so triggering CI on these changes is essential
The workflow currently runs cargo fmt and cargo check which will catch any issues from schema changes

Potential Concerns: ⚠️ Minor

Pattern Specificity: The pattern **/*.bare will match any .bare file in the repository. Consider if you want to be more specific (e.g., engine/sdks/schemas/**/*.bare), though the current broad pattern is likely fine and future-proof.
Missing from Other CI Workflows: I noticed this only updates .github/workflows/rust.yml. If there are other workflows that should also trigger on .bare changes (e.g., integration tests, E2E tests), they may need similar updates.

Performance: ✅ No Impact

This change only affects CI trigger conditions, no runtime performance impact
May slightly increase CI runs if .bare files are frequently modified, but this is the desired behavior

Security: ✅ No Concerns

No security implications from this configuration change

Test Coverage: ✅ Adequate

The existing CI jobs (fmt, check) are sufficient to catch issues from .bare schema changes since they:

Generate code during build via build.rs
Run formatting checks
Run compilation checks with warnings as errors

Recommendation: ✅ APPROVE

This is a well-targeted fix that closes a gap in CI coverage. The change is minimal, correct, and follows project conventions. No blocking issues identified.

Optional Enhancement: Consider documenting in CLAUDE.md that .bare schema files trigger Rust CI, since they're an important part of the build process.

claude · 2025-11-04T20:33:20Z

PR Review: CI trigger for .bare artifacts

Summary

This PR adds **/*.bare to the paths that trigger Rust CI workflows. This is a small but important change to ensure CI runs when BARE schema files are modified.

Analysis

What are .bare files?
The .bare files are BARE (Binary Application Record Encoding) schema definition files used to generate both Rust and TypeScript code for protocol definitions (runner-protocol, epoxy-protocol, ups-protocol, etc.). These schemas are compiled during build time via build.rs scripts using vbare-compiler and @bare-ts/tools.

Why this change is needed:
Currently, modifying .bare schema files doesn't trigger the Rust CI pipeline, which means:

Generated Rust code from schema changes isn't validated
Potential compilation errors or breaking changes in protocols could go undetected
The CI filter is incomplete for files that directly impact Rust builds

Code Quality: ✅ Good

Positives:

Clean, minimal change with clear intent
Follows existing pattern (same indentation, glob style as other entries)
Placed logically with other build-related patterns (Cargo.toml, Cargo.lock)
Commit message follows conventional commit format: ci: trigger rust ci for generated bare artifacts

No issues found with:

Code formatting/style
CI workflow syntax
Filter pattern syntax

Potential Concerns: ⚠️ Minor

Build time impact: Every .bare file change will now trigger full Rust CI (fmt, check jobs). Given that there are 14 .bare files across the codebase, this could increase CI usage if schemas are frequently modified. However, this is the correct behavior since these files directly affect Rust compilation.
Consideration - Test coverage: While this ensures builds are checked, consider whether integration tests adequately cover protocol changes. Since .bare files define critical protocol schemas (actor communication, KV operations, WebSocket handling), schema changes could break runtime behavior even if code compiles.

Security: ✅ No concerns

No security implications
Only affects CI triggering logic

Performance: ✅ Acceptable

Minimal impact on CI runtime
Properly scoped to only trigger when relevant files change
Uses the path filter optimization pattern already in place

Recommendations

✅ Approve this PR - The change is correct and necessary
💡 Optional enhancement: Consider documenting in CI comments or project docs that .bare schema files trigger Rust CI because they generate code during build time. This helps future contributors understand the relationship.
💡 Future consideration: If .bare files are modified frequently and CI costs become a concern, you could:
- Add a separate workflow specifically for schema validation (faster than full Rust CI)
- Use build.rs rerun-if-changed directives more aggressively
- However, this is likely premature optimization

Verdict: ✅ LGTM - Approve and Merge

This is a straightforward, necessary fix that correctly identifies .bare files as Rust build inputs. The implementation is clean and follows existing patterns.

claude · 2025-11-04T20:40:05Z

Code Review

Summary

This PR adds **/*.bare to the Rust CI workflow path filter to trigger CI when BARE schema files are modified. This is a valuable addition given that .bare files are used to generate Rust code via build scripts.

Positive Observations

✅ Correct Problem Identification: The change correctly identifies that .bare schema files affect Rust compilation through the vbare_compiler in build.rs scripts (e.g., engine/sdks/rust/epoxy-protocol/build.rs, engine/sdks/rust/data/build.rs)

✅ Consistent Pattern: Follows the existing pattern of tracking file types that affect Rust compilation (.rs, Cargo.toml, Cargo.lock)

✅ Minimal Change: Single-line addition with clear intent

Potential Considerations

1. Build Script Dependency Tracking

Issue: Cargo build scripts don't automatically declare dependencies on the .bare schema files they process. This means:

Modifying a .bare file may not trigger a rebuild locally without a clean build
The CI will run, but developers might miss issues until CI runs

Recommendation: Consider adding cargo:rerun-if-changed directives to the build.rs files. For example, in engine/sdks/rust/epoxy-protocol/build.rs:

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR")?;
    let workspace_root = Path::new(&manifest_dir)
        .parent()
        .and_then(|p| p.parent())
        .and_then(|p| p.parent())
        .ok_or("Failed to find workspace root")?;

    let schema_dir = workspace_root
        .join("sdks")
        .join("schemas")
        .join("epoxy-protocol");

    // Tell cargo to rerun if schema files change
    println!("cargo:rerun-if-changed={}", schema_dir.display());

    let cfg = vbare_compiler::Config::with_hashable_map();
    vbare_compiler::process_schemas_with_config(&schema_dir, &cfg)
}

This would ensure both local builds and CI properly detect schema changes.

2. Scope Consideration

The pattern **/*.bare will match bare files anywhere in the repository, including:

TypeScript schemas in rivetkit-typescript/packages/rivetkit/schemas/ (which generate TypeScript, not Rust)

This might trigger Rust CI unnecessarily for TypeScript-only schema changes. If this becomes an issue, consider a more specific pattern like:

- 'engine/sdks/schemas/**/*.bare'

However, given the small size of these files and CI efficiency, this is likely not a practical concern.

Verdict

LGTM ✅ - This is a solid change that improves CI coverage. The build script dependency tracking suggestion is an enhancement for the future, not a blocker for this PR.

Test Coverage

The change affects CI infrastructure rather than runtime code, so manual testing would involve:

Verifying CI triggers when .bare files are modified
Confirming the build succeeds/fails appropriately

Review generated by Claude Code

claude · 2025-11-04T21:02:35Z

PR Review

Summary

This PR adds **/*.bare files to the Rust CI workflow path filters, ensuring that changes to BARE schema files trigger the Rust CI pipeline.

Code Quality: ✅ Excellent

Strengths:

Correct placement: The change is added to the path filters in the changes job, which is the proper location for detecting relevant file changes
Consistent pattern: Uses the same glob pattern style (**/*.bare) as the existing filters for *.rs, Cargo.toml, and Cargo.lock
Well-scoped: The change is minimal and focused on a single, clear objective

Technical Analysis: ✅ Valid

Context:

BARE (Binary Application Record Encoding) schema files (.bare) are used throughout the codebase to define serialization protocols
Found 15+ .bare files in the repository under engine/sdks/schemas/ and rivetkit-typescript/packages/rivetkit/schemas/
These schemas are compiled into Rust code at build time via vbare-compiler in build.rs scripts
Multiple packages depend on vbare and vbare-compiler (epoxy-protocol, runner-protocol, ups-protocol, data, etc.)

Why this change is necessary:

Changes to .bare files modify the generated Rust code that gets compiled into the final binaries
Without this filter, PRs that only modify .bare files would skip Rust CI checks
This creates a potential for broken builds to be merged without validation

Potential Issues: ✅ None Found

No bugs, performance concerns, or security issues identified.

Test Coverage: ✅ Appropriate

This is an infrastructure change to CI configuration. The change itself:

Will be validated when the CI runs on this PR
Is self-testing by nature (incorrect patterns would cause CI failures)
Follows the existing pattern established by other file filters

Recommendations: None

This is a straightforward, correct change that addresses a real gap in the CI coverage. The implementation is clean and follows established patterns.

Approval: ✅ LGTM - Ready to merge

claude · 2025-11-05T00:14:57Z

Code Review for PR #3346

Summary

This PR adds .bare files to the path filter in the Rust CI workflow. This is a good addition since .bare files are schema definitions that generate Rust code during the build process.

Positive Findings ✓

Correct Problem Identification: The change properly addresses the need to trigger Rust CI when BARE schema files change, since these files generate Rust code via build.rs scripts using the vbare-compiler.
Appropriate Placement: The addition is correctly placed in the paths-filter configuration alongside other Rust-related file patterns.
Consistent with Existing Patterns: The pattern **/*.bare follows the same glob syntax as other entries (**/*.rs, **/Cargo.toml, etc.).
Minimal and Focused: The change is surgical and only touches what's necessary.

Suggestions for Consideration

Documentation: Consider adding a comment above the .bare entry explaining that these are BARE schema files that generate Rust code at build time. This would help future maintainers understand why they're included:
```
rust:
  - '**/*.rs'
  - '**/*.bare'  # BARE schema files that generate Rust code
  - '**/Cargo.toml'
```
Build Script Awareness: While the current implementation is correct, note that changes to build.rs files themselves would also affect code generation. The workflow already includes Rust files (**/*.rs), which covers this, but it's worth being aware of the relationship.

Verification

I verified that:

There are 14 .bare files in the repository (in engine/sdks/schemas/ and rivetkit-typescript/packages/rivetkit/schemas/)
These files are processed by vbare-compiler in build.rs scripts
Changes to these files would generate different Rust code, making CI runs necessary

Conclusion

Approval: ✅ LGTM

This is a well-targeted fix that ensures CI runs when schema definitions change. The change is small, correct, and follows existing conventions. The optional documentation suggestion is minor and not blocking.

Review generated by Claude Code

claude · 2025-11-05T02:15:16Z

Pull Request Review

Summary

This PR adds **/*.bare files to the path filter in the Rust CI workflow, ensuring that changes to BARE schema files trigger the Rust CI pipeline.

Analysis

What are .bare files?

Based on the codebase analysis, .bare files are BARE (Binary Application Record Encoding) schema definitions used for efficient binary serialization. The project uses:

vbare-compiler for Rust code generation (seen in build.rs files)
@bare-ts/tools for TypeScript code generation

These schema files generate Rust code during the build process via build.rs scripts (e.g., engine/sdks/rust/epoxy-protocol/build.rs:16-18, engine/sdks/rust/runner-protocol/build.rs:21-22), making them critical to the Rust compilation pipeline.

Review Feedback

✅ Code Quality - Excellent

The change is minimal, focused, and correct
Follows the existing pattern for file type filters in the workflow
Conventional commit message follows the project's standards

✅ Correctness - Valid Change

This change is necessary and correct because:

Changes to .bare schema files trigger code generation in Rust build.rs scripts
Generated Rust code affects compilation and type safety
Without this filter, schema changes could be merged without verifying they compile correctly
The change ensures CI catches issues like:
- Invalid BARE schema syntax
- Schema changes that break existing Rust code
- Schema changes that cause compilation failures

✅ Consistency

The change is consistent with the existing pattern:

**/*.rs - Rust source files
**/*.bare - BARE schema files (generates Rust code) ✨ NEW
**/Cargo.toml - Dependency definitions
**/Cargo.lock - Dependency lock files
.github/workflows/rust.yml - CI workflow itself

📝 Suggestions

1. Consider Adding build.rs Files to the Filter

The build.rs scripts process .bare files during compilation. Changes to these scripts could affect code generation without triggering CI:

filters: |
  rust:
    - '**/*.rs'
    - '**/*.bare'
    - '**/build.rs'  # Suggested addition
    - '**/Cargo.toml'
    - '**/Cargo.lock'
    - '.github/workflows/rust.yml'

However, since build.rs files match the **/*.rs glob pattern, this is already covered. No action needed! 👍

2. Documentation Consideration (Optional, Low Priority)

Consider documenting the relationship between .bare files and Rust builds somewhere (e.g., in CLAUDE.md or a contributing guide) to help future contributors understand why schema changes trigger Rust CI. This is a nice-to-have, not required for this PR.

Verdict

✅ LGTM - Approve with confidence

This is a well-scoped, necessary change that closes a gap in CI coverage. The .bare schema files are integral to the Rust build process through code generation, and this ensures CI validation occurs when they change.

Impact: Improves CI reliability by catching schema-related compilation issues earlier.

Risk: None - This only adds an additional trigger condition; it doesn't modify behavior or skip any checks.

Great work on identifying and fixing this gap in the CI pipeline! 🚀

claude · 2025-11-05T02:15:37Z

Code Review

Summary

This PR adds **/*.bare to the path filters in the Rust CI workflow, ensuring that changes to BARE schema files trigger the Rust CI pipeline. This is a necessary and correct change.

Analysis

Context:

The repository uses BARE (Binary Application Record Encoding) schema files (.bare) for data serialization
These schema files are used for code generation in Rust via vbare-compiler in build.rs scripts
Multiple packages use BARE schemas: runner-protocol, ups-protocol, epoxy-protocol, and data packages
When .bare files change, Rust code is regenerated at build time, which should trigger CI validation

What this PR does:
Adds **/*.bare to the paths-filter configuration so that modifications to BARE schema files are detected as Rust code changes and trigger:

Rustfmt checks
Cargo check with warnings-as-errors
Other Rust CI validations

Review Findings

✅ Code Quality

Clean and minimal change: Single line addition, well-scoped
Consistent pattern: Follows the existing pattern of other path filters (*.rs, Cargo.toml, Cargo.lock)
Correct glob pattern: Uses **/ prefix to match files at any depth in the repository

✅ Correctness

Addresses real need: BARE files generate Rust code via build.rs scripts (as seen in runner-protocol/build.rs:21-22)
Prevents issues: Without this filter, changes to .bare files would not trigger CI, potentially allowing broken schema changes to be merged
Complete coverage: The **/ pattern will catch all .bare files in both engine/sdks/schemas/ and rivetkit-typescript/packages/rivetkit/schemas/

✅ Best Practices

Matches repository conventions: Aligns with CLAUDE.md guidance on testing and CI
Prevents false negatives: Ensures schema changes that affect Rust codegen are validated
Appropriate scope: Only affects the change detection, not the actual CI jobs

Recommendations

No changes needed - this PR is ready to merge as-is.

Optional Future Enhancements (not blocking):

Consider adding a test that validates .bare file syntax before running the full build
Document in CLAUDE.md or a CI README that .bare files trigger Rust CI (though the workflow itself is now self-documenting)

Security & Performance

No security concerns: Read-only path filter change
Performance impact: Minimal - only triggers CI when .bare files actually change, which should be infrequent
No test coverage needed: This is CI configuration, not application code

Conclusion

Approved ✓

This is a straightforward, necessary fix that ensures BARE schema files are properly validated through CI. The change is minimal, correct, and follows established patterns in the codebase.

Review generated by Claude Code

graphite-app · 2025-11-05T02:25:04Z

Merge activity

Nov 5, 2:25 AM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 5, 2:25 AM UTC: CI is running for this pull request on a draft pull request (#3368) due to your merge queue CI optimization settings.
Nov 5, 2:29 AM UTC: Merged by the Graphite merge queue via draft PR: #3368.

NathanFlurry requested a review from MasterPtato November 4, 2025 19:57

vercel bot had a problem deploying to Preview – rivetkit-serverless November 4, 2025 19:57 Failure

This was referenced Nov 4, 2025

fix(rivetkit): fix conns not being cleaned up if actor.createConn errors #3335

Closed

chore(engine): move smoke test to engine/tests/ #3337

Closed

chore(rivetkit): add debug logging around sleep condition #3336

Closed

NathanFlurry force-pushed the 11-04-chore_rivetkit_debounce_ws_message_ack branch from 05654a6 to a16734e Compare November 4, 2025 20:25

NathanFlurry force-pushed the 11-04-ci_trigger_rust_ci_for_generated_bare_artifacts branch from f2e1683 to 891274c Compare November 4, 2025 20:25

vercel bot deployed to Preview – rivetkit-serverless November 4, 2025 20:27 View deployment

graphite-app bot force-pushed the 11-04-chore_rivetkit_debounce_ws_message_ack branch from a16734e to 7973ad8 Compare November 4, 2025 20:59

graphite-app bot force-pushed the 11-04-ci_trigger_rust_ci_for_generated_bare_artifacts branch from 891274c to e8e5d95 Compare November 4, 2025 21:00

vercel bot deployed to Preview – rivetkit-serverless November 4, 2025 21:01 View deployment

MasterPtato approved these changes Nov 5, 2025

View reviewed changes

graphite-app bot force-pushed the 11-04-chore_rivetkit_debounce_ws_message_ack branch 2 times, most recently from 635c1c0 to 75c97ad Compare November 5, 2025 00:13

graphite-app bot force-pushed the 11-04-ci_trigger_rust_ci_for_generated_bare_artifacts branch from e8e5d95 to 7a5d98a Compare November 5, 2025 00:13

vercel bot deployed to Preview – rivetkit-serverless November 5, 2025 00:14 View deployment

ci: trigger rust ci for generated bare artifacts

ca1c932

NathanFlurry force-pushed the 11-04-ci_trigger_rust_ci_for_generated_bare_artifacts branch from 7a5d98a to ca1c932 Compare November 5, 2025 02:12

NathanFlurry force-pushed the 11-04-chore_rivetkit_debounce_ws_message_ack branch from 75c97ad to 2baa4b7 Compare November 5, 2025 02:13

vercel bot deployed to Preview – rivetkit-serverless November 5, 2025 02:14 View deployment

graphite-app bot pushed a commit that referenced this pull request Nov 5, 2025

ci: trigger rust ci for generated bare artifacts (#3346)

d3a8681

graphite-app bot closed this Nov 5, 2025

graphite-app bot deleted the 11-04-ci_trigger_rust_ci_for_generated_bare_artifacts branch November 5, 2025 02:29

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

ci: trigger rust ci for generated bare artifacts #3346

ci: trigger rust ci for generated bare artifacts #3346

Uh oh!

NathanFlurry commented Nov 4, 2025

Uh oh!

vercel bot commented Nov 4, 2025 •

edited

Loading

Uh oh!

NathanFlurry commented Nov 4, 2025 •

edited

Loading

Uh oh!

claude bot commented Nov 4, 2025

Uh oh!

claude bot commented Nov 4, 2025

Uh oh!

claude bot commented Nov 4, 2025

Uh oh!

claude bot commented Nov 4, 2025

Uh oh!

claude bot commented Nov 5, 2025

Uh oh!

claude bot commented Nov 5, 2025

Uh oh!

claude bot commented Nov 5, 2025

Uh oh!

graphite-app bot commented Nov 5, 2025 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

ci: trigger rust ci for generated bare artifacts #3346

ci: trigger rust ci for generated bare artifacts #3346

Uh oh!

Conversation

NathanFlurry commented Nov 4, 2025

Uh oh!

vercel bot commented Nov 4, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

NathanFlurry commented Nov 4, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

How to use the Graphite Merge Queue

Uh oh!

claude bot commented Nov 4, 2025

PR Review: Trigger Rust CI for Generated BARE Artifacts

Overview

Code Quality: ✅ Excellent

Correctness: ✅ Correct

Potential Concerns: ⚠️ Minor

Performance: ✅ No Impact

Security: ✅ No Concerns

Test Coverage: ✅ Adequate

Recommendation: ✅ APPROVE

Uh oh!

claude bot commented Nov 4, 2025

PR Review: CI trigger for .bare artifacts

Summary

Analysis

Code Quality: ✅ Good

Potential Concerns: ⚠️ Minor

Security: ✅ No concerns

Performance: ✅ Acceptable

Recommendations

Verdict: ✅ LGTM - Approve and Merge

Uh oh!

claude bot commented Nov 4, 2025

Code Review

Summary

Positive Observations

Potential Considerations

1. Build Script Dependency Tracking

2. Scope Consideration

Verdict

Test Coverage

Uh oh!

claude bot commented Nov 4, 2025

PR Review

Summary

Code Quality: ✅ Excellent

Technical Analysis: ✅ Valid

Potential Issues: ✅ None Found

Test Coverage: ✅ Appropriate

Recommendations: None

Uh oh!

claude bot commented Nov 5, 2025

Code Review for PR #3346

Summary

Positive Findings ✓

Suggestions for Consideration

Verification

Conclusion

Uh oh!

claude bot commented Nov 5, 2025

Pull Request Review

Summary

Analysis

What are .bare files?

Review Feedback

✅ Code Quality - Excellent

✅ Correctness - Valid Change

✅ Consistency

📝 Suggestions

Verdict

Uh oh!

claude bot commented Nov 5, 2025

Code Review

Summary

Analysis

Review Findings

✅ Code Quality

vercel bot commented Nov 4, 2025 •

edited

Loading

NathanFlurry commented Nov 4, 2025 •

edited

Loading

graphite-app bot commented Nov 5, 2025 •

edited

Loading