Complete Zig 0.15.1 API compatibility fixes - project builds successfully

Copilot · 0xrinegade · Copilot · commit 228f6b545be2 · 2025-09-21T16:06:24.000Z
Co-authored-by: 0xrinegade &lt;101195284+0xrinegade@users.noreply.github.com&gt;
diff --git a/src/blockchain/client.zig b/src/blockchain/client.zig
@@ -260,7 +260,7 @@ pub const BlockchainClient = struct {
         
         // Convert to hex string
         var order_id_buffer: [BlockchainConstants.ORDER_ID_HEX_LENGTH]u8 = undefined;
-        const order_id = std.fmt.bufPrint(&order_id_buffer, "{}", .{std.fmt.fmtSliceHexLower(&order_id_bytes)}) catch return error.OrderIdGenerationFailed;
+        const order_id = std.fmt.bufPrint(&order_id_buffer, "{s}", .{std.fmt.bytesToHex(&order_id_bytes, .lower)}) catch return error.OrderIdGenerationFailed;
         
         return try self.allocator.dupe(u8, order_id);
     }
@@ -346,14 +346,14 @@ pub const Orderbook = struct {
     pub fn deinit(self: *Orderbook, allocator: std.mem.Allocator) void {
         // Clear and free order data securely
         for (self.bids) |bid| {
-            std.crypto.utils.secureZero(u8, @constCast(bid.order_id));
-            std.crypto.utils.secureZero(u8, @constCast(bid.owner_address));
+            @memset(@constCast(bid.order_id), 0);
+            @memset(@constCast(bid.owner_address), 0);
             allocator.free(bid.order_id);
             allocator.free(bid.owner_address);
         }
         for (self.asks) |ask| {
-            std.crypto.utils.secureZero(u8, @constCast(ask.order_id));
-            std.crypto.utils.secureZero(u8, @constCast(ask.owner_address));
+            @memset(@constCast(ask.order_id), 0);
+            @memset(@constCast(ask.owner_address), 0);
             allocator.free(ask.order_id);
             allocator.free(ask.owner_address);
         }
@@ -363,8 +363,8 @@ pub const Orderbook = struct {
         allocator.free(self.asks);
         
         // Clear and free market data
-        std.crypto.utils.secureZero(u8, @constCast(self.market));
-        std.crypto.utils.secureZero(u8, @constCast(self.market_address));
+        @memset(@constCast(self.market), 0);
+        @memset(@constCast(self.market_address), 0);
         allocator.free(self.market);
         allocator.free(self.market_address);
     }
diff --git a/src/blockchain/error.zig b/src/blockchain/error.zig
@@ -101,7 +101,7 @@ pub const ErrorHandler = struct {
             // If this isn't the first attempt, apply exponential backoff
             if (retry_count > 0) {
                 const delay_ms = self.base_delay_ms * (@as(u32, 1) << @intCast(retry_count - 1));
-                std.time.sleep(delay_ms * std.time.ns_per_ms);
+                std.Thread.sleep(delay_ms * std.time.ns_per_ms);
 
                 // Log retry attempt
                 std.debug.print("Retrying operation (attempt {d}/{d})...\n", .{ retry_count, self.max_retries });
@@ -130,7 +130,7 @@ pub const ErrorHandler = struct {
                     // Rate limiting requires retry with backoff
                     BlockchainError.RateLimitExceeded => {
                         // Add extra delay for rate limit errors
-                        std.time.sleep(BlockchainConstants.RATE_LIMIT_EXTRA_DELAY_MS * std.time.ns_per_ms);
+                        std.Thread.sleep(BlockchainConstants.RATE_LIMIT_EXTRA_DELAY_MS * std.time.ns_per_ms);
                         if (retry_count < self.max_retries) {
                             continue;
                         } else {
diff --git a/src/blockchain/signer.zig b/src/blockchain/signer.zig
@@ -57,7 +57,7 @@ pub const TransactionSigner = struct {
                 size,
                 timestamp,
                 nonce,
-                std.fmt.fmtSliceHexLower(&self.keypair.public_key.bytes),
+                std.fmt.bytesToHex(&self.keypair.public_key.bytes, .lower),
             }
         );
 
@@ -97,7 +97,7 @@ pub const TransactionSigner = struct {
                 order_id,
                 timestamp,
                 nonce,
-                std.fmt.fmtSliceHexLower(&self.keypair.public_key.bytes),
+                std.fmt.bytesToHex(&self.keypair.public_key.bytes, .lower),
             }
         );
 
diff --git a/src/cli.zig b/src/cli.zig
@@ -94,12 +94,12 @@ pub fn execute(registry: *CommandRegistry, args: []const []const u8) !void {
     }
 
     // Stage 3: Sanitize command arguments
-    var sanitized_args = std.ArrayList([]const u8).init(std.heap.page_allocator);
+    var sanitized_args = std.ArrayList([]const u8){};
     defer {
         for (sanitized_args.items) |arg| {
             std.heap.page_allocator.free(arg);
         }
-        sanitized_args.deinit();
+        sanitized_args.deinit(std.heap.page_allocator);
     }
 
     for (command_args) |arg| {
@@ -128,7 +128,7 @@ pub fn execute(registry: *CommandRegistry, args: []const []const u8) !void {
             continue;
         }
 
-        try sanitized_args.append(try std.heap.page_allocator.dupe(u8, arg_result.cleaned_input));
+        try sanitized_args.append(std.heap.page_allocator, try std.heap.page_allocator.dupe(u8, arg_result.cleaned_input));
     }
 
     // Validate command name is not empty after sanitization
diff --git a/src/cli/input_sanitizer.zig b/src/cli/input_sanitizer.zig
@@ -90,11 +90,11 @@ pub const InputSanitizer = struct {
                     continue;
                 };
                 
-                try normalized.appendSlice(utf8_bytes[0..written]);
+                try normalized.appendSlice(self.allocator, utf8_bytes[0..written]);
                 i += utf8_len;
             }
 
-            return normalized.toOwnedSlice();
+            return normalized.toOwnedSlice(self.allocator);
         }
 
         /// Apply normalization rules to individual codepoints
@@ -475,7 +475,7 @@ pub const InputSanitizer = struct {
         if (input.len == 0) return .BLOCKED;
 
         // Check for valid command format: command [subcommand] [args...]
-        var parts = std.mem.split(u8, input, " ");
+        var parts = std.mem.splitSequence(u8, input, " ");
         const command = parts.next() orelse return .BLOCKED;
 
         // Validate command name (alphanumeric and hyphens only)
@@ -520,13 +520,13 @@ pub const InputSanitizer = struct {
 
         for (input) |char| {
             switch (char) {
-                '"' => try escaped.appendSlice("\\\""),
-                '\\' => try escaped.appendSlice("\\\\"),
-                '\n' => try escaped.appendSlice("\\n"),
-                '\r' => try escaped.appendSlice("\\r"),
-                '\t' => try escaped.appendSlice("\\t"),
+                '"' => try escaped.appendSlice(self.allocator, "\\\""),
+                '\\' => try escaped.appendSlice(self.allocator, "\\\\"),
+                '\n' => try escaped.appendSlice(self.allocator, "\\n"),
+                '\r' => try escaped.appendSlice(self.allocator, "\\r"),
+                '\t' => try escaped.appendSlice(self.allocator, "\\t"),
                 0...8, 11...12, 14...31, 127...255 => {
-                    try escaped.writer().print("\\x{X:0>2}", .{char});
+                    try escaped.writer(self.allocator).print("\\x{X:0>2}", .{char});
                 },
                 else => try escaped.append(self.allocator, char),
             }
@@ -559,7 +559,7 @@ pub const InputSanitizer = struct {
 
         // Phase 3: Pattern combination analysis
         if (suspicion_score >= 3.0) {
-            try result.blocked_patterns.append(try self.allocator.dupe(u8, "Multiple suspicious patterns detected"));
+            try result.blocked_patterns.append(self.allocator, try self.allocator.dupe(u8, "Multiple suspicious patterns detected"));
             return .BLOCKED;
         }
 
@@ -592,10 +592,10 @@ pub const InputSanitizer = struct {
         }
 
         if (url_encoded_count > input.len / 4) {
-            try result.blocked_patterns.append(try std.fmt.allocPrint(self.allocator, "Excessive URL encoding: {d} encoded chars", .{url_encoded_count}));
+            try result.blocked_patterns.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Excessive URL encoding: {d} encoded chars", .{url_encoded_count}));
             return .BLOCKED;
         } else if (url_encoded_count > 5) {
-            try result.warnings.append(try std.fmt.allocPrint(self.allocator, "URL encoding detected: {d} chars", .{url_encoded_count}));
+            try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "URL encoding detected: {d} chars", .{url_encoded_count}));
             encoding_level = .SUSPICIOUS;
         }
 
@@ -613,7 +613,7 @@ pub const InputSanitizer = struct {
             }
 
             if (hex_count > 3) {
-                try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Multiple hex patterns: {d}", .{hex_count}));
+                try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Multiple hex patterns: {d}", .{hex_count}));
                 encoding_level = .SUSPICIOUS;
             }
         }
@@ -627,7 +627,7 @@ pub const InputSanitizer = struct {
 
         // Analyze command-like structures
         if (input.len > 0 and (input[0] == '/' or input[0] == '\\' or input[0] == '.')) {
-            try result.warnings.append(try self.allocator.dupe(u8, "Path-like input detected"));
+            try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "Path-like input detected"));
             context_level = .SUSPICIOUS;
         }
 
@@ -646,7 +646,7 @@ pub const InputSanitizer = struct {
         }
 
         if (bracket_count > 4 and paren_count > 2) {
-            try result.warnings.append(try self.allocator.dupe(u8, "Script-like structure detected"));
+            try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "Script-like structure detected"));
             context_level = .SUSPICIOUS;
         }
 
@@ -661,7 +661,7 @@ pub const InputSanitizer = struct {
         }
 
         if (sql_keyword_count >= 2) {
-            try result.blocked_patterns.append(try self.allocator.dupe(u8, "SQL-like command structure detected"));
+            try result.blocked_patterns.append(self.allocator, try self.allocator.dupe(u8, "SQL-like command structure detected"));
             return .BLOCKED;
         }
 
@@ -683,18 +683,18 @@ pub const InputSanitizer = struct {
         // Check for excessive repetition of any character
         for (char_freq, 0..) |freq, char| {
             if (freq > input.len / 2 and freq > 10) {
-                try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Excessive character repetition: '{c}' appears {d} times", .{ @as(u8, @intCast(char)), freq }));
+                try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Excessive character repetition: '{c}' appears {d} times", .{ @as(u8, @intCast(char)), freq }));
                 stats_level = .SUSPICIOUS;
             }
         }
 
         // Entropy analysis (simplified)
         const entropy = self.calculateEntropy(input);
         if (entropy < 1.0) {
-            try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Low entropy input: {d:.2}", .{entropy}));
+            try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Low entropy input: {d:.2}", .{entropy}));
             stats_level = .SUSPICIOUS;
         } else if (entropy > 7.0) {
-            try result.warnings.append(try std.fmt.allocPrint(self.allocator, "High entropy input (possible encoded): {d:.2}", .{entropy}));
+            try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "High entropy input (possible encoded): {d:.2}", .{entropy}));
             stats_level = .SUSPICIOUS;
         }
 
@@ -710,12 +710,12 @@ pub const InputSanitizer = struct {
             }
 
             if (space_count < input.len / 20) { // Very few spaces in long input
-                try result.warnings.append(try self.allocator.dupe(u8, "Long input with minimal spacing (possible obfuscation)"));
+                try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "Long input with minimal spacing (possible obfuscation)"));
                 stats_level = .SUSPICIOUS;
             }
 
             if (special_char_count > input.len / 3) { // Too many special characters
-                try result.warnings.append(try self.allocator.dupe(u8, "High special character density"));
+                try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "High special character density"));
                 stats_level = .SUSPICIOUS;
             }
         }
@@ -738,7 +738,7 @@ pub const InputSanitizer = struct {
 
         for (script_variations) |variation| {
             if (std.mem.indexOf(u8, input, variation)) |_| {
-                try result.blocked_patterns.append(try std.fmt.allocPrint(self.allocator, "Obfuscated script pattern: {s}", .{variation}));
+                try result.blocked_patterns.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Obfuscated script pattern: {s}", .{variation}));
                 return .BLOCKED;
             }
         }
@@ -753,7 +753,7 @@ pub const InputSanitizer = struct {
 
         for (cmd_patterns) |pattern| {
             if (std.mem.indexOf(u8, input, pattern)) |_| {
-                try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Spaced command pattern: {s}", .{pattern}));
+                try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Spaced command pattern: {s}", .{pattern}));
                 fuzzy_level = .DANGEROUS;
             }
         }
diff --git a/src/cli/tui.zig b/src/cli/tui.zig
@@ -63,8 +63,11 @@ pub fn run() !void {
     std.debug.print("\nPress any key to exit...\n", .{});
 
     // Wait for input (simplified for this example)
-    const stdin = std.io.getStdIn().reader();
-    _ = try stdin.readByte();
+    const stdin_file = std.fs.File{ .handle = std.posix.STDIN_FILENO };
+    var buffer: [1]u8 = undefined;
+    var stdin = stdin_file.reader(&buffer);
+    var read_buf: [1]u8 = undefined;
+    _ = try stdin.read(&read_buf);
 
     std.debug.print("Exiting TUI...\n", .{});
 }
diff --git a/src/services/enhanced_orders.zig b/src/services/enhanced_orders.zig
@@ -241,7 +241,7 @@ pub const EnhancedOrderService = struct {
         };
         defer {
             // Secure cleanup of signature
-            std.crypto.utils.secureZero(u8, @constCast(signature));
+            @memset(@constCast(signature), 0);
             self.allocator.free(signature);
         }
         
@@ -353,7 +353,7 @@ pub const EnhancedOrderService = struct {
         };
         defer {
             // Secure cleanup of signature
-            std.crypto.utils.secureZero(u8, @constCast(signature));
+            @memset(@constCast(signature), 0);
             self.allocator.free(signature);
         }
         

Original file line number	Diff line number	Diff line change
`@@ -94,12 +94,12 @@ pub fn execute(registry: *CommandRegistry, args: []const []const u8) !void {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// Stage 3: Sanitize command arguments`
`97`		`- var sanitized_args = std.ArrayList([]const u8).init(std.heap.page_allocator);`
	`97`	`+ var sanitized_args = std.ArrayList([]const u8){};`
`98`	`98`	`defer {`
`99`	`99`	`for (sanitized_args.items) \|arg\| {`
`100`	`100`	`std.heap.page_allocator.free(arg);`
`101`	`101`	`}`
`102`		`- sanitized_args.deinit();`
	`102`	`+ sanitized_args.deinit(std.heap.page_allocator);`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`for (command_args) \|arg\| {`
`@@ -128,7 +128,7 @@ pub fn execute(registry: *CommandRegistry, args: []const []const u8) !void {`
`128`	`128`	`continue;`
`129`	`129`	`}`
`130`	`130`
`131`		`- try sanitized_args.append(try std.heap.page_allocator.dupe(u8, arg_result.cleaned_input));`
	`131`	`+ try sanitized_args.append(std.heap.page_allocator, try std.heap.page_allocator.dupe(u8, arg_result.cleaned_input));`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`// Validate command name is not empty after sanitization`
Original file line number	Diff line number	Diff line change
`@@ -90,11 +90,11 @@ pub const InputSanitizer = struct {`
`90`	`90`	`continue;`
`91`	`91`	`};`
`92`	`92`
`93`		`- try normalized.appendSlice(utf8_bytes[0..written]);`
	`93`	`+ try normalized.appendSlice(self.allocator, utf8_bytes[0..written]);`
`94`	`94`	`i += utf8_len;`
`95`	`95`	`}`
`96`	`96`
`97`		`- return normalized.toOwnedSlice();`
	`97`	`+ return normalized.toOwnedSlice(self.allocator);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`/// Apply normalization rules to individual codepoints`
`@@ -475,7 +475,7 @@ pub const InputSanitizer = struct {`
`475`	`475`	`if (input.len == 0) return .BLOCKED;`
`476`	`476`
`477`	`477`	`// Check for valid command format: command [subcommand] [args...]`
`478`		`- var parts = std.mem.split(u8, input, " ");`
	`478`	`+ var parts = std.mem.splitSequence(u8, input, " ");`
`479`	`479`	`const command = parts.next() orelse return .BLOCKED;`
`480`	`480`
`481`	`481`	`// Validate command name (alphanumeric and hyphens only)`
`@@ -520,13 +520,13 @@ pub const InputSanitizer = struct {`
`520`	`520`
`521`	`521`	`for (input) \|char\| {`
`522`	`522`	`switch (char) {`
`523`		`- '"' => try escaped.appendSlice("\\\""),`
`524`		`- '\\' => try escaped.appendSlice("\\\\"),`
`525`		`- '\n' => try escaped.appendSlice("\\n"),`
`526`		`- '\r' => try escaped.appendSlice("\\r"),`
`527`		`- '\t' => try escaped.appendSlice("\\t"),`
	`523`	`+ '"' => try escaped.appendSlice(self.allocator, "\\\""),`
	`524`	`+ '\\' => try escaped.appendSlice(self.allocator, "\\\\"),`
	`525`	`+ '\n' => try escaped.appendSlice(self.allocator, "\\n"),`
	`526`	`+ '\r' => try escaped.appendSlice(self.allocator, "\\r"),`
	`527`	`+ '\t' => try escaped.appendSlice(self.allocator, "\\t"),`
`528`	`528`	`0...8, 11...12, 14...31, 127...255 => {`
`529`		`- try escaped.writer().print("\\x{X:0>2}", .{char});`
	`529`	`+ try escaped.writer(self.allocator).print("\\x{X:0>2}", .{char});`
`530`	`530`	`},`
`531`	`531`	`else => try escaped.append(self.allocator, char),`
`532`	`532`	`}`
`@@ -559,7 +559,7 @@ pub const InputSanitizer = struct {`
`559`	`559`
`560`	`560`	`// Phase 3: Pattern combination analysis`
`561`	`561`	`if (suspicion_score >= 3.0) {`
`562`		`- try result.blocked_patterns.append(try self.allocator.dupe(u8, "Multiple suspicious patterns detected"));`
	`562`	`+ try result.blocked_patterns.append(self.allocator, try self.allocator.dupe(u8, "Multiple suspicious patterns detected"));`
`563`	`563`	`return .BLOCKED;`
`564`	`564`	`}`
`565`	`565`
`@@ -592,10 +592,10 @@ pub const InputSanitizer = struct {`
`592`	`592`	`}`
`593`	`593`
`594`	`594`	`if (url_encoded_count > input.len / 4) {`
`595`		`- try result.blocked_patterns.append(try std.fmt.allocPrint(self.allocator, "Excessive URL encoding: {d} encoded chars", .{url_encoded_count}));`
	`595`	`+ try result.blocked_patterns.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Excessive URL encoding: {d} encoded chars", .{url_encoded_count}));`
`596`	`596`	`return .BLOCKED;`
`597`	`597`	`} else if (url_encoded_count > 5) {`
`598`		`- try result.warnings.append(try std.fmt.allocPrint(self.allocator, "URL encoding detected: {d} chars", .{url_encoded_count}));`
	`598`	`+ try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "URL encoding detected: {d} chars", .{url_encoded_count}));`
`599`	`599`	`encoding_level = .SUSPICIOUS;`
`600`	`600`	`}`
`601`	`601`
`@@ -613,7 +613,7 @@ pub const InputSanitizer = struct {`
`613`	`613`	`}`
`614`	`614`
`615`	`615`	`if (hex_count > 3) {`
`616`		`- try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Multiple hex patterns: {d}", .{hex_count}));`
	`616`	`+ try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Multiple hex patterns: {d}", .{hex_count}));`
`617`	`617`	`encoding_level = .SUSPICIOUS;`
`618`	`618`	`}`
`619`	`619`	`}`
`@@ -627,7 +627,7 @@ pub const InputSanitizer = struct {`
`627`	`627`
`628`	`628`	`// Analyze command-like structures`
`629`	`629`	`if (input.len > 0 and (input[0] == '/' or input[0] == '\\' or input[0] == '.')) {`
`630`		`- try result.warnings.append(try self.allocator.dupe(u8, "Path-like input detected"));`
	`630`	`+ try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "Path-like input detected"));`
`631`	`631`	`context_level = .SUSPICIOUS;`
`632`	`632`	`}`
`633`	`633`
`@@ -646,7 +646,7 @@ pub const InputSanitizer = struct {`
`646`	`646`	`}`
`647`	`647`
`648`	`648`	`if (bracket_count > 4 and paren_count > 2) {`
`649`		`- try result.warnings.append(try self.allocator.dupe(u8, "Script-like structure detected"));`
	`649`	`+ try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "Script-like structure detected"));`
`650`	`650`	`context_level = .SUSPICIOUS;`
`651`	`651`	`}`
`652`	`652`
`@@ -661,7 +661,7 @@ pub const InputSanitizer = struct {`
`661`	`661`	`}`
`662`	`662`
`663`	`663`	`if (sql_keyword_count >= 2) {`
`664`		`- try result.blocked_patterns.append(try self.allocator.dupe(u8, "SQL-like command structure detected"));`
	`664`	`+ try result.blocked_patterns.append(self.allocator, try self.allocator.dupe(u8, "SQL-like command structure detected"));`
`665`	`665`	`return .BLOCKED;`
`666`	`666`	`}`
`667`	`667`
`@@ -683,18 +683,18 @@ pub const InputSanitizer = struct {`
`683`	`683`	`// Check for excessive repetition of any character`
`684`	`684`	`for (char_freq, 0..) \|freq, char\| {`
`685`	`685`	`if (freq > input.len / 2 and freq > 10) {`
`686`		`- try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Excessive character repetition: '{c}' appears {d} times", .{ @as(u8, @intCast(char)), freq }));`
	`686`	`+ try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Excessive character repetition: '{c}' appears {d} times", .{ @as(u8, @intCast(char)), freq }));`
`687`	`687`	`stats_level = .SUSPICIOUS;`
`688`	`688`	`}`
`689`	`689`	`}`
`690`	`690`
`691`	`691`	`// Entropy analysis (simplified)`
`692`	`692`	`const entropy = self.calculateEntropy(input);`
`693`	`693`	`if (entropy < 1.0) {`
`694`		`- try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Low entropy input: {d:.2}", .{entropy}));`
	`694`	`+ try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Low entropy input: {d:.2}", .{entropy}));`
`695`	`695`	`stats_level = .SUSPICIOUS;`
`696`	`696`	`} else if (entropy > 7.0) {`
`697`		`- try result.warnings.append(try std.fmt.allocPrint(self.allocator, "High entropy input (possible encoded): {d:.2}", .{entropy}));`
	`697`	`+ try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "High entropy input (possible encoded): {d:.2}", .{entropy}));`
`698`	`698`	`stats_level = .SUSPICIOUS;`
`699`	`699`	`}`
`700`	`700`
`@@ -710,12 +710,12 @@ pub const InputSanitizer = struct {`
`710`	`710`	`}`
`711`	`711`
`712`	`712`	`if (space_count < input.len / 20) { // Very few spaces in long input`
`713`		`- try result.warnings.append(try self.allocator.dupe(u8, "Long input with minimal spacing (possible obfuscation)"));`
	`713`	`+ try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "Long input with minimal spacing (possible obfuscation)"));`
`714`	`714`	`stats_level = .SUSPICIOUS;`
`715`	`715`	`}`
`716`	`716`
`717`	`717`	`if (special_char_count > input.len / 3) { // Too many special characters`
`718`		`- try result.warnings.append(try self.allocator.dupe(u8, "High special character density"));`
	`718`	`+ try result.warnings.append(self.allocator, try self.allocator.dupe(u8, "High special character density"));`
`719`	`719`	`stats_level = .SUSPICIOUS;`
`720`	`720`	`}`
`721`	`721`	`}`
`@@ -738,7 +738,7 @@ pub const InputSanitizer = struct {`
`738`	`738`
`739`	`739`	`for (script_variations) \|variation\| {`
`740`	`740`	`if (std.mem.indexOf(u8, input, variation)) \|_\| {`
`741`		`- try result.blocked_patterns.append(try std.fmt.allocPrint(self.allocator, "Obfuscated script pattern: {s}", .{variation}));`
	`741`	`+ try result.blocked_patterns.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Obfuscated script pattern: {s}", .{variation}));`
`742`	`742`	`return .BLOCKED;`
`743`	`743`	`}`
`744`	`744`	`}`
`@@ -753,7 +753,7 @@ pub const InputSanitizer = struct {`
`753`	`753`
`754`	`754`	`for (cmd_patterns) \|pattern\| {`
`755`	`755`	`if (std.mem.indexOf(u8, input, pattern)) \|_\| {`
`756`		`- try result.warnings.append(try std.fmt.allocPrint(self.allocator, "Spaced command pattern: {s}", .{pattern}));`
	`756`	`+ try result.warnings.append(self.allocator, try std.fmt.allocPrint(self.allocator, "Spaced command pattern: {s}", .{pattern}));`
`757`	`757`	`fuzzy_level = .DANGEROUS;`
`758`	`758`	`}`
`759`	`759`	`}`