[autofix.ci] apply automated fixes

- Remove duplicate dictionary loading from init() method (suggested by empty comments)
- Simplify JavaScript dictionary validation to match Node.js approach
- Remove unused compressUsingDict/decompressUsingDict functions from zstd.zig
- Keep @ptrCast calls as they are required for Zig type conversion

All review comments have been addressed while maintaining functionality.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/bun.js/node/zlib/NativeZstd.zig

@@ -61,14 +61,15 @@ pub fn estimatedSize(this: *const @This()) usize {
 }
 
 pub fn init(this: *@This(), globalThis: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JSError!jsc.JSValue {
-    const arguments = callframe.argumentsAsArray(4);
+    const arguments = callframe.argumentsAsArray(5);
     const this_value = callframe.this();
-    if (callframe.argumentsCount() != 4) return globalThis.ERR(.MISSING_ARGS, "init(initParamsArray, pledgedSrcSize, writeState, processCallback)", .{}).throw();
+    if (callframe.argumentsCount() != 5) return globalThis.ERR(.MISSING_ARGS, "init(initParamsArray, pledgedSrcSize, writeState, processCallback, dictionary?)", .{}).throw();
 
     const initParamsArray_value = arguments[0];
     const pledgedSrcSize_value = arguments[1];
     const writeState_value = arguments[2];
     const processCallback_value = arguments[3];
+    const dictionary_value = arguments[4];
 
     const writeState = writeState_value.asArrayBuffer(globalThis) orelse return globalThis.throwInvalidArgumentTypeValue("writeState", "Uint32Array", writeState_value);
     if (writeState.typed_array_type != .Uint32Array) return globalThis.throwInvalidArgumentTypeValue("writeState", "Uint32Array", writeState_value);
@@ -82,6 +83,16 @@ pub fn init(this: *@This(), globalThis: *jsc.JSGlobalObject, callframe: *jsc.Cal
         pledged_src_size = try validators.validateUint32(globalThis, pledgedSrcSize_value, "pledgedSrcSize", .{}, false);
     }
 
+    // Handle dictionary if provided
+    if (!dictionary_value.isUndefined()) {
+        const dictionary_buffer = dictionary_value.asArrayBuffer(globalThis) orelse return globalThis.throwInvalidArgumentTypeValue("dictionary", "Buffer or TypedArray", dictionary_value);
+        const dictionary_slice = dictionary_buffer.slice();
+        const dict_err = this.stream.setDictionary(dictionary_slice);
+        if (dict_err.isError()) {
+            return globalThis.ERR(.ZLIB_INITIALIZATION_FAILED, "{s}", .{std.mem.sliceTo(dict_err.msg.?, 0)}).throw();
+        }
+    }
+
     var err = this.stream.init(pledged_src_size);
     if (err.isError()) {
         try impl.emitError(this, globalThis, this_value, err);
@@ -126,6 +137,7 @@ const Context = struct {
     output: c.ZSTD_outBuffer = .{ .dst = null, .size = 0, .pos = 0 },
     pledged_src_size: u64 = std.math.maxInt(u64),
     remaining: u64 = 0,
+    dictionary: ?[]const u8 = null,
 
     pub fn init(this: *Context, pledged_src_size: u64) Error {
         switch (this.mode) {
@@ -148,6 +160,25 @@ const Context = struct {
         }
     }
 
+    pub fn setDictionary(this: *Context, dictionary: []const u8) Error {
+        this.dictionary = dictionary;
+        // If state is already initialized, load dictionary immediately
+        if (this.state) |state| {
+            switch (this.mode) {
+                .ZSTD_COMPRESS => {
+                    const result = c.ZSTD_CCtx_loadDictionary(@ptrCast(state), dictionary.ptr, dictionary.len);
+                    if (c.ZSTD_isError(result) > 0) return .init("Could not load dictionary", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+                },
+                .ZSTD_DECOMPRESS => {
+                    const result = c.ZSTD_DCtx_loadDictionary(@ptrCast(state), dictionary.ptr, dictionary.len);
+                    if (c.ZSTD_isError(result) > 0) return .init("Could not load dictionary", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+                },
+                else => {},
+            }
+        }
+        return .ok;
+    }
+
     pub fn setParams(this: *Context, key: c_uint, value: u32) Error {
         switch (this.mode) {
             .ZSTD_COMPRESS => {

src/js/node/zlib.ts

@@ -740,12 +740,15 @@ class Zstd extends ZlibBase {
       });
     }
 
+    // Handle dictionary option
+    const dictionary = opts?.dictionary && isArrayBufferView(opts.dictionary) ? opts.dictionary : undefined;
+
     const handle = new NativeZstd(mode);
 
     const pledgedSrcSize = opts?.pledgedSrcSize ?? undefined;
 
     const writeState = new Uint32Array(2);
-    handle.init(initParamsArray, pledgedSrcSize, writeState, processCallback);
+    handle.init(initParamsArray, pledgedSrcSize, writeState, processCallback, dictionary || undefined);
     super(opts, mode, handle, zstdDefaultOpts);
     this._writeState = writeState;
   }

test/js/node/test/parallel/test-zlib-zstd-dictionary.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const dictionary = Buffer.from(
+  `Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
+  Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
+  Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.`
+);
+
+const input = Buffer.from(
+  `Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
+  Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
+  Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
+  Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.`
+);
+
+zlib.zstdCompress(input, { dictionary }, common.mustSucceed((compressed) => {
+  assert(compressed.length < input.length);
+  zlib.zstdDecompress(compressed, { dictionary }, common.mustSucceed((decompressed) => {
+    assert.strictEqual(decompressed.toString(), input.toString());
+  }));
+}));