@zigc/lib 0.17.0-dev.76 → 0.17.0-dev.813

package/std/crypto/ecdsa.zig

@@ -212,7 +212,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             fn finalizePrehashed(self: *Signer, msg_hash: [Hash.digest_length]u8) (IdentityElementError || NonCanonicalError)!Signature {
                 const scalar_encoded_length = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, scalar_encoded_length);
-                var h: [h_len]u8 = [_]u8{0} ** (h_len - Hash.digest_length) ++ msg_hash;
+                var h: [h_len]u8 = @as([h_len - Hash.digest_length]u8, @splat(0)) ++ msg_hash;
 
                 std.debug.assert(h.len >= scalar_encoded_length);
                 const z = reduceToScalar(scalar_encoded_length, h[0..scalar_encoded_length].*);
@@ -275,7 +275,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             fn verifyPrehashed(self: *Verifier, msg_hash: [Hash.digest_length]u8) VerifyError!void {
                 const ht = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, ht);
-                var h: [h_len]u8 = [_]u8{0} ** (h_len - Hash.digest_length) ++ msg_hash;
+                var h: [h_len]u8 = @as([h_len - Hash.digest_length]u8, @splat(0)) ++ msg_hash;
 
                 const z = reduceToScalar(ht, h[0..ht].*);
                 if (z.isZero()) {
@@ -316,8 +316,8 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             ///
             /// Except in tests, applications should generally call `generate()` instead of this function.
             pub fn generateDeterministic(seed: [seed_length]u8) IdentityElementError!KeyPair {
-                const h = [_]u8{0x00} ** Hash.digest_length;
-                const k0 = [_]u8{0x01} ** SecretKey.encoded_length;
+                const h: [Hash.digest_length]u8 = @splat(0x00);
+                const k0: [SecretKey.encoded_length]u8 = @splat(0x01);
                 const secret_key = deterministicScalar(h, k0, seed).toBytes(.big);
                 return fromSecretKey(SecretKey{ .bytes = secret_key });
             }
@@ -367,11 +367,11 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         // Reduce the coordinate of a field element to the scalar field.
         fn reduceToScalar(comptime unreduced_len: usize, s: [unreduced_len]u8) Curve.scalar.Scalar {
             if (unreduced_len >= 48) {
-                var xs = [_]u8{0} ** 64;
+                var xs: [64]u8 = @splat(0);
                 @memcpy(xs[xs.len - s.len ..], s[0..]);
                 return Curve.scalar.Scalar.fromBytes64(xs, .big);
             }
-            var xs = [_]u8{0} ** 48;
+            var xs: [48]u8 = @splat(0);
             @memcpy(xs[xs.len - s.len ..], s[0..]);
             return Curve.scalar.Scalar.fromBytes48(xs, .big);
         }
@@ -379,9 +379,9 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         // Create a deterministic scalar according to a secret key and optional noise.
         // This uses the overly conservative scheme from the "Deterministic ECDSA and EdDSA Signatures with Additional Randomness" draft.
         fn deterministicScalar(h: [Hash.digest_length]u8, secret_key: Curve.scalar.CompressedScalar, noise: ?[noise_length]u8) Curve.scalar.Scalar {
-            var k = [_]u8{0x00} ** h.len;
-            var m = [_]u8{0x00} ** (h.len + 1 + noise_length + secret_key.len + h.len);
-            var t = [_]u8{0x00} ** Curve.scalar.encoded_length;
+            var k: [h.len]u8 = @splat(0);
+            var m: [h.len + 1 + noise_length + secret_key.len + h.len]u8 = @splat(0);
+            var t: [Curve.scalar.encoded_length]u8 = @splat(0);
             const m_v = m[0..h.len];
             const m_i = &m[m_v.len];
             const m_z = m[m_v.len + 1 ..][0..noise_length];

package/std/crypto/ff.zig

@@ -10,7 +10,6 @@ const builtin = @import("builtin");
 const crypto = std.crypto;
 const math = std.math;
 const mem = std.mem;
-const meta = std.meta;
 const testing = std.testing;
 const assert = std.debug.assert;
 const Endian = std.builtin.Endian;
@@ -25,7 +24,7 @@ const carry_bits = 1;
 const t_bits: usize = @bitSizeOf(Limb) - carry_bits;
 
 // A TLimb is a Limb that is truncated to t_bits.
-const TLimb = meta.Int(.unsigned, t_bits);
+const TLimb = @Int(.unsigned, t_bits);
 
 const native_endian = builtin.target.cpu.arch.endian();
 
@@ -96,7 +95,7 @@ pub fn Uint(comptime max_bits: comptime_int) type {
 
         /// The zero integer.
         pub const zero: Self = .{
-            .limbs_buffer = [1]Limb{0} ** max_limbs_count,
+            .limbs_buffer = @splat(0),
             .limbs_len = max_limbs_count,
         };
 
@@ -703,7 +702,9 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
             var out = self.one();
             self.toMontgomery(&out) catch unreachable;
 
-            if (public and e.len < 3 or (e.len == 3 and e[if (endian == .big) 0 else 2] <= 0b1111)) {
+            if (public and
+                (e.len < 3 or (e.len == 3 and e[if (endian == .big) 0 else 2] <= 0b1111)))
+            {
                 // Do not use a precomputation table for short, public exponents
                 var x_m = x;
                 if (!x.montgomery) {
@@ -738,7 +739,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
                 }
             } else {
                 // Use a precomputation table for large exponents
-                var pc = [1]Fe{x} ++ [_]Fe{self.zero} ** 14;
+                var pc: [15]Fe = [1]Fe{x} ++ @as([14]Fe, @splat(self.zero));
                 if (!x.montgomery) {
                     self.toMontgomery(&pc[0]) catch unreachable;
                 }
@@ -906,7 +907,7 @@ const ct_protected = struct {
     // Multiplies two limbs and returns the result as a wide limb.
     fn mulWide(x: Limb, y: Limb) WideLimb {
         const half_bits = @typeInfo(Limb).int.bits / 2;
-        const Half = meta.Int(.unsigned, half_bits);
+        const Half = @Int(.unsigned, half_bits);
         const x0 = @as(Half, @truncate(x));
         const x1 = @as(Half, @truncate(x >> half_bits));
         const y0 = @as(Half, @truncate(y));

package/std/crypto/ghash_polyval.zig

@@ -417,8 +417,8 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
 const htest = @import("test.zig");
 
 test "ghash" {
-    const key = [_]u8{0x42} ** 16;
-    const m = [_]u8{0x69} ** 256;
+    const key: [16]u8 = @splat(0x42);
+    const m: [256]u8 = @splat(0x69);
 
     var st = Ghash.init(&key);
     st.update(&m);
@@ -467,8 +467,8 @@ test "ghash2" {
 }
 
 test "polyval" {
-    const key = [_]u8{0x42} ** 16;
-    const m = [_]u8{0x69} ** 256;
+    const key: [16]u8 = @splat(0x42);
+    const m: [256]u8 = @splat(0x69);
 
     var st = Polyval.init(&key);
     st.update(&m);

package/std/crypto/hkdf.zig

@@ -72,7 +72,7 @@ pub fn Hkdf(comptime Hmac: type) type {
 const htest = @import("test.zig");
 
 test "Hkdf" {
-    const ikm = [_]u8{0x0b} ** 22;
+    const ikm: [22]u8 = @splat(0x0b);
     const salt = [_]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c };
     const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
     const kdf = HkdfSha256;

package/std/crypto/isap.zig

@@ -42,7 +42,7 @@ pub const IsapA128A = struct {
                     break;
                 }
             } else {
-                var padded = [_]u8{0} ** 8;
+                var padded: [8]u8 = @splat(0);
                 @memcpy(padded[0..left], m[i..]);
                 padded[left] = 0x80;
                 isap.st.addBytes(&padded);
@@ -169,8 +169,8 @@ pub const IsapA128A = struct {
 };
 
 test "ISAP" {
-    const k = [_]u8{1} ** 16;
-    const n = [_]u8{2} ** 16;
+    const k: [16]u8 = @splat(1);
+    const n: [16]u8 = @splat(2);
     var tag: [16]u8 = undefined;
     const ad = "ad";
     var msg = "test";

package/std/crypto/kangarootwelve.zig

@@ -881,7 +881,7 @@ fn ktMultiThreaded(
         // Buffer for out-of-order results (select_buf slots get reused)
         const pending_cv_buf = try allocator.alloc([leaves_per_batch * cv_size]u8, max_concurrent);
         defer allocator.free(pending_cv_buf);
-        var pending_cv_lens: [256]usize = .{0} ** 256;
+        var pending_cv_lens: [256]usize = @splat(0);
 
         var select_outstanding: usize = 0;
         var select: Select = .init(io, select_buf);

package/std/crypto/keccak_p.zig

@@ -9,7 +9,7 @@ const mode = @import("builtin").mode;
 /// The Keccak-f permutation.
 pub fn KeccakF(comptime f: u11) type {
     comptime assert(f >= 200 and f <= 1600 and f % 200 == 0); // invalid bit size
-    const T = std.meta.Int(.unsigned, f / 25);
+    const T = @Int(.unsigned, f / 25);
     const Block = [25]T;
 
     const PI = [_]u5{
@@ -40,7 +40,7 @@ pub fn KeccakF(comptime f: u11) type {
             break :rc rc;
         };
 
-        st: Block = [_]T{0} ** 25,
+        st: Block = @splat(0),
 
         /// Initialize the state from a slice of bytes.
         pub fn init(bytes: [block_bytes]u8) Self {
@@ -70,7 +70,7 @@ pub fn KeccakF(comptime f: u11) type {
                 self.st[i / @sizeOf(T)] = mem.readInt(T, bytes[i..][0..@sizeOf(T)], .little);
             }
             if (i < bytes.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 @memcpy(padded[0 .. bytes.len - i], bytes[i..]);
                 self.st[i / @sizeOf(T)] = mem.readInt(T, padded[0..], .little);
             }
@@ -89,7 +89,7 @@ pub fn KeccakF(comptime f: u11) type {
                 self.st[i / @sizeOf(T)] ^= mem.readInt(T, bytes[i..][0..@sizeOf(T)], .little);
             }
             if (i < bytes.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 @memcpy(padded[0 .. bytes.len - i], bytes[i..]);
                 self.st[i / @sizeOf(T)] ^= mem.readInt(T, padded[0..], .little);
             }
@@ -102,7 +102,7 @@ pub fn KeccakF(comptime f: u11) type {
                 mem.writeInt(T, out[i..][0..@sizeOf(T)], self.st[i / @sizeOf(T)], .little);
             }
             if (i < out.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 mem.writeInt(T, padded[0..], self.st[i / @sizeOf(T)], .little);
                 @memcpy(out[i..], padded[0 .. out.len - i]);
             }
@@ -118,7 +118,7 @@ pub fn KeccakF(comptime f: u11) type {
                 mem.writeInt(T, out[i..][0..@sizeOf(T)], x, native_endian);
             }
             if (i < in.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 @memcpy(padded[0 .. in.len - i], in[i..]);
                 const x = mem.readInt(T, &padded, native_endian) ^ mem.nativeToLittle(T, self.st[i / @sizeOf(T)]);
                 mem.writeInt(T, &padded, x, native_endian);
@@ -140,7 +140,7 @@ pub fn KeccakF(comptime f: u11) type {
             const st = &self.st;
 
             // theta
-            var t = [_]T{0} ** 5;
+            var t: [5]T = @splat(0);
             inline for (0..5) |i| {
                 inline for (0..5) |j| {
                     t[i] ^= st[j * 5 + i];
@@ -382,7 +382,7 @@ test "Keccak-f800" {
 }
 
 test "squeeze" {
-    var st = State(800, 256, 22).init([_]u8{0x80} ** 100, 0x01);
+    var st: State(800, 256, 22) = .init(@splat(0x80), 0x01);
 
     var out0: [15]u8 = undefined;
     var out1: [out0.len]u8 = undefined;

package/std/crypto/md5.zig

@@ -272,7 +272,7 @@ test "streaming" {
 }
 
 test "aligned final" {
-    var block = [_]u8{0} ** Md5.block_length;
+    const block: [Md5.block_length]u8 = @splat(0);
     var out: [Md5.digest_length]u8 = undefined;
 
     var h = Md5.init(.{});

package/std/crypto/ml_dsa.zig

@@ -156,7 +156,7 @@ const Params = struct {
 const Poly = struct {
     cs: [N]u32,
 
-    const zero: Poly = .{ .cs = .{0} ** N };
+    const zero: Poly = .{ .cs = @splat(0) };
 
     // Add two polynomials (no normalization)
     fn add(a: Poly, b: Poly) Poly {
@@ -302,7 +302,7 @@ fn PolyVec(comptime len: u8) type {
         ps: [len]Poly,
 
         const Self = @This();
-        const zero: Self = .{ .ps = .{Poly.zero} ** len };
+        const zero: Self = .{ .ps = @splat(.zero) };
 
         /// Apply a unary operation to each polynomial in the vector
         fn map(v: Self, comptime op: fn (Poly) Poly) Self {
@@ -581,7 +581,7 @@ fn PolyVec(comptime len: u8) type {
 
         /// Unpack hints from bytes
         fn unpackHint(comptime omega: u16, buf: []const u8) ?Self {
-            var result: Self = .{ .ps = .{Poly.zero} ** len };
+            var result: Self = .{ .ps = @splat(.zero) };
             var prev_sop: u8 = 0; // previous switch-over-point
 
             for (0..len) |i| {
@@ -1839,7 +1839,7 @@ fn MLDSAImpl(comptime p: Params) type {
                 return Signer{
                     .h = h,
                     .secret_key = secret_key,
-                    .rnd = noise orelse .{0} ** 32,
+                    .rnd = noise orelse @splat(0),
                 };
             }
 
@@ -2324,7 +2324,7 @@ test "decompose correctness for ML-DSA-87" {
 
 test "polyDeriveUniform deterministic" {
     // Test that polyDeriveUniform produces deterministic results
-    const seed: [32]u8 = .{0x01} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x01} ++ @as([31]u8, @splat(0x00));
     const nonce: u16 = 0;
 
     const p1 = polyDeriveUniform(&seed, nonce);
@@ -2343,7 +2343,7 @@ test "polyDeriveUniform deterministic" {
 
 test "polyDeriveUniform different nonces" {
     // Test that different nonces produce different polynomials
-    const seed: [32]u8 = .{0x01} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x01} ++ @as([31]u8, @splat(0x00));
 
     const p1 = polyDeriveUniform(&seed, 0);
     const p2 = polyDeriveUniform(&seed, 1);
@@ -2361,7 +2361,7 @@ test "polyDeriveUniform different nonces" {
 
 test "expandS with eta=2" {
     // Test eta=2 sampling
-    const seed: [64]u8 = .{0x02} ++ .{0x00} ** 63;
+    const seed: [64]u8 = .{0x02} ++ @as([63]u8, @splat(0x00));
     const nonce: u16 = 0;
 
     const p = expandS(2, &seed, nonce);
@@ -2378,7 +2378,7 @@ test "expandS with eta=2" {
 
 test "expandS with eta=4" {
     // Test eta=4 sampling
-    const seed: [64]u8 = .{0x03} ++ .{0x00} ** 63;
+    const seed: [64]u8 = .{0x03} ++ @as([63]u8, @splat(0x00));
     const nonce: u16 = 0;
 
     const p = expandS(4, &seed, nonce);
@@ -2395,7 +2395,7 @@ test "expandS with eta=4" {
 test "sampleInBall has correct weight" {
     // Test that ball polynomial has exactly tau non-zero coefficients
     const tau = 39; // From ML-DSA-44
-    const seed: [32]u8 = .{0x04} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x03} ++ @as([31]u8, @splat(0x00));
 
     const p = sampleInBall(tau, &seed);
 
@@ -2415,7 +2415,7 @@ test "sampleInBall has correct weight" {
 test "sampleInBall deterministic" {
     // Test that ball sampling is deterministic
     const tau = 49; // From ML-DSA-65
-    const seed: [32]u8 = .{0x05} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x05} ++ @as([31]u8, @splat(0x00));
 
     const p1 = sampleInBall(tau, &seed);
     const p2 = sampleInBall(tau, &seed);
@@ -2851,13 +2851,13 @@ test "Key generation basic - all variants" {
         .{ .variant = MLDSA65, .seed_byte = 0x65 },
         .{ .variant = MLDSA87, .seed_byte = 0x87 },
     }) |config| {
-        const seed = [_]u8{config.seed_byte} ** 32;
+        const seed: [32]u8 = @splat(config.seed_byte);
         try testKeyGenerationBasic(config.variant, seed);
     }
 }
 
 test "Key generation determinism" {
-    const seed = [_]u8{ 0x12, 0x34, 0x56, 0x78 } ++ [_]u8{0xAB} ** 28;
+    const seed = [_]u8{ 0x12, 0x34, 0x56, 0x78 } ++ @as([28]u8, @splat(0xAB));
 
     // Generate two key pairs from the same seed
     const result1 = MLDSA44.newKeyFromSeed(&seed);
@@ -2874,7 +2874,7 @@ test "Key generation determinism" {
 }
 
 test "Private key can compute public key" {
-    const seed = [_]u8{0xFF} ** 32;
+    const seed: [32]u8 = @splat(0xFF);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const pk = result.pk;
     const sk = result.sk;
@@ -2907,13 +2907,13 @@ test "Sign and verify - all variants" {
         .{ .variant = MLDSA65, .seed_byte = 0x65, .message = "Hello, ML-DSA-65!" },
         .{ .variant = MLDSA87, .seed_byte = 0x87, .message = "Hello, ML-DSA-87!" },
     }) |config| {
-        const seed = [_]u8{config.seed_byte} ** 32;
+        const seed: [32]u8 = @splat(config.seed_byte);
         try testSignAndVerify(config.variant, seed, config.message);
     }
 }
 
 test "Invalid signature rejection" {
-    const seed = [_]u8{0x99} ** 32;
+    const seed: [32]u8 = @splat(0x99);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -2934,7 +2934,7 @@ test "Invalid signature rejection" {
 }
 
 test "Context string support" {
-    const seed = [_]u8{0xAA} ** 32;
+    const seed: [32]u8 = @splat(0xAA);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -2964,17 +2964,17 @@ test "Context string support" {
     try testing.expectError(error.SignatureVerificationFailed, sig2.verifyWithContext(message, kp.public_key, context1));
 
     // Test maximum context length (255 bytes)
-    const max_context = [_]u8{0xBB} ** 255;
+    const max_context: [255]u8 = @splat(0xBB);
     const sig3 = try kp.signWithContext(message, null, &max_context);
     try sig3.verifyWithContext(message, kp.public_key, &max_context);
 
     // Test context too long (256 bytes should fail)
-    const too_long_context = [_]u8{0xCC} ** 256;
+    const too_long_context: [256]u8 = @splat(0xCC);
     try testing.expectError(error.ContextTooLong, kp.signWithContext(message, null, &too_long_context));
 }
 
 test "Context string with streaming API" {
-    const seed = [_]u8{0xDD} ** 32;
+    const seed: [32]u8 = @splat(0xDD);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -3002,12 +3002,12 @@ test "Context string with streaming API" {
 }
 
 test "Signature determinism (same rnd)" {
-    const seed = [_]u8{0x11} ** 32;
+    const seed: [32]u8 = @splat(0x11);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const sk = result.sk;
 
     const message = "Deterministic test";
-    const rnd = [_]u8{0x22} ** 32;
+    const rnd: [32]u8 = @splat(0x22);
 
     // Sign twice with same randomness using streaming API
     var st1 = try sk.signer(rnd);
@@ -3023,7 +3023,7 @@ test "Signature determinism (same rnd)" {
 }
 
 test "Signature toBytes/fromBytes roundtrip" {
-    const seed = [_]u8{0x33} ** 32;
+    const seed: [32]u8 = @splat(0x33);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -3043,7 +3043,7 @@ test "Signature toBytes/fromBytes roundtrip" {
 }
 
 test "Empty message signing" {
-    const seed = [_]u8{0x44} ** 32;
+    const seed: [32]u8 = @splat(0x44);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -3057,12 +3057,12 @@ test "Empty message signing" {
 }
 
 test "Long message signing" {
-    const seed = [_]u8{0x55} ** 32;
+    const seed: [32]u8 = @splat(0x55);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
     // Create a long message (1KB)
-    const long_message = [_]u8{0xAB} ** 1024;
+    const long_message: [1024]u8 = @splat(0xAB);
 
     // Sign long message
     const sig = try kp.sign(&long_message, null);
@@ -3209,7 +3209,7 @@ test "KeyPair API - generate and sign" {
 
 test "KeyPair API - generateDeterministic" {
     // Test deterministic key generation
-    const seed = [_]u8{42} ** 32;
+    const seed: [32]u8 = @splat(42);
     const kp1 = try MLDSA44.KeyPair.generateDeterministic(seed);
     const kp2 = try MLDSA44.KeyPair.generateDeterministic(seed);
 
@@ -3240,7 +3240,7 @@ test "Signature verification with noise" {
     const msg = "Message to be signed with randomness";
 
     // Create some noise
-    const noise = [_]u8{ 1, 2, 3, 4, 5 } ++ [_]u8{0} ** 27;
+    const noise = [_]u8{ 1, 2, 3, 4, 5 } ++ @as([27]u8, @splat(0));
 
     // Sign with noise
     const sig = try kp.sign(msg, noise);
@@ -3262,7 +3262,7 @@ test "Signature verification failure" {
 }
 
 test "Streaming API - sign and verify" {
-    const seed = [_]u8{0x55} ** 32;
+    const seed: [32]u8 = @splat(0x55);
     const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
 
     const msg = "Test message for streaming API";
@@ -3279,7 +3279,7 @@ test "Streaming API - sign and verify" {
 }
 
 test "Streaming API - chunked message" {
-    const seed = [_]u8{0x66} ** 32;
+    const seed: [32]u8 = @splat(0x66);
     const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
 
     // Create a message in chunks
@@ -3313,7 +3313,7 @@ test "Streaming API - chunked message" {
 }
 
 test "Streaming API - large message" {
-    const seed = [_]u8{0x77} ** 32;
+    const seed: [32]u8 = @splat(0x77);
     const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
 
     // Create a large message (1MB)
@@ -3344,7 +3344,7 @@ test "Streaming API - all parameter sets" {
 
     // ML-DSA-44
     {
-        const seed = [_]u8{0x44} ** 32;
+        const seed: [32]u8 = @splat(0x44);
         const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
         var signer = try kp.signer(null);
         signer.update(test_msg);
@@ -3356,7 +3356,7 @@ test "Streaming API - all parameter sets" {
 
     // ML-DSA-65
     {
-        const seed = [_]u8{0x65} ** 32;
+        const seed: [32]u8 = @splat(0x65);
         const kp = try MLDSA65.KeyPair.generateDeterministic(seed);
         var signer = try kp.signer(null);
         signer.update(test_msg);
@@ -3368,7 +3368,7 @@ test "Streaming API - all parameter sets" {
 
     // ML-DSA-87
     {
-        const seed = [_]u8{0x87} ** 32;
+        const seed: [32]u8 = @splat(0x87);
         const kp = try MLDSA87.KeyPair.generateDeterministic(seed);
         var signer = try kp.signer(null);
         signer.update(test_msg);
@@ -3413,7 +3413,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
     // Use a signed type for EEA computation
     const type_info = @typeInfo(T);
     const SignedT = if (type_info == .int and type_info.int.signedness == .unsigned)
-        std.meta.Int(.signed, type_info.int.bits)
+        @Int(.signed, type_info.int.bits)
     else
         T;
 
@@ -3436,7 +3436,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
 fn modularPow(comptime T: type, comptime a: T, s: T, comptime p: T) T {
     const type_info = @typeInfo(T);
     const bits = type_info.int.bits;
-    const WideT = std.meta.Int(.unsigned, bits * 2);
+    const WideT = @Int(.unsigned, bits * 2);
 
     var ret: T = 1;
     var base: T = a;
@@ -3465,14 +3465,14 @@ fn bitMask(comptime T: type, bit: T) T {
 
 /// Creates a mask from the sign bit of a signed integer.
 /// Returns all 1s (0xFF...FF) if x < 0, all 0s if x >= 0.
-fn signMask(comptime T: type, x: T) std.meta.Int(.unsigned, @typeInfo(T).int.bits) {
+fn signMask(comptime T: type, x: T) @Int(.unsigned, @typeInfo(T).int.bits) {
     const type_info = @typeInfo(T);
     if (type_info != .int) {
         @compileError("signMask requires an integer type");
     }
 
     const bits = type_info.int.bits;
-    const SignedT = std.meta.Int(.signed, bits);
+    const SignedT = @Int(.signed, bits);
 
     // Convert to signed if needed, arithmetic right shift to propagate sign bit
     const x_signed: SignedT = if (type_info.int.signedness == .signed) x else @bitCast(x);
@@ -3499,8 +3499,8 @@ fn montgomeryReduce(
     const m: OutT = @truncate(m_full);
 
     const yR = x -% @as(InT, m) * @as(InT, q);
-    const y_shifted = @as(std.meta.Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
-    return @bitCast(@as(std.meta.Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
+    const y_shifted = @as(@Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
+    return @bitCast(@as(@Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
 }
 
 /// Uniform sampling using SHAKE-128 with rejection sampling.