chore(scripts): add endian converter script

[NathanFlurry]

No description provided.

[vercel]

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 4:05am

3 Skipped Deployments

Project	Deployment	Preview	Comments	Updated (UTC)
rivet-cloud	Ignored			Nov 5, 2025 4:05am
rivet-inspector	Ignored	Preview		Nov 5, 2025 4:05am
rivet-site	Ignored	Preview		Nov 5, 2025 4:05am

[NathanFlurry]

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

• chore(pegboard): allow configuring reschedule_backoff_max_exponent #3370
• fix(next-js): auto shut down runners when source code updates #3369
• fix(rivetkit): fix duplicate runner key in serverless #3366
• chore(runner): improve runner connection logs #3365
• chore(rivetkit): add runner sse ping interval #3362
• chore(rivetkit): log close code when client ws closes #3361
• chore(rivetkit): log runner id with actor logs #3360
• chore(scripts): add endian converter script #3359 👈 (View in Graphite)
• fix(guard): fix url decoding actor id + token #3357
• chore(rivetkit): remove unneeded headers & protocols in requests #3356
• fix(rivetkit): reduce pegboard actor retry for spawned engines #3355
• chore(pegboard): allow configuring base_retry_timeout, actor_start_threshold, actor_stop_threshold, and retry_reset_duration #3354
• feat(pb): add reschedule_ts to actors #3363
• fix: fix all dashboards #3358
• chore: change log levels #3333
• chore: misc bug fixes, add logs for outbound req #3332
• fix: use correct vbare functions for runner tunnel #3300 : 1 other dependent PR (#3301 )
• feat(grafana): fix api dashboards #3193
• fix: docker compose build #3273
• chore: fix remaining warnings for all targets #3305
• fix(gas): fix from_workflow when creating standalone ctx from op ctx #3342
• ci: udpate ci filter to succeed if no relevant changes #3343
• main

---

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]

Code Review

Summary

This PR adds a utility script for converting numbers between big-endian and little-endian byte order. The script is well-structured and provides clear output formatting.

Positive Aspects

• Clear purpose: The script has a specific, well-defined utility function
• Good documentation: Includes descriptive comments and clear console output
• Proper shebang: Uses #!/usr/bin/env tsx for portability
• Handles large numbers: Correctly uses BigInt for 64-bit integer handling
• Good default value: Provides a sensible default input for testing

Issues & Recommendations

1. Logic Error in Conversion (Critical)

Location: scripts/misc/endian-converter.ts:36

The conversion logic appears to have an issue:

const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(num);
const littleEndianValue = leBuf.readBigUInt64BE(); // Read the LE bytes as if they were BE

This code writes a number as little-endian, then reads it back as big-endian. This doesn't actually convert the input number's byte order—it treats the input as if it's already in the desired source format.

Expected behavior: If the goal is to show what a big-endian number looks like when interpreted as little-endian (or vice versa), this should be clarified. If the goal is to convert between formats, the logic needs adjustment.

Suggested fix: Clarify the intent and align the implementation. The bigEndianToLittleEndian function at the top is defined but never used—consider using it in the main execution.

2. Unused Function

Location: scripts/misc/endian-converter.ts:6-15

The bigEndianToLittleEndian function is defined but never called in the main execution. Either:

• Remove it if not needed
• Use it in the conversion logic
• Export it for use as a module

3. Missing Error Handling

The script doesn't validate input or handle errors:

// Add input validation:
if (process.argv[2] && !/^\d+$/.test(process.argv[2])) {
  console.error('Error: Input must be a valid positive integer');
  process.exit(1);
}

try {
  const num = BigInt(inputNumber);
  // ... rest of code
} catch (error) {
  console.error('Error: Invalid number format');
  process.exit(1);
}

4. Unclear Use Case

Missing context: The PR description is empty, making it unclear:

• What problem does this solve?
• How should it be used?
• Is this for debugging a specific issue?

Consider adding:

• A PR description explaining the use case
• Usage examples in comments or a README
• Link to any related issues this helps debug

5. Memory Safety Consideration

Buffer.allocUnsafe(8) is used, which doesn't zero-initialize the buffer. While this is fine since you're immediately writing to it, Buffer.alloc(8) would be safer and more explicit about intent with negligible performance impact for a utility script.

Testing Recommendations

• Add test cases with known conversions to verify correctness
• Test edge cases: 0, maximum 64-bit value, powers of 2
• Add usage documentation showing expected input/output

Overall Assessment

The code is clean and readable, but the conversion logic needs clarification or correction. Once the logic issue is resolved and the intent is clear, this will be a useful utility script.

Recommendation: Request changes to address the logic issue and add clarifying documentation.

---

Review generated by Claude Code

[claude]

Code Review: Endian Converter Script

Thanks for adding this utility script! Overall, this is a clean and functional tool for endian conversion. Here are some observations and suggestions:

✅ Positives

• Clear Purpose: The script has a well-defined, single responsibility
• Good Documentation: The header comment clearly explains what the script does
• Executable: Proper shebang line for direct execution
• Readable Output: Nice formatted output with visual separators

🐛 Issues Found

1. Logic Inconsistency (lines 7-15 vs 33-36)

The bigEndianToLittleEndian() function is defined but never used. The main execution reimplements the same logic inline but with different semantics:

// Function interprets input as BE, converts to LE value
function bigEndianToLittleEndian(num: bigint): bigint {
    const buffer = Buffer.allocUnsafe(8);
    buffer.writeBigUInt64BE(num);      // Write as BE
    return buffer.readBigUInt64LE();   // Read as LE - gets LE interpretation
}

// Main code interprets input as value, swaps bytes
const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(num);           // Write as LE
const littleEndianValue = leBuf.readBigUInt64BE(); // Read as BE - swaps bytes

These produce different results. The main code at line 36 performs byte-order swapping by writing with one endianness and reading with another, which is the correct approach for byte swapping. Either:

• Use the function consistently, or
• Remove the unused function

2. Confusing Variable Names (line 36)

littleEndianValue actually contains the big-endian numeric interpretation of little-endian bytes. This is misleading. Consider:

// More accurate name
const swappedValue = leBuf.readBigUInt64BE();

3. Missing Error Handling

No validation for invalid inputs:

const inputNumber = process.argv[2] || '360287970189639680';
try {
    const num = BigInt(inputNumber);
    // ... rest of code
} catch (error) {
    console.error('Error: Invalid number format');
    process.exit(1);
}

💡 Suggestions

1. Add Usage Information

if (process.argv.includes('--help') || process.argv.includes('-h')) {
    console.log('Usage: endian-converter.ts [number]');
    console.log('Converts a number between big and little endian byte orders');
    process.exit(0);
}

2. Consider Bidirectionality

The script title suggests BE→LE only, but the logic actually just swaps bytes (works both ways). Consider:

• Renaming to endian-swap.ts for clarity, or
• Adding explicit direction flags if needed

3. Add Input Validation

Check for negative numbers or values that don't fit in 64 bits:

if (num < 0n || num > 0xFFFFFFFFFFFFFFFFn) {
    console.error('Error: Number must be between 0 and 2^64-1');
    process.exit(1);
}

🔒 Security

• Low Risk: Utility script with no security-critical operations
• ✅ Uses Buffer.allocUnsafe appropriately (values immediately written)

🎯 Performance

• ✅ Appropriate for a utility script
• No concerns for this use case

📝 Documentation

Consider adding:

• A comment explaining why this tool exists (what problem it solves)
• Examples of when you'd use it
• Expected input/output ranges

Test Coverage

❓ No tests included, but acceptable for a utility script in scripts/misc/. If this logic were part of production code, tests would be essential.

---

Recommendation: Approve with suggested changes - The script works but would benefit from fixing the unused function and improving error handling.

[claude]

Code Review

Thanks for adding this endian converter utility script! Here's my review:

Positive Aspects

✅ Good structure - Clean, focused utility with clear purpose
✅ Executable script - Proper shebang for direct execution
✅ Clear output - Nice formatted output showing both representations

Issues & Suggestions

1. Unused Function (scripts/misc/endian-converter.ts:7-16)

The bigEndianToLittleEndian function is defined but never called. The main code duplicates this logic inline at lines 34-36. Either remove the function or use it consistently.

2. Confusing Conversion Logic (line 36)

const littleEndianValue = leBuf.readBigUInt64BE(); // Read the LE bytes as if they were BE

This reads LE bytes as BE, producing a reinterpretation rather than a true endian conversion. The variable name littleEndianValue is misleading - it actually shows how LE bytes would be interpreted when read as BE (a completely different number). Consider clearer naming like leBytesBEInterpretation.

3. Missing Error Handling

No validation for invalid input. The BigInt() constructor can throw if the input is invalid. Add try-catch for better user experience.

4. Unclear Purpose

Consider adding:

• Usage message explaining what the script does
• --help flag with documentation
• Support for reverse conversion (LE to BE)

Priority Fixes

1. Remove unused function or use it consistently
2. Clarify what the "Converted (Little Endian)" output actually represents
3. Add basic error handling for invalid inputs

[claude]

PR Review: Endian Converter Script

Thanks for adding this utility script! Here's my review:

Code Quality & Best Practices

Positives:

• Clean, well-structured code with good comments
• Proper shebang for tsx execution
• Good use of TypeScript with explicit typing
• Helpful visual output with separators and formatting

Issues Found:

1. Logic Bug in Conversion (Critical) - scripts/misc/endian-converter.ts:35-36

   const leBuf = Buffer.allocUnsafe(8);
   leBuf.writeBigUInt64LE(num);
   const littleEndianValue = leBuf.readBigUInt64BE();

   This doesn't perform endian conversion correctly. You're writing num as little-endian, then reading it back as big-endian, which gives you a byte-swapped version of the original number. However, this doesn't match what the bigEndianToLittleEndian function does (which is defined but never used).

   The function appears to be unused - you define bigEndianToLittleEndian() at the top but never call it. Either use it or remove it.

2. Semantic Confusion
   The current logic assumes the input is already in big-endian format, but numbers in JavaScript/TypeScript don't have inherent endianness - they're just values. The script should clarify:

   • Are you converting a number's byte representation from BE to LE?
   • Or are you showing how the same bytes would be interpreted differently?

3. Missing Error Handling

   const num = BigInt(inputNumber);

   This will throw if the input isn't a valid number. Consider wrapping in try-catch with a helpful error message.

4. Unsafe Buffer Usage
   Using Buffer.allocUnsafe(8) is fine here since you immediately write to it, but it's worth noting for clarity.

Recommendations

Fix the conversion logic:

// Remove the unused function or use it like this:
const littleEndianValue = bigEndianToLittleEndian(num);

// Or simplify by removing the function and doing it inline:
const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64BE(num);  // Write as BE
const littleEndianValue = leBuf.readBigUInt64LE();  // Read as LE

Add error handling:

if (process.argv.length < 3) {
  console.error('Usage: endian-converter.ts <number>');
  process.exit(1);
}

let num: bigint;
try {
  num = BigInt(inputNumber);
} catch (e) {
  console.error(`Error: Invalid number "${inputNumber}"`);
  process.exit(1);
}

Add a description comment explaining the purpose:

/**
 * Utility script to convert 64-bit numbers between big-endian and little-endian
 * byte representations. Useful for debugging binary data interchange.
 * 
 * Usage: tsx endian-converter.ts <decimal_number>
 */

Security Concerns

• No security issues for a development utility script
• Input validation would be good practice (see error handling above)

Performance

• No concerns - this is a simple CLI utility

Test Coverage

• No tests included, but this is a simple utility script so it's acceptable
• Consider adding a comment with example usage and expected output

Summary

The script needs a logic fix to either use the defined conversion function or remove it. The current implementation has a bug where the conversion logic doesn't match the defined helper function. Otherwise, it's a clean utility script that would benefit from better error handling and usage documentation.

Severity: Medium - The logic bug should be fixed before merging.

[claude]

Code Review

Thanks for adding this endian converter utility script! Overall, the code is clean and functional. Here are some observations and suggestions:

✅ Strengths

• Clear purpose: The script does what it says - converts between big and little endian byte orders
• Good output formatting: The visual representation with hex, decimal, and byte arrays is helpful
• Executable shebang: Properly configured with #\!/usr/bin/env tsx

🔍 Issues & Suggestions

1. Logic Confusion (Bug)

Lines 34-36 have a logical issue:

const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(num);
const littleEndianValue = leBuf.readBigUInt64BE(); // Read the LE bytes as if they were BE

This code writes num as little endian bytes, then reads those same bytes back as big endian. This is correct for byte swapping, but the comment and variable naming are misleading:

• num is treated as already being in big endian format
• Writing it with writeBigUInt64LE stores it as little endian bytes
• Reading with readBigUInt64BE interprets those LE bytes as if they were BE, giving the swapped result

Issue: The function bigEndianToLittleEndian() defined at the top (lines 7-16) is never used. The main code reimplements the same logic inline.

Recommendation: Either use the function you defined, or remove it if not needed:

const littleEndianValue = bigEndianToLittleEndian(num);

2. Security: Buffer.allocUnsafe()

Lines 9, 26, and 34 use Buffer.allocUnsafe() which doesn't zero out memory. While this is fine for a utility script that immediately writes to the buffer, consider using Buffer.alloc() for safety, or at minimum add a comment explaining why unsafe allocation is acceptable here.

3. Input Validation

The script doesn't validate user input:

const inputNumber = process.argv[2] || '360287970189639680';
const num = BigInt(inputNumber);

If a user passes an invalid value, it will throw an unhandled error. Consider:

try {
  const num = BigInt(inputNumber);
} catch (err) {
  console.error('Error: Invalid number provided');
  process.exit(1);
}

4. Documentation

The top comment only describes converting from big to little endian, but the script actually shows both representations. Consider updating the comment to reflect that it's a conversion tool that displays both byte orders.

5. Minor: Default Value

The hardcoded default '360287970189639680' seems arbitrary. Consider adding a comment explaining what this number represents, or use a more obvious example like '1234567890'.

📝 Test Coverage

This is a standalone utility script, so automated tests may be overkill. However, you could:

• Add example output in a comment showing expected results
• Document usage examples in a comment or README

Summary

The script works correctly for its intended purpose, but has one definite bug (unused function) and could benefit from better input validation and clearer documentation. The byte swapping logic itself is sound.

Priority fixes:

1. ⚠️ Use or remove the unused bigEndianToLittleEndian() function
2. Add input validation
3. Clarify comments/documentation

[claude]

Code Review

I've reviewed the endian converter script. Here's my feedback:

✅ Positive Aspects

• Clear purpose: The script is well-documented with a clear purpose
• Executable shebang: Properly configured with #!/usr/bin/env tsx
• Readable output: Good formatting with visual separators for clarity

🐛 Issues Found

1. Logic Bug - Function Not Used (Line 7-16)

The bigEndianToLittleEndian function is defined but never called. Instead, the main code reimplements the logic differently in lines 33-36, which may produce unexpected results.

Current behavior: Lines 35-36 write a number as little endian, then read those bytes back as big endian - this is the reverse of what the function does and what the title suggests.

Recommendation: Either use the defined function or remove it:

// Option 1: Use the function
const littleEndianValue = bigEndianToLittleEndian(num);

// Option 2: Remove the unused function and clarify intent

2. Confusing Conversion Logic

The conversion logic is unclear:

• Lines 26-31: Create a big endian buffer from input
• Lines 34-36: Create a little endian buffer from the same input, then read as big endian

This doesn't actually convert between endianness - it treats the same number as two different byte orders. Is this intentional? If so, the documentation and variable names should clarify this.

Expected behavior for endian conversion:

// Input: 0x0500000000000000 (big endian)
// Output: 0x0000000000000005 (little endian - bytes reversed)

Current behavior:

// Input: 360287970189639680
// Shows the same number in both BE and LE byte representations

3. Security: Buffer.allocUnsafe Usage

Using Buffer.allocUnsafe() can expose sensitive data from memory. For a utility script, Buffer.alloc() is safer and the performance difference is negligible.

Fix:

const buffer = Buffer.alloc(8); // Instead of allocUnsafe

📋 Suggestions

1. Add error handling for invalid inputs:

try {
  const num = BigInt(inputNumber);
} catch (e) {
  console.error('Error: Invalid number format');
  process.exit(1);
}

2. Add usage documentation at the top of the file:

/**
 * Converts a number from big endian to little endian byte order
 * 
 * Usage:
 *   ./endian-converter.ts <number>
 *   
 * Example:
 *   ./endian-converter.ts 360287970189639680
 */

3. Consider adding tests if this is critical infrastructure

🎯 Priority

• High: Fix the logic bug - clarify conversion intent
• Medium: Replace Buffer.allocUnsafe with Buffer.alloc
• Low: Add error handling and usage docs

Summary

The script has a significant logic discrepancy between the defined function and the actual implementation. Please clarify the intended behavior and ensure the code matches the documentation.

[claude]

Code Review

Overview

This PR adds a utility script for converting numbers between big-endian and little-endian byte order. The implementation is straightforward and functional.

Issues Found

1. Bug: Incorrect Conversion Logic ❗ CRITICAL

Location: scripts/misc/endian-converter.ts:33-36

The conversion logic is incorrect. The current implementation:

const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(num);
const littleEndianValue = leBuf.readBigUInt64BE(); // Read the LE bytes as if they were BE

This writes the input as LE, then reads it back as BE. This is different from the bigEndianToLittleEndian function above it. The unused function appears to have the correct logic.

Issue: If the input is already a big-endian number, writing it with writeBigUInt64LE treats it as a native number and stores it in LE format, then reading with readBigUInt64BE produces unexpected results.

Recommendation: Use the bigEndianToLittleEndian function that is already defined, or clarify what the intended input/output format is. The function is defined but never used.

2. Code Quality: Unused Function

Location: scripts/misc/endian-converter.ts:6-15

The bigEndianToLittleEndian function is defined but never called. Either:

• Use it in the main execution, or
• Remove it if not needed

3. Code Style: Inconsistent with Codebase

The script uses #!/usr/bin/env tsx but other scripts in the codebase use Deno (e.g., update_workspace.ts uses #!/usr/bin/env -S deno run ...).

Recommendation: Consider using Deno for consistency, or document why tsx is preferred for this script.

4. Documentation: Missing Purpose

Location: scripts/misc/endian-converter.ts:1-4

The comment says "Converts a number from big endian to little endian" but does not explain:

• Why this utility is needed
• What use case it solves
• How to use it (CLI args not documented)

Recommendation: Add JSDoc-style documentation explaining the script purpose and usage.

5. User Experience: No Error Handling

Location: scripts/misc/endian-converter.ts:19

If invalid input is provided (non-numeric), the script will crash with an unhelpful error.

Recommendation: Add input validation with a helpful error message.

Positive Aspects ✅

• Clean, readable output formatting
• Good use of BigInt for 64-bit numbers
• Executable permissions set correctly

Security Considerations

• No security concerns for a development utility script

Testing

• No tests provided, but acceptable for a simple utility script
• Manual testing recommended to verify the conversion logic after fixing the bug

Summary

The main issue is the incorrect conversion logic that makes the script produce unexpected results. Fix the conversion function, remove unused code, and improve documentation.

[claude]

Code Review - PR #3359

Overview

This PR adds a utility script for converting numbers between big endian and little endian byte order. Overall, the script is functional and well-structured for a utility script.

Issues & Suggestions

🐛 Logic Issue - Incorrect Conversion

Severity: High

Lines 34-36 have a logic error. The current implementation:

const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(num);
const littleEndianValue = leBuf.readBigUInt64BE(); // Read the LE bytes as if they were BE

This writes num as little endian, then reads it back as big endian. This doesn't demonstrate the conversion - it just re-interprets the same input number in a different byte order.

The script already defines a bigEndianToLittleEndian() function (lines 7-16) that isn't being used. Consider:

const littleEndianValue = bigEndianToLittleEndian(num);
const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(littleEndianValue);

Or if the goal is to show byte reinterpretation, clarify this in comments.

⚠️ Input Validation Missing

Severity: Medium

Line 20: No validation on the input argument. Consider:

• Catching invalid BigInt inputs (non-numeric strings)
• Handling negative numbers (currently using UInt64 functions)
• Range validation for 64-bit values

Example:

try {
    const num = BigInt(inputNumber);
    if (num < 0n) {
        throw new Error('Negative numbers not supported');
    }
    if (num > 0xFFFFFFFFFFFFFFFFn) {
        throw new Error('Number exceeds 64-bit unsigned range');
    }
} catch (e) {
    console.error(`Invalid input: ${e.message}`);
    process.exit(1);
}

📝 Documentation

Severity: Low

• Add usage instructions: // Usage: ./endian-converter.ts [number]
• Clarify the script's purpose in the header comment - is this for debugging, data conversion, or educational purposes?
• Add examples in comments

🔍 Code Quality

Severity: Low

1. The bigEndianToLittleEndian() function is defined but never called (lines 7-16)
2. Consider using Buffer.alloc() instead of Buffer.allocUnsafe() for better security, even though the buffers are immediately written to

✅ Positive Notes

• Clean, readable code
• Good visual formatting of output
• Proper shebang for tsx execution
• Shows both decimal, hex, and byte representations which is helpful for debugging

Recommendation

Request Changes - The logic issue should be addressed before merging to avoid confusion about what the script actually does.

[claude]

Code Review: Endian Converter Script

Summary

This PR adds a utility script for converting numbers between big endian and little endian byte order. The script is well-structured and functional, but there are a few areas for improvement.

---

✅ Strengths

1. Clear Purpose: The script has a focused, well-defined purpose with good documentation
2. Good Formatting: Clean, readable code with proper spacing and comments
3. Executable Shebang: Correctly uses #!/usr/bin/env tsx for direct execution
4. Visual Output: Nice formatting with separators and clear labeling

---

🔍 Issues & Recommendations

1. Logic Error in Conversion ⚠️

The main conversion logic appears to be incorrect:

const leBuf = Buffer.allocUnsafe(8);
leBuf.writeBigUInt64LE(num);
const littleEndianValue = leBuf.readBigUInt64BE(); // This reads LE bytes as BE

Issue: You're writing a number in little endian format, then reading it back as big endian. This doesn't perform endian conversion - it just reinterprets the bytes.

What it should do: If you have a big endian number representation, convert it to little endian (or vice versa).

Suggested fix: The bigEndianToLittleEndian function at the top is closer to correct, but even that has issues. Consider:

function swapEndianness(num: bigint): bigint {
    const buffer = Buffer.allocUnsafe(8);
    buffer.writeBigUInt64BE(num);
    return buffer.readBigUInt64LE();
}

Then use this function consistently, or clarify what conversion you're trying to perform.

2. Unused Function

The bigEndianToLittleEndian function is defined but never called in the main execution. Either use it or remove it.

3. Input Validation

No validation for the input argument:

• What if the user provides invalid input?
• What if the number is negative or out of range?

Suggestion:

const inputNumber = process.argv[2];
if (!inputNumber) {
    console.error('Usage: endian-converter.ts <number>');
    process.exit(1);
}

let num: bigint;
try {
    num = BigInt(inputNumber);
    if (num < 0n) {
        throw new Error('Number must be non-negative');
    }
} catch (error) {
    console.error(`Invalid input: ${error.message}`);
    process.exit(1);
}

4. Misleading Comments

The comment "Read the LE bytes as if they were BE" suggests this is intentional, but it's confusing. If this is the intended behavior, please add more explanation about why and what use case this serves.

5. Type Safety

Using Buffer.allocUnsafe is fine for this use case, but be aware it doesn't zero-initialize memory. For a utility script like this, Buffer.alloc might be safer (though marginally slower).

---

🧪 Testing Considerations

No tests included. For a utility script, consider adding a simple test or at least document expected behavior:

// Example test cases (could be in comments or separate test file):
// bigEndianToLittleEndian(0x0102030405060708n) === 0x0807060504030201n

---

📝 Documentation

Consider adding:

1. Usage examples in comments or a README
2. What problem this solves (when would someone use this?)
3. Example invocations:

   # Convert a specific number
   ./scripts/misc/endian-converter.ts 360287970189639680
   

---

🎯 Overall Assessment

Verdict: ⚠️ Needs Revision

The script is well-formatted and has good structure, but the core conversion logic appears incorrect or at least confusing. Please clarify the intended behavior and ensure the conversion logic matches that intent.

If this is working as intended for your specific use case, please add comments explaining why you're reading LE bytes as BE - what's the real-world scenario this addresses?

---

Action Items

• Fix or clarify the endian conversion logic
• Add input validation and error handling
• Use or remove the unused bigEndianToLittleEndian function
• Add usage documentation
• Consider adding test cases or example outputs

[claude]

Code Review

Thanks for adding this utility script! Here's my review:

Issues Found

🐛 Critical: Logic Error in Conversion

The main conversion logic has a bug. On lines 34-35:

leBuf.writeBigUInt64LE(num);
const littleEndianValue = leBuf.readBigUInt64BE(); // Read the LE bytes as if they were BE

This doesn't perform endian conversion correctly. You're:

1. Writing the number as little-endian bytes
2. Reading those same bytes back as big-endian

This reinterprets the byte order rather than converting it. The function bigEndianToLittleEndian() at the top (lines 6-15) appears to have the correct approach but is never called.

Expected behavior: Convert a big-endian number to its little-endian representation
Current behavior: Shows what value you'd get if you misinterpreted LE bytes as BE

💡 Suggested Fix

Either:

Option 1: Use the existing bigEndianToLittleEndian() function:

const littleEndianValue = bigEndianToLittleEndian(num);
console.log('\nConverted (Little Endian):');
console.log(`  Decimal: ${littleEndianValue}`);
// ... rest of output

Option 2: If the current behavior is intentional (showing byte reinterpretation), rename the function and add documentation explaining this is a byte-order reinterpretation tool, not a mathematical conversion.

---

Minor Issues

📝 Naming and Documentation

• The script title says "Converts a number from big endian to little endian" but the actual behavior differs from standard endian conversion
• Consider clarifying: is this for demonstrating byte order interpretation or for actual value conversion?

⚠️ Input Validation

The script lacks input validation:

const inputNumber = process.argv[2] || '360287970189639680';
const num = BigInt(inputNumber);

Consider adding:

• Try-catch for invalid BigInt strings
• Range validation for 64-bit unsigned values
• Usage message if no argument provided

Example:

try {
    const num = BigInt(inputNumber);
    if (num < 0n || num > 0xFFFFFFFFFFFFFFFFn) {
        throw new Error('Number out of 64-bit unsigned range');
    }
    // ... continue
} catch (e) {
    console.error('Error:', e.message);
    console.log('Usage: ./endian-converter.ts <number>');
    process.exit(1);
}

---

Positive Notes ✅

• Clean, readable output formatting
• Good use of TypeScript and Buffer APIs
• Executable shebang properly configured
• Helpful visual representation with hex and byte displays

---

Recommendations

1. Fix the conversion logic or clarify the intended behavior
2. Add input validation and error handling
3. Consider adding a --help flag for usage documentation
4. If this is for debugging/testing, add a comment explaining the use case

Let me know if you'd like me to clarify any of these points!

[graphite-app]

Merge activity

• Nov 5, 5:07 AM UTC: NathanFlurry added this pull request to the Graphite merge queue.
• Nov 5, 5:08 AM UTC: CI is running for this pull request on a draft pull request (#3371) due to your merge queue CI optimization settings.
• Nov 5, 5:11 AM UTC: Merged by the Graphite merge queue via draft PR: #3371.