fix(rivetkit): uri encode actor ids to fix cloudflare workers actor id with generation #3504

NathanFlurry · 2025-11-20T22:19:58Z

No description provided.

vercel · 2025-11-20T22:20:03Z

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

Project	Deployment	Preview	Comments	Updated (UTC)
rivetkit-serverless	Ready	Preview	Comment	Nov 20, 2025 11:36pm

3 Skipped Deployments

Project	Deployment	Preview	Updated (UTC)
rivet-cloud	Ignored		Nov 20, 2025 11:36pm
rivet-inspector	Ignored	Preview	Nov 20, 2025 11:36pm
rivet-site	Ignored	Preview	Nov 20, 2025 11:36pm

NathanFlurry · 2025-11-20T22:20:24Z

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-20T22:21:25Z

Code Review

Summary

This PR adds URL encoding for actor IDs in WebSocket protocol headers to fix an issue with Cloudflare Workers when actor IDs contain colons (specifically the generation format: {doId}:{generation}). The changes correctly encode/decode actor IDs across all WebSocket connection points.

Positive Aspects ✅

Comprehensive Coverage: The fix is applied consistently across all layers:
- Rust guard service (encoding/decoding)
- TypeScript Cloudflare Workers driver (encoding)
- TypeScript manager gateway and router (decoding)
- Test infrastructure
Proper Symmetry: Encoding is done at the sender side and decoding at the receiver side, maintaining protocol consistency
Good Comment: The added comment in actors.rs:440 clearly explains why URL encoding is necessary
Error Handling: The Rust code properly handles decoding errors with context (invalid url encoding in actor id)

Issues & Recommendations 🔍

1. Minor: Inconsistent Variable Naming

In pegboard_gateway.rs:63, you introduce actor_id_raw to store the encoded value, then decode it to actor_id. This is good and clear. However, the variable name could be more explicit:

// Current
let actor_id_raw = protocols...
let actor_id = urlencoding::decode(actor_id_raw)...

// Suggestion (more explicit)
let actor_id_encoded = protocols...
let actor_id = urlencoding::decode(actor_id_encoded)...

2. Debugging Improvements in Test Code

The change in test-inline-client-driver.ts:184-202 moves the debug log after building protocols and adds the protocols to the log. This is good, but consider:

The original comment // Build protocols for the connection is now separated from where protocols are actually built
Consider keeping the debug statement closer to the connection attempt

3. Missing `WS_PROTOCOL_STANDARD` in Original Code

The change in test-inline-client-driver.ts:186 adds WS_PROTOCOL_STANDARD to the protocols array. This looks like it was missing before. Was this intentional or a separate fix bundled with this PR? If it's a separate issue, consider:

Mentioning it in the PR description
Or moving it to a separate commit/PR

4. Test Coverage

Consider adding a test case that specifically validates:

Actor IDs with colons are properly encoded/decoded
WebSocket connections work with actor IDs containing special characters
Round-trip encoding/decoding produces the correct actor ID

Example test case structure:

// Test actor ID with generation (contains colon)
const actorIdWithGeneration = "do-id-123:5";
const encoded = encodeURIComponent(actorIdWithGeneration);
// Verify encoded doesn't contain colon
// Verify decoded matches original

5. Security: URL Encoding Choice

The choice of URL encoding is appropriate for WebSocket protocol names. However, verify:

Does urlencoding::decode in Rust handle the same encoding as JavaScript's encodeURIComponent?
Both should use percent-encoding (RFC 3986), but worth confirming they're compatible

Performance Considerations ⚡

URL encoding/decoding is a lightweight operation with minimal overhead
No performance concerns for this change

Security Considerations 🔒

URL encoding properly escapes special characters, preventing potential injection issues
The error handling prevents invalid encoded values from causing panics
Good defensive programming

Alignment with CLAUDE.md 📋

✅ Follows conventions:

Proper use of workspace dependencies (urlencoding.workspace = true)
Error handling with context messages
Structured logging with tracing
Hard tabs in Rust code (should be enforced by rustfmt)

⚠️ Minor deviations:

No explicit test added for this functionality (though existing tests should catch regressions)

Recommended Next Steps

Optional: Consider renaming actor_id_raw to actor_id_encoded for clarity
Optional: Add explicit test case for actor IDs with special characters
Clarify: Document whether adding WS_PROTOCOL_STANDARD was intentional or incidental
Verify: Confirm encoding compatibility between Rust urlencoding and JS encodeURIComponent

Verdict

✅ Approve with minor suggestions

This is a solid fix that addresses the root cause comprehensively. The implementation is correct and follows best practices. The suggestions above are minor improvements that could enhance robustness and clarity, but they don't block merging this PR.

Great job on identifying the issue and implementing a clean solution across all affected layers!

pkg-pr-new · 2025-11-20T22:22:20Z

More templates

@rivetkit/cloudflare-workers

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/cloudflare-workers@3504

@rivetkit/db

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/db@3504

@rivetkit/framework-base

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/framework-base@3504

@rivetkit/next-js

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/next-js@3504

@rivetkit/react

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/react@3504

rivetkit

pnpm add https://pkg.pr.new/rivet-dev/rivet/rivetkit@3504

@rivetkit/sql-loader

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/sql-loader@3504

@rivetkit/engine-runner

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/engine-runner@3504

@rivetkit/engine-runner-protocol

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/engine-runner-protocol@3504

commit: 1431ddd

…d with generation

claude · 2025-11-20T23:48:17Z

PR Review: URI Encoding for Actor IDs with Generation

Summary

This PR fixes an important bug where actor IDs containing colons (from the generation suffix format {doId}:{generation}) were breaking WebSocket connections in Cloudflare Workers. The fix properly URI-encodes actor IDs when passed in WebSocket protocol headers and decodes them on the server side.

Code Quality: ✅ Good

Strengths:

Correct Implementation: The fix properly uses encodeURIComponent() on the TypeScript side and urlencoding::decode() on the Rust side
Consistent Pattern: Applied across all relevant code paths (both TypeScript and Rust)
Good Documentation: Added a helpful comment in the test explaining why encoding is needed
Dependency Management: Properly uses existing workspace dependency (urlencoding.workspace = true)

Code Style Adherence:

✅ Follows Rust structured logging patterns (e.g., ?x for debug formatting)
✅ Uses workspace dependencies correctly
✅ Error handling follows anyhow patterns

Potential Issues: ⚠️ Minor Concerns

Redundant .to_string() call (packages/guard/src/routing/pegboard_gateway.rs:102)
- Line 75 already calls .to_string() on the decoded actor_id
- Line 102 calls .to_string() again on actor_id_str which is already a String
- Fix: Change line 102 from (actor_id.to_string(), token) to (actor_id, token)
Missing WS_PROTOCOL_STANDARD in some locations
- The change adds WS_PROTOCOL_STANDARD to test-inline-client-driver.ts:186, which is good
- However, should verify this is consistently used in all WebSocket protocol arrays across the codebase
- Currently CloudflareActorsManagerDriver already has it ("rivet" protocol), so this is consistent

Performance Considerations: ✅ Good

URI encoding/decoding has minimal overhead
No N+1 queries or performance anti-patterns introduced
The urlencoding crate is efficient for this use case

Security Concerns: ✅ Good

Prevents injection: Proper encoding prevents special characters in actor IDs from breaking protocol parsing
No SQL injection risk: Actor IDs are properly validated with Id::parse() before use
No XSS concerns: This is server-to-server WebSocket communication

Test Coverage: ⚠️ Needs Improvement

What's Tested:

✅ The fix is applied to the test helper in test-inline-client-driver.ts
✅ Encoding is now used in ping_actor_websocket_via_guard test helper

What's Missing:

❌ No explicit test case for actor IDs with colons/generations (e.g., doId:123)
❌ No test verifying the decode/encode round-trip works correctly
❌ No test for error cases (invalid URL encoding)

Recommendation: Add a test case that specifically creates an actor with a generation-based ID and verifies WebSocket connections work correctly. Something like:

#[tokio::test]
async fn test_actor_websocket_with_generation_id() {
    let actor_id = "test-do-id:42"; // ID with colon/generation
    // Test WebSocket connection works
}

Architecture & Design: ✅ Good

The fix is in the right place (encoding at protocol boundary)
Follows the principle of encoding data when crossing protocol boundaries
Maintains compatibility with existing actor ID format

Specific Code Comments

packages/guard/src/routing/pegboard_gateway.rs:73-75

let actor_id = urlencoding::decode(actor_id_raw)
    .context("invalid url encoding in actor id")?
    .to_string();

✅ Good error context message

packages/guard/src/routing/pegboard_gateway.rs:106

let actor_id = Id::parse(&actor_id_str).context("invalid x-rivet-actor header")?;

⚠️ Minor: Error message mentions "x-rivet-actor header" but this code path is used for both WebSocket protocols and HTTP headers. Consider a more generic message like "invalid actor id".

rivetkit-typescript/packages/rivetkit/src/driver-test-suite/test-inline-client-driver.ts:191-197

logger().debug({
    msg: "connecting to websocket",
    url: finalWsUrl,
    protocols,
});

✅ Excellent improvement: Adding protocols to debug logging helps troubleshooting

Summary of Recommendations

Must Fix:

Remove redundant .to_string() call on line 102 of pegboard_gateway.rs

Should Consider:

Add explicit test coverage for actor IDs with colons/generations
Update error message on line 106 to be more generic
Consider adding a comment in the Rust code explaining why URL decoding is needed (similar to the TypeScript comment)

Overall Assessment: ✅ Approve with Minor Changes

This is a solid bug fix that addresses a real issue with Cloudflare Workers actor IDs. The implementation is correct and follows best practices. With the minor cleanup of the redundant .to_string() call and ideally some additional test coverage, this is ready to merge.

Impact: This fix enables proper actor resurrection tracking in Cloudflare Workers environments where actor IDs include generation suffixes.

claude · 2025-11-20T23:49:06Z

Code Review

Summary

This PR fixes a critical issue where actor IDs containing colons (format: doId:generation) were failing in WebSocket connections. The colon character is not allowed in WebSocket protocol names per the RFC spec, causing connection failures in Cloudflare Workers and other environments.

✅ Positive Aspects

Correct Use of URL Encoding: The PR properly uses encodeURIComponent in TypeScript and urlencoding in Rust to handle special characters in actor IDs.
Comprehensive Fix: The change is applied consistently across all relevant locations:
- Cloudflare Workers manager driver (encoding/decoding)
- RivetKit gateway and router (decoding)
- Test client driver (encoding)
- Rust guard routing (decoding)
- Engine test utilities (encoding)
Proper Dependency Management: The urlencoding dependency was already in the workspace dependencies, so no new dependencies were added.
Good Documentation: The Rust code includes a helpful comment explaining why URL encoding is needed.

🔍 Code Quality Issues

1. Redundant `.to_string()` Call

// engine/packages/guard/src/routing/pegboard_gateway.rs:73-75
let actor_id = urlencoding::decode(actor_id_raw)
    .context("invalid url encoding in actor id")?
    .to_string();  // This returns a String already

// Line 81 - unnecessary second conversion
(actor_id, token)  // Changed from (actor_id.to_string(), token)

Issue: The urlencoding::decode() already returns a Cow<str> that's converted to String via .to_string() on line 75. The variable actor_id is already a String, so line 103 doesn't need & in the parse call anymore (the diff shows it was changed but the reference is correct).

Recommendation: The code is actually correct as-is, but could be simplified slightly for clarity.

2. Missing Reference in Parse Call

// engine/packages/guard/src/routing/pegboard_gateway.rs:106
let actor_id = Id::parse(&actor_id_str).context("invalid x-rivet-actor header")?;

Issue: The variable is named actor_id_str but it's actually the decoded actor ID, not the raw string. The addition of & is correct since actor_id is now a String (line 81 returns it), but the naming is slightly misleading since it's no longer the "str" from the HTTP case.

Recommendation: Consider renaming for clarity:

let actor_id_decoded = if is_websocket {
    // ... decoding logic
    (actor_id, token)
} else {
    // ... HTTP header logic  
    (actor_id, token)
};
let actor_id = Id::parse(&actor_id_decoded).context("invalid actor id")?;

3. Inconsistent Context Messages

// Line 74: "invalid url encoding in actor id"
// Line 106: "invalid x-rivet-actor header"

Issue: The error message on line 106 still references "x-rivet-actor header" but this path is now used for both WebSocket protocols and HTTP headers.

Recommendation: Use a more generic message:

let actor_id = Id::parse(&actor_id_str).context("invalid actor id format")?;

🔒 Security Considerations

✅ No security concerns identified. The use of URL encoding/decoding is the correct approach and doesn't introduce injection vulnerabilities. The urlencoding crate properly handles malformed input.

⚡ Performance Considerations

Minor consideration: URL encoding/decoding adds a small overhead to every WebSocket connection. However:

This is necessary for correctness
The overhead is minimal (single string operation)
This only affects the connection handshake, not message passing

Verdict: Acceptable performance impact for correctness.

🧪 Test Coverage

Good: The PR updates the test helper function ping_actor_websocket_via_guard to use URL encoding, which means existing tests will validate the change.

Suggestion: Consider adding a specific test case that validates actor IDs with colons (i.e., with generations) to ensure the encoding/decoding roundtrip works correctly:

#[tokio::test]
async fn test_actor_id_with_generation_via_websocket() {
    // Test that actor IDs with colons (format: doId:generation) work correctly
    let actor_id_with_generation = format!("{}:1", Uuid::new_v4());
    // ... test WebSocket connection with this ID
}

📝 Minor Issues

Test Client Driver Change: The addition of WS_PROTOCOL_STANDARD import and push in test-inline-client-driver.ts:186 is good for consistency, though this appears unrelated to the URL encoding fix. Worth noting for release notes.
Logging Change: The debug log was moved after the protocols array is built, which is actually better since it now logs the full protocols array. Good improvement!

✅ Recommended Approval

This PR correctly fixes a real bug that would prevent Cloudflare Workers from routing to actors with generation numbers. The implementation is sound, comprehensive, and follows Rust/TypeScript best practices. The minor issues noted above are cosmetic and don't affect correctness.

Recommendation: Approve with optional cleanup of the naming/messaging issues mentioned above.

claude · 2025-11-20T23:49:07Z

Code Review

Summary

This PR fixes an important bug where actor IDs containing colons (format: {doId}:{generation}) were causing issues with WebSocket connections in Cloudflare Workers. The colon character is not allowed in WebSocket protocol names, so the fix properly URI-encodes actor IDs in all WebSocket protocol headers and decodes them on the server side.

Positive Aspects ✅

Comprehensive fix: The PR addresses the issue across all affected layers:
- TypeScript client drivers (Cloudflare Workers, inline test driver)
- TypeScript server-side routing (manager gateway and router)
- Rust guard service (pegboard gateway)
- Test infrastructure
Consistent encoding pattern: Uses encodeURIComponent in TypeScript and urlencoding::encode in Rust consistently across all locations.
Good documentation: Added a helpful comment in engine/packages/engine/tests/common/actors.rs:440 explaining why encoding is needed.
Test coverage improvement: Updated the test infrastructure to properly encode actor IDs, which means existing tests will now validate this behavior.

Issues & Concerns 🔍

Critical: Missing Rust Client Update ⚠️

The Rust RivetKit client at rivetkit-rust/packages/client/src/remote_manager.rs:298 is NOT updated in this PR, but it should be for consistency:

// Line 298 - currently NOT encoding the actor_id
format!("{}{}", WS_PROTOCOL_ACTOR, actor_id),

This should be:

format!("{}{}", WS_PROTOCOL_ACTOR, urlencoding::encode(actor_id)),

The urlencoding crate is already imported and used elsewhere in the same file (line 308), so this is a straightforward fix. Without this change, the Rust client will fail to connect to actors with generation numbers via WebSocket.

Minor: Redundant `.to_string()` in Rust Code

In engine/packages/guard/src/routing/pegboard_gateway.rs:102:

(actor_id.to_string(), token)

This is redundant since actor_id is already a String from line 75. This can be simplified to just (actor_id, token).

Code Quality: Error Context

In engine/packages/guard/src/routing/pegboard_gateway.rs:74:

.context("invalid url encoding in actor id")?

Consider adding the actual actor_id_raw value to the error context for better debugging:

.with_context(|| format!("invalid url encoding in actor id: {}", actor_id_raw))?

Performance Considerations 🚀

The encoding/decoding operations are minimal overhead and only happen during WebSocket connection establishment, not for every message. This is negligible and acceptable.

Security Considerations 🔒

Positive: URI encoding is the correct approach here and actually improves security by:

Preventing injection attacks via malformed actor IDs
Ensuring proper parsing of protocol headers
Following web standards for encoding special characters

No security concerns identified.

Test Coverage ✅

Good test coverage:

Updated engine/packages/engine/tests/common/actors.rs to encode actor IDs in test infrastructure
Updated rivetkit-typescript/packages/rivetkit/src/driver-test-suite/test-inline-client-driver.ts to use encoding
Added logging improvement in test driver showing protocols being used

Existing tests will now validate the encoding/decoding behavior automatically.

Recommendations

Must fix: Add URL encoding to the Rust client at rivetkit-rust/packages/client/src/remote_manager.rs:298
Optional cleanup: Remove redundant .to_string() at pegboard_gateway.rs:102
Nice to have: Improve error context to include the raw actor ID value

Verdict

Approve with required changes - The fix is correct and comprehensive for the TypeScript ecosystem, but needs the Rust client update to be complete. The core logic is sound and follows best practices.

Great job identifying and fixing this issue! The use of URI encoding is the correct solution for handling colons in WebSocket protocol names.

claude · 2025-11-20T23:51:08Z

Pull Request Review

Summary

This PR fixes a bug where actor IDs containing colons (from generation tracking) were breaking Cloudflare Workers WebSocket connections. The fix properly URL-encodes actor IDs when passing them via WebSocket protocol headers.

Code Quality ✅

Strengths:

The fix is correctly applied symmetrically: encoding on the client side and decoding on the server side
All affected code paths have been updated (Rust guard, TypeScript manager driver, gateway, router, and test client)
Good inline comments explaining the reason for encoding ("colons are not allowed in WebSocket protocol names")
Uses proper workspace dependencies for urlencoding in Rust
Uses standard encodeURIComponent/decodeURIComponent in TypeScript

Minor observations:

The Rust code at engine/packages/guard/src/routing/pegboard_gateway.rs:81 has a redundant .to_string() call since actor_id is already a String after decoding
The fix in test-inline-client-driver.ts also adds WS_PROTOCOL_STANDARD to the protocols list, which appears to be a separate improvement (good catch!)

Potential Issues ❌

Critical - Missing Error Handling:

In engine/packages/guard/src/routing/pegboard_gateway.rs:73-75:

let actor_id = urlencoding::decode(actor_id_raw)
    .context("invalid url encoding in actor id")?
    .to_string();

This will return an error if the actor ID is not properly URL-encoded. However, this creates a backwards compatibility issue:

Old clients that don't URL-encode actor IDs will now fail
The error message doesn't clearly indicate this is a client-side issue

Recommendation: Consider adding backwards compatibility handling:

// Try to decode, but fall back to raw string for backwards compatibility
let actor_id = urlencoding::decode(actor_id_raw)
    .map(|s| s.to_string())
    .unwrap_or_else(|_| {
        tracing::warn\!(actor_id_raw, "actor id not url-encoded, using raw value for backwards compatibility");
        actor_id_raw.to_string()
    });

Or, if you want to enforce the new behavior, document this as a breaking change.

Performance Considerations ✅

URL encoding/decoding adds minimal overhead
The operations are performed once per WebSocket connection establishment, not per message
No performance concerns

Security Concerns ⚠️

Medium - Input Validation:

The URL decoding in Rust properly handles invalid encoding and returns an error. However, consider:

DoS via malformed input: Extremely long or malformed URL-encoded strings could potentially cause issues. The current implementation is likely safe, but consider adding length validation before decoding.
Injection concerns: Actor IDs are passed to Id::parse() after decoding. Ensure that Id::parse() has proper validation to prevent any injection attacks if malicious data gets through.

Looking at the code:

let actor_id = Id::parse(&actor_id_str).context("invalid x-rivet-actor header")?;

This appears safe since Id::parse() validates the format. ✅

Test Coverage ⚠️

Missing Tests:

No test for the colon character case: The most critical test case (actor ID with colon like abc123:1) is not explicitly tested. The existing test at engine/packages/engine/tests/common/actors.rs:443 now encodes the actor ID, but we should verify:
- Actor IDs with colons work correctly
- Actor IDs with other special characters that need encoding
- Decoding failures are handled gracefully
No test for backwards compatibility: If you decide to add backwards compatibility, add a test for non-encoded actor IDs

Recommendation: Add integration tests like:

#[tokio::test]
async fn test_actor_id_with_generation() {
    let actor_id = "abc123:42"; // Contains colon
    ping_actor_websocket_via_guard(guard_port, actor_id).await;
}

#[tokio::test]
async fn test_actor_id_with_special_chars() {
    let actor_id = "abc:123#test"; // Multiple special chars
    ping_actor_websocket_via_guard(guard_port, actor_id).await;
}

Additional Recommendations

Documentation: Update any documentation about actor ID format to mention that colons are used for generation tracking
Consistency check: Verify that HTTP header-based routing (the else branch at line 82-103 in pegboard_gateway.rs) doesn't need similar encoding. HTTP headers may have different encoding requirements.
Code cleanup: Remove the redundant .to_string() at line 102:

// Before
(actor_id.to_string(), token)

// After  
(actor_id, token)

TypeScript type safety: Consider adding validation when parsing actor IDs in TypeScript to ensure they match the expected format before encoding.

Verdict

This is a good fix for a real bug, but it needs:

⚠️ Decision on backwards compatibility approach
⚠️ Additional test coverage for the colon case
✅ Minor code cleanup

The core logic is sound and properly handles the encoding/decoding symmetrically across the codebase.

graphite-app · 2025-11-21T02:40:49Z

Merge activity

Nov 21, 2:40 AM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 21, 2:42 AM UTC: CI is running for this pull request on a draft pull request (#3515) due to your merge queue CI optimization settings.
Nov 21, 2:43 AM UTC: Merged by the Graphite merge queue via draft PR: #3515.

…d with generation (#3504)

This was referenced Nov 20, 2025

chore(rivetkit): make action cancelled error more descriptive #3500

Closed

fix(pb): stop actors from destroying on goingaway #3501

Closed

fix(pb): add ability to timeout force resceduling pending state #3502

Closed

NathanFlurry mentioned this pull request Nov 20, 2025

chore(rivetkit): fix lockfile #3503

Closed

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

NathanFlurry mentioned this pull request Nov 20, 2025

feat(cloudflare-workers): add createInlineClient #3466

Closed

NathanFlurry changed the title ~~fix(rivetkit): uri encode actor ids to fix cloudfalre workers actor id with generation~~ fix(rivetkit): uri encode actor ids to fix cloudflare workers actor id with generation Nov 20, 2025

NathanFlurry force-pushed the 11-20-fix_rivetkit_uri_encode_actor_ids_to_fix_cloudfalre_workers_actor_id_with_generation branch from 4dbfcc3 to 9faab1f Compare November 20, 2025 23:32

NathanFlurry force-pushed the 11-20-chore_rivetkit_fix_lockfile branch from 763302d to 57ae58f Compare November 20, 2025 23:32

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

This was referenced Nov 20, 2025

fix(gateway): prevent gc from removing hibernating in flight req, check actor started after sub when hibernating #3505

Closed

chore(examples): add counter-next-js example #3506

Closed

fix(rivetkit): uri encode actor ids to fix cloudfalre workers actor i…

1431ddd

…d with generation

NathanFlurry force-pushed the 11-20-fix_rivetkit_uri_encode_actor_ids_to_fix_cloudfalre_workers_actor_id_with_generation branch from 9faab1f to 1431ddd Compare November 20, 2025 23:35

NathanFlurry force-pushed the 11-20-chore_rivetkit_fix_lockfile branch from 57ae58f to 6557c65 Compare November 20, 2025 23:35

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

NathanFlurry mentioned this pull request Nov 21, 2025

fix(engine): ensure first keepalive tick is not skipped to prevent timeout on ws hibernation #3507

Closed

MasterPtato mentioned this pull request Nov 21, 2025

chore: remove msg id parts from protocol, move id utils to runner protocol crate #3508

Closed

This was referenced Nov 21, 2025

chore(rivetkit): buffer outbound tunnel messages #3509

Closed

docs: runner lifecycle #3510

Closed

chore(engine): upgrade vbare 0.0.4 #3511

Closed

NathanFlurry changed the base branch from 11-20-chore_rivetkit_fix_lockfile to graphite-base/3504 November 21, 2025 02:31

This was referenced Nov 21, 2025

fix(runner-protocol): add noop converters for v1 -> v3 #3512

Closed

fix(runner-protocol): fix decoding gateway & req id from req id instead of message id #3513

Closed

chore(pegboard-runner): log runner messages #3514

Closed

NathanFlurry requested a review from MasterPtato November 21, 2025 02:34

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

fix(rivetkit): uri encode actor ids to fix cloudflare workers actor i…

3ba72ca

…d with generation (#3504)

graphite-app bot closed this Nov 21, 2025

graphite-app bot deleted the 11-20-fix_rivetkit_uri_encode_actor_ids_to_fix_cloudfalre_workers_actor_id_with_generation branch November 21, 2025 02:43

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

fix(rivetkit): uri encode actor ids to fix cloudflare workers actor id with generation #3504

fix(rivetkit): uri encode actor ids to fix cloudflare workers actor id with generation #3504

Uh oh!

NathanFlurry commented Nov 20, 2025

Uh oh!

vercel bot commented Nov 20, 2025 •

edited

Loading

Uh oh!

NathanFlurry commented Nov 20, 2025 •

edited

Loading

Uh oh!

claude bot commented Nov 20, 2025

Uh oh!

pkg-pr-new bot commented Nov 20, 2025 •

edited

Loading

Uh oh!

claude bot commented Nov 20, 2025

Uh oh!

claude bot commented Nov 20, 2025

Uh oh!

claude bot commented Nov 20, 2025

Uh oh!

claude bot commented Nov 20, 2025

Uh oh!

graphite-app bot commented Nov 21, 2025 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

fix(rivetkit): uri encode actor ids to fix cloudflare workers actor id with generation #3504

fix(rivetkit): uri encode actor ids to fix cloudflare workers actor id with generation #3504

Uh oh!

Conversation

NathanFlurry commented Nov 20, 2025

Uh oh!

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

Uh oh!

Uh oh!

NathanFlurry commented Nov 20, 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 20, 2025

Code Review

Summary

Positive Aspects ✅

Issues & Recommendations 🔍

1. Minor: Inconsistent Variable Naming

2. Debugging Improvements in Test Code

3. Missing WS_PROTOCOL_STANDARD in Original Code

4. Test Coverage

5. Security: URL Encoding Choice

Performance Considerations ⚡

Security Considerations 🔒

Alignment with CLAUDE.md 📋

Recommended Next Steps

Verdict

Uh oh!

pkg-pr-new bot commented Nov 20, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

claude bot commented Nov 20, 2025

PR Review: URI Encoding for Actor IDs with Generation

Summary

Code Quality: ✅ Good

Potential Issues: ⚠️ Minor Concerns

Performance Considerations: ✅ Good

Security Concerns: ✅ Good

Test Coverage: ⚠️ Needs Improvement

Architecture & Design: ✅ Good

Specific Code Comments

Summary of Recommendations

Overall Assessment: ✅ Approve with Minor Changes

Uh oh!

claude bot commented Nov 20, 2025

Code Review

Summary

✅ Positive Aspects

🔍 Code Quality Issues

1. Redundant .to_string() Call

2. Missing Reference in Parse Call

3. Inconsistent Context Messages

🔒 Security Considerations

⚡ Performance Considerations

🧪 Test Coverage

📝 Minor Issues

✅ Recommended Approval

Uh oh!

claude bot commented Nov 20, 2025

Code Review

Summary

Positive Aspects ✅

Issues & Concerns 🔍

Critical: Missing Rust Client Update ⚠️

Minor: Redundant .to_string() in Rust Code

Code Quality: Error Context

Performance Considerations 🚀

Security Considerations 🔒

Test Coverage ✅

Recommendations

Verdict

Uh oh!

claude bot commented Nov 20, 2025

Pull Request Review

Summary

Code Quality ✅

Potential Issues ❌

Performance Considerations ✅

Security Concerns ⚠️

vercel bot commented Nov 20, 2025 •

edited

Loading

NathanFlurry commented Nov 20, 2025 •

edited

Loading

3. Missing `WS_PROTOCOL_STANDARD` in Original Code

pkg-pr-new bot commented Nov 20, 2025 •

edited

Loading

1. Redundant `.to_string()` Call

Minor: Redundant `.to_string()` in Rust Code

graphite-app bot commented Nov 21, 2025 •

edited

Loading