@ddunigma/node 1.1.6 → 1.1.7

package/README.md

@@ -64,6 +64,7 @@ const encoder4 = new Ddu64(undefined, undefined, {
 const text = "안녕하세요";
 const encoded = encoder1.encode(text);
 const decoded = encoder1.decode(encoded);
+const decodedBuffer = encoder1.decodeToBuffer(encoded);
 ```
 
 ### 커스텀 Charset 사용
@@ -82,4 +83,47 @@ const encoder = new Ddu64(koreanChars, "뭐");
 const text = "안녕하세요12";
 const encoded = encoder.encode(text);
 const decoded = encoder.decode(encoded);
+const decodedBuffer = encoder.decodeToBuffer(encoded);
+```
+
+## API
+
+### `new Ddu64(dduChar?, paddingChar?, options?)`
+
+인코더 인스턴스를 생성합니다.
+
+**Parameters:**
+- `dduChar` (string | string[]): charset 문자열 또는 배열
+- `paddingChar` (string): 패딩 문자
+- `options` (DduOptions): 옵션 객체
+  - `dduSetSymbol`: 미리 정의된 charset 사용
+  - `encoding`: Buffer encoding (기본값: 'utf-8')
+  - `usePowerOfTwo`: 2의 제곱수 강제 여부
+  - `useBuildErrorReturn`: 에러 발생 시 throw 여부
+
+### `encode(data: string | Buffer): string`
+
+데이터를 인코딩
+
+### `decode(encoded: string): string`
+
+인코딩된 문자열을 디코딩
+
+### `decodeToBuffer(encoded: string): Buffer`
+
+인코딩된 문자열을 Buffer로 직접 디코딩
+
+### `getCharSetInfo()`
+
+현재 charset 정보를 반환
+
+```typescript
+{
+  charSet: string[];
+  paddingChar: string;
+  charLength: number;
+  bitLength: number;
+  usePowerOfTwo: boolean;
+  encoding: BufferEncoding;
+}
 ```

package/dist/cjs/base/BaseDdu.d.ts

@@ -1,38 +1,27 @@
 import { DduOptions, BufferToDduBinaryResult } from "../types";
 export declare abstract class BaseDdu {
     protected readonly defaultEncoding: BufferEncoding;
-    /**
-     * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
-     */
     protected readonly binaryLookup: string[];
-    /**
-     * 정규표현식 특수문자 이스케이프
-     */
     protected escapeRegExp(str: string): string;
-    /**
-     * 문자열을 지정된 길이로 분할하는 제너레이터
-     */
     protected splitString(s: string, length: number): Generator<string>;
-    /**
-     * 2의 거듭제곱 길이 계산
-     */
     protected getLargestPowerOfTwo(n: number): number;
-    /**
-     * 2의 거듭제곱 지수 계산
-     */
     protected getLargestPowerOfTwoExponent(n: number): number;
-    /**
-     * 비트 길이 계산
-     */
     protected getBitLength(setLength: number): number;
-    /**
-     * Buffer를 DDU Binary 배열로 변환
-     */
     protected bufferToDduBinary(input: Buffer, bitLength: number): BufferToDduBinaryResult;
-    /**
-     * DDU Binary를 Buffer로 변환
-     */
     protected dduBinaryToBuffer(decodedBin: string, paddingBits: number): Buffer;
     abstract encode(input: Buffer | string, options?: DduOptions): string;
+    abstract decodeToBuffer(input: string, options?: DduOptions): Buffer;
     abstract decode(input: string, options?: DduOptions): string;
+    /**
+     * 테스트 및 디버깅용 추상 메서드
+     * 구현 클래스의 내부 상태 정보를 반환
+     */
+    abstract getCharSetInfo(): {
+        charSet: string[];
+        paddingChar: string;
+        charLength: number;
+        bitLength: number;
+        usePowerOfTwo: boolean;
+        encoding: BufferEncoding;
+    };
 }

package/dist/cjs/base/BaseDdu.js

@@ -4,46 +4,25 @@ exports.BaseDdu = void 0;
 class BaseDdu {
     constructor() {
         this.defaultEncoding = "utf-8";
-        /**
-         * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
-         */
         this.binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
     }
-    /**
-     * 정규표현식 특수문자 이스케이프
-     */
     escapeRegExp(str) {
         return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
-    /**
-     * 문자열을 지정된 길이로 분할하는 제너레이터
-     */
     *splitString(s, length) {
         for (let i = 0; i < s.length; i += length) {
             yield s.slice(i, Math.min(i + length, s.length));
         }
     }
-    /**
-     * 2의 거듭제곱 길이 계산
-     */
     getLargestPowerOfTwo(n) {
         return Math.pow(2, Math.floor(Math.log2(n)));
     }
-    /**
-     * 2의 거듭제곱 지수 계산
-     */
     getLargestPowerOfTwoExponent(n) {
         return Math.floor(Math.log2(n));
     }
-    /**
-     * 비트 길이 계산
-     */
     getBitLength(setLength) {
         return Math.ceil(Math.log2(setLength));
     }
-    /**
-     * Buffer를 DDU Binary 배열로 변환
-     */
     bufferToDduBinary(input, bitLength) {
         // 성능 최적화: reduce 대신 for loop + join 사용
         if (input.length === 0) {
@@ -61,9 +40,6 @@ class BaseDdu {
         }
         return { dduBinary, padding };
     }
-    /**
-     * DDU Binary를 Buffer로 변환
-     */
     dduBinaryToBuffer(decodedBin, paddingBits) {
         if (paddingBits > 0) {
             decodedBin = decodedBin.slice(0, -paddingBits);

package/dist/cjs/encoders/Ddu64.d.ts

@@ -10,6 +10,7 @@ export declare class Ddu64 extends BaseDdu {
     protected readonly dduBinaryLookup: Map<string, number>;
     private readonly isPredefinedCharSet;
     private readonly effectiveBitLength;
+    private readonly maxBinaryValue;
     private readonly binaryChunkToIntFn;
     private readonly indexToBinaryCache;
     constructor(dduChar?: string[] | string, paddingChar?: string, dduOptions?: DduConstructorOptions);
@@ -17,5 +18,18 @@ export declare class Ddu64 extends BaseDdu {
     private getBinaryFromIndex;
     private validateCombinationDuplicates;
     encode(input: Buffer | string, _options?: DduOptions): string;
+    decodeToBuffer(input: string, _options?: DduOptions): Buffer;
     decode(input: string, _options?: DduOptions): string;
+    /**
+     * 테스트 및 디버깅용 getter 메서드
+     * 인코더의 내부 상태 정보를 반환
+     */
+    getCharSetInfo(): {
+        charSet: string[];
+        paddingChar: string;
+        charLength: number;
+        bitLength: number;
+        usePowerOfTwo: boolean;
+        encoding: BufferEncoding;
+    };
 }

package/dist/cjs/encoders/Ddu64.js

@@ -23,12 +23,23 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
             const finalPadding = paddingChar !== null && paddingChar !== void 0 ? paddingChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.paddingChar;
             if (finalDduChar) {
                 // 커스텀 charset
-                if (!finalPadding)
-                    throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
-                const arr = typeof finalDduChar === "string" ? [...new Set(finalDduChar.trim())] : finalDduChar;
+                if (!finalPadding) {
+                    throw new Error(`[Ddu64 Constructor] paddingChar is required when dduChar is provided. Received: dduChar=${typeof finalDduChar}, paddingChar=${finalPadding}`);
+                }
+                // 문자열을 배열로 변환 (중복 제거 없이)
+                const arr = typeof finalDduChar === "string" ? [...finalDduChar.trim()] : finalDduChar;
+                // 중복 검사 (useBuildErrorReturn이 true일 때만)
+                if (shouldThrowError) {
+                    const uniqueChars = new Set(arr);
+                    if (uniqueChars.size !== arr.length) {
+                        const duplicates = arr.filter((char, index) => arr.indexOf(char) !== index);
+                        throw new Error(`[Ddu64 Constructor] Character set contains duplicate characters. Total: ${arr.length}, Unique: ${uniqueChars.size}, Duplicates: [${[...new Set(duplicates)].join(', ')}]`);
+                    }
+                }
                 const len = (_b = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.requiredLength) !== null && _b !== void 0 ? _b : arr.length;
-                if (arr.length < len)
-                    throw new Error(`dduChar must be at least ${len} characters long. Provided: ${arr.length}`);
+                if (arr.length < len) {
+                    throw new Error(`[Ddu64 Constructor] Insufficient characters in charset. Required: ${len}, Provided: ${arr.length}`);
+                }
                 const usePow2 = (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === true || ((dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === undefined && len > 0 && (len & (len - 1)) === 0);
                 if (usePow2) {
                     const exp = this.getLargestPowerOfTwoExponent(len);
@@ -73,22 +84,25 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         this.dduChar = normalized.charSet;
         this.paddingChar = normalized.padding;
         this.charLength = normalized.charLength;
-        this.bitLength = normalized.bitLength;
         this.isPredefinedCharSet = normalized.isPredefined;
         this.encoding = (_g = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.encoding) !== null && _g !== void 0 ? _g : this.defaultEncoding;
         const dduLength = this.dduChar.length;
+        const recalculatedBitLength = this.getBitLength(dduLength);
         this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
-        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : this.getBitLength(dduLength);
-        this.binaryChunkToIntFn = this.effectiveBitLength <= 26
-            ? (chunk) => chunk.split('').reduce((v, c) => (v << 1) | (c.charCodeAt(0) & 1), 0)
-            : (chunk) => chunk.split('').reduce((v, c) => v * 2 + (c.charCodeAt(0) & 1), 0);
+        this.bitLength = this.usePowerOfTwo
+            ? this.getLargestPowerOfTwoExponent(dduLength)
+            : recalculatedBitLength;
+        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : recalculatedBitLength;
+        this.maxBinaryValue = Math.pow(2, this.effectiveBitLength);
+        // 성능 최적화: 단일 구현 사용 (벤치마크 결과 Method2가 더 빠르고 안정적)
+        // Method2는 32비트 이상에서도 오버플로우 없이 정확한 결과 제공
+        this.binaryChunkToIntFn = (chunk) => chunk.split('').reduce((v, c) => v * 2 + (c.charCodeAt(0) & 1), 0);
         this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
-        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+        if (this.charLength === 1 && !this.isPredefinedCharSet) {
             this.validateCombinationDuplicates(this.dduChar, this.paddingChar, dduLength);
         }
         if (this.effectiveBitLength <= 16) {
-            const size = 1 << this.effectiveBitLength;
-            this.indexToBinaryCache = Array.from({ length: size }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
+            this.indexToBinaryCache = Array.from({ length: this.maxBinaryValue }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
         }
         else {
             this.indexToBinaryCache = null;
@@ -114,50 +128,67 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
             }
             return false;
         };
-        // 중복 제거 (커스텀 charset만)
-        if (!isPredefined) {
-            const uniqueChars = new Set(charSet);
-            if (uniqueChars.size !== charSet.length) {
-                if (shouldThrowError)
-                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${charSet.length}`);
-                charSet = Array.from(uniqueChars);
+        // 중복 제거 (모든 charset에 적용)
+        const uniqueChars = new Set(charSet);
+        if (uniqueChars.size !== charSet.length) {
+            const duplicates = charSet.filter((char, index) => charSet.indexOf(char) !== index);
+            const errorMsg = `[Ddu64 normalizeCharSet] Character set contains duplicate characters. Total: ${charSet.length}, Unique: ${uniqueChars.size}, Duplicates: [${[...new Set(duplicates)].join(', ')}]`;
+            if (shouldThrowError)
+                throw new Error(errorMsg);
+            // 중복 제거 후 계속 진행
+            charSet = Array.from(uniqueChars);
+            if (!isPredefined) {
                 requiredLength = charSet.length;
             }
         }
         // 검증
-        if (validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`)) {
+        if (validate(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters. Required: ${requiredLength}, Provided: ${charSet.length}`)) {
+            return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
+        }
+        if (validate(requiredLength < 2, `[Ddu64 normalizeCharSet] At least 2 unique characters are required. Provided: ${requiredLength}`)) {
+            return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
+        }
+        if (validate(bitLength <= 0, `[Ddu64 normalizeCharSet] Invalid bit length (${bitLength}) for charset size ${requiredLength}`)) {
             return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
         }
         let charLength = (_b = (_a = charSet[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-        validate(charLength === 0, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+        validate(charLength === 0, `[Ddu64 normalizeCharSet] Empty charset. Required: ${requiredLength} characters`);
         const invalidIndex = charSet.findIndex(char => char.length !== charLength);
         if (invalidIndex !== -1) {
-            if (shouldThrowError)
-                throw new Error(`All characters must have the same length. Expected: ${charLength}, but index ${invalidIndex} has length ${charSet[invalidIndex].length}`);
+            if (shouldThrowError) {
+                throw new Error(`[Ddu64 normalizeCharSet] Inconsistent character length. Expected: ${charLength}, but character at index ${invalidIndex} ("${charSet[invalidIndex]}") has length ${charSet[invalidIndex].length}`);
+            }
             charSet = charSet.filter(char => char.length === charLength);
-            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            validate(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters after filtering. Required: ${requiredLength}, Remaining: ${charSet.length}`);
             charLength = (_d = (_c = charSet[0]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
         }
-        validate(!charSet.length, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: 0`);
-        validate(padding.length !== charLength, `Padding character must have length ${charLength}, got ${padding.length}`);
+        validate(!charSet.length, `[Ddu64 normalizeCharSet] Empty charset after validation`);
+        validate(padding.length !== charLength, `[Ddu64 normalizeCharSet] Padding character length mismatch. Expected: ${charLength}, Got: ${padding.length} (padding: "${padding}")`);
         if (new Set(charSet).has(padding)) {
-            if (shouldThrowError)
-                throw new Error(`Padding character "${padding}" cannot be in the character set`);
+            if (shouldThrowError) {
+                throw new Error(`[Ddu64 normalizeCharSet] Padding character "${padding}" conflicts with charset. Padding must not be in the character set.`);
+            }
             charSet = charSet.filter(char => char !== padding);
-            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            validate(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters after removing padding conflict. Required: ${requiredLength}, Remaining: ${charSet.length}`);
             charLength = (_f = (_e = charSet[0]) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
         }
         return { charSet: charSet.slice(0, requiredLength), padding, requiredLength, bitLength, isPredefined, charLength };
     }
     getBinaryFromIndex(index) {
         var _a, _b;
+        if (index < 0 || index >= this.maxBinaryValue) {
+            throw new Error(`[Ddu64] Binary index overflow. Received: ${index}, Allowed range: 0-${this.maxBinaryValue - 1}`);
+        }
         return (_b = (_a = this.indexToBinaryCache) === null || _a === void 0 ? void 0 : _a[index]) !== null && _b !== void 0 ? _b : index.toString(2).padStart(this.effectiveBitLength, "0");
     }
     validateCombinationDuplicates(charSet, paddingChar, requiredLength) {
         const charLength = charSet[0].length;
+        // 조합 충돌 검사는 단일 문자 집합이면서 비교적 작은 경우(<=256)에만 적용한다.
+        if (charLength !== 1 || requiredLength > 256) {
+            return;
+        }
         const allStrings = new Set([...charSet.slice(0, requiredLength), paddingChar]);
         const limit = Math.min(charSet.length, requiredLength);
-        // 2개 조합 검사
         for (let i = 0; i < limit; i++) {
             for (let j = 0; j < limit; j++) {
                 const combo = charSet[i] + charSet[j];
@@ -167,32 +198,17 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
             }
             const charPad = charSet[i] + paddingChar;
             const padChar = paddingChar + charSet[i];
-            if (allStrings.has(charPad))
+            if (allStrings.has(charPad)) {
                 throw new Error(`Combination conflict: "${charSet[i]}" + padding "${paddingChar}" = "${charPad}"`);
-            if (allStrings.has(padChar))
+            }
+            if (allStrings.has(padChar)) {
                 throw new Error(`Combination conflict: padding "${paddingChar}" + "${charSet[i]}" = "${padChar}"`);
+            }
         }
-        // 패딩 + 패딩 조합 검사
         const doublePad = paddingChar + paddingChar;
         if (allStrings.has(doublePad)) {
             throw new Error(`Combination conflict: double padding "${doublePad}" already exists`);
         }
-        // 3개 조합 검사 (100개 이하만)
-        if (charLength >= 2 && requiredLength <= 100) {
-            for (let i = 0; i < limit; i++) {
-                for (let j = 0; j < limit; j++) {
-                    for (let k = 0; k < limit; k++) {
-                        const combo = charSet[i] + charSet[j] + charSet[k];
-                        for (let start = 0; start <= combo.length - charLength; start++) {
-                            const sub = combo.substring(start, start + charLength);
-                            if (allStrings.has(sub) && sub !== charSet[i] && sub !== charSet[j] && sub !== charSet[k]) {
-                                throw new Error(`Combination conflict: substring "${sub}" from "${charSet[i]}" + "${charSet[j]}" + "${charSet[k]}"`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
     }
     encode(input, _options) {
         // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
@@ -207,8 +223,8 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         for (let i = 0; i < dduBinary.length; i++) {
             const binaryChunk = dduBinary[i];
             const charInt = this.binaryChunkToIntFn(binaryChunk);
-            if (this.charLength === 1 && !this.usePowerOfTwo) {
-                // 가변 길이 조합 인코딩
+            if (!this.usePowerOfTwo) {
+                // 가변 길이 조합 인코딩 (멀티바이트 문자도 지원)
                 const quotient = Math.floor(charInt / dduLength);
                 const remainder = charInt % dduLength;
                 resultParts[i] = this.dduChar[quotient] + this.dduChar[remainder];
@@ -225,45 +241,78 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         }
         return resultString;
     }
-    decode(input, _options) {
-        // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
-        // 패딩 정보 추출
+    decodeToBuffer(input, _options) {
         let paddingBits = 0;
-        const padCharIndex = input.indexOf(this.paddingChar);
-        if (padCharIndex >= 0) {
-            const paddingStr = input.substring(padCharIndex + this.paddingChar.length);
-            paddingBits = parseInt(paddingStr) || 0;
-            input = input.substring(0, padCharIndex);
+        if (input.length >= this.paddingChar.length) {
+            const padCharIndex = input.lastIndexOf(this.paddingChar);
+            if (padCharIndex >= 0 &&
+                padCharIndex % this.charLength === 0 &&
+                padCharIndex + this.paddingChar.length <= input.length) {
+                const paddingSection = input.slice(padCharIndex + this.paddingChar.length);
+                if (paddingSection.length === 0) {
+                    throw new Error(`[Ddu64 decode] Invalid padding format. Missing padding length after "${this.paddingChar}"`);
+                }
+                paddingBits = parseInt(paddingSection, 10);
+                if (isNaN(paddingBits) ||
+                    paddingSection !== paddingBits.toString() ||
+                    paddingBits < 0 ||
+                    paddingBits >= this.effectiveBitLength) {
+                    throw new Error(`[Ddu64 decode] Invalid padding format. Expected integer between 0 and ${this.effectiveBitLength - 1}, Got: "${paddingSection}"`);
+                }
+                input = input.substring(0, padCharIndex);
+            }
         }
         let dduBinary = "";
-        // 생성자에서 설정된 값 사용
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.effectiveBitLength;
-        if (this.charLength === 1 && !this.usePowerOfTwo) {
-            // 가변 길이 조합 디코딩 (2개씩 읽음)
-            for (let i = 0; i < input.length; i += 2) {
-                const firstChar = input[i];
-                const secondChar = input[i + 1];
+        if (!this.usePowerOfTwo) {
+            const chunkSize = this.charLength * 2;
+            for (let i = 0; i < input.length; i += chunkSize) {
+                const firstChar = input.slice(i, i + this.charLength);
+                const secondChar = input.slice(i + this.charLength, i + chunkSize);
                 const firstIndex = this.dduBinaryLookup.get(firstChar);
                 const secondIndex = this.dduBinaryLookup.get(secondChar);
-                if (firstIndex === undefined || secondIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
+                if (firstIndex === undefined || secondIndex === undefined) {
+                    const invalidChar = firstIndex === undefined ? firstChar : secondChar;
+                    throw new Error(`[Ddu64 decode] Invalid character in encoded string. Character: "${invalidChar}", Position: ${i}, Expected charset size: ${dduLength}`);
+                }
                 const value = firstIndex * dduLength + secondIndex;
+                if (value >= this.maxBinaryValue) {
+                    throw new Error(`[Ddu64 decode] Invalid character combination detected. Calculated value ${value} exceeds binary range ${this.maxBinaryValue - 1}.`);
+                }
                 dduBinary += this.getBinaryFromIndex(value);
             }
         }
         else {
-            // 고정 길이 직접 매핑 (charLength만큼씩 읽음)
             for (let i = 0; i < input.length; i += this.charLength) {
                 const charChunk = input.slice(i, i + this.charLength);
                 const charIndex = this.dduBinaryLookup.get(charChunk);
-                if (charIndex === undefined)
-                    throw new Error(`Invalid character: ${charChunk}`);
+                if (charIndex === undefined) {
+                    throw new Error(`[Ddu64 decode] Invalid character in encoded string. Character: "${charChunk}", Position: ${i}, Charset size: ${dduLength}, Character length: ${this.charLength}`);
+                }
+                if (charIndex >= this.maxBinaryValue) {
+                    throw new Error(`[Ddu64 decode] Invalid binary index ${charIndex}. Allowed range: 0-${this.maxBinaryValue - 1}`);
+                }
                 dduBinary += this.getBinaryFromIndex(charIndex);
             }
         }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);
-        return decoded.toString(this.encoding);
+        return this.dduBinaryToBuffer(dduBinary, paddingBits);
+    }
+    decode(input, _options) {
+        return this.decodeToBuffer(input, _options).toString(this.encoding);
+    }
+    /**
+     * 테스트 및 디버깅용 getter 메서드
+     * 인코더의 내부 상태 정보를 반환
+     */
+    getCharSetInfo() {
+        return {
+            charSet: [...this.dduChar],
+            paddingChar: this.paddingChar,
+            charLength: this.charLength,
+            bitLength: this.bitLength,
+            usePowerOfTwo: this.usePowerOfTwo,
+            encoding: this.encoding,
+        };
     }
 }
 exports.Ddu64 = Ddu64;

package/dist/mjs/base/BaseDdu.d.ts

@@ -1,38 +1,27 @@
 import { DduOptions, BufferToDduBinaryResult } from "../types";
 export declare abstract class BaseDdu {
     protected readonly defaultEncoding: BufferEncoding;
-    /**
-     * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
-     */
     protected readonly binaryLookup: string[];
-    /**
-     * 정규표현식 특수문자 이스케이프
-     */
     protected escapeRegExp(str: string): string;
-    /**
-     * 문자열을 지정된 길이로 분할하는 제너레이터
-     */
     protected splitString(s: string, length: number): Generator<string>;
-    /**
-     * 2의 거듭제곱 길이 계산
-     */
     protected getLargestPowerOfTwo(n: number): number;
-    /**
-     * 2의 거듭제곱 지수 계산
-     */
     protected getLargestPowerOfTwoExponent(n: number): number;
-    /**
-     * 비트 길이 계산
-     */
     protected getBitLength(setLength: number): number;
-    /**
-     * Buffer를 DDU Binary 배열로 변환
-     */
     protected bufferToDduBinary(input: Buffer, bitLength: number): BufferToDduBinaryResult;
-    /**
-     * DDU Binary를 Buffer로 변환
-     */
     protected dduBinaryToBuffer(decodedBin: string, paddingBits: number): Buffer;
     abstract encode(input: Buffer | string, options?: DduOptions): string;
+    abstract decodeToBuffer(input: string, options?: DduOptions): Buffer;
     abstract decode(input: string, options?: DduOptions): string;
+    /**
+     * 테스트 및 디버깅용 추상 메서드
+     * 구현 클래스의 내부 상태 정보를 반환
+     */
+    abstract getCharSetInfo(): {
+        charSet: string[];
+        paddingChar: string;
+        charLength: number;
+        bitLength: number;
+        usePowerOfTwo: boolean;
+        encoding: BufferEncoding;
+    };
 }

package/dist/mjs/base/BaseDdu.js

@@ -1,44 +1,23 @@
 export class BaseDdu {
     defaultEncoding = "utf-8";
-    /**
-     * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
-     */
     binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
-    /**
-     * 정규표현식 특수문자 이스케이프
-     */
     escapeRegExp(str) {
         return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
-    /**
-     * 문자열을 지정된 길이로 분할하는 제너레이터
-     */
     *splitString(s, length) {
         for (let i = 0; i < s.length; i += length) {
             yield s.slice(i, Math.min(i + length, s.length));
         }
     }
-    /**
-     * 2의 거듭제곱 길이 계산
-     */
     getLargestPowerOfTwo(n) {
         return 2 ** Math.floor(Math.log2(n));
     }
-    /**
-     * 2의 거듭제곱 지수 계산
-     */
     getLargestPowerOfTwoExponent(n) {
         return Math.floor(Math.log2(n));
     }
-    /**
-     * 비트 길이 계산
-     */
     getBitLength(setLength) {
         return Math.ceil(Math.log2(setLength));
     }
-    /**
-     * Buffer를 DDU Binary 배열로 변환
-     */
     bufferToDduBinary(input, bitLength) {
         // 성능 최적화: reduce 대신 for loop + join 사용
         if (input.length === 0) {
@@ -56,9 +35,6 @@ export class BaseDdu {
         }
         return { dduBinary, padding };
     }
-    /**
-     * DDU Binary를 Buffer로 변환
-     */
     dduBinaryToBuffer(decodedBin, paddingBits) {
         if (paddingBits > 0) {
             decodedBin = decodedBin.slice(0, -paddingBits);

package/dist/mjs/encoders/Ddu64.d.ts

@@ -10,6 +10,7 @@ export declare class Ddu64 extends BaseDdu {
     protected readonly dduBinaryLookup: Map<string, number>;
     private readonly isPredefinedCharSet;
     private readonly effectiveBitLength;
+    private readonly maxBinaryValue;
     private readonly binaryChunkToIntFn;
     private readonly indexToBinaryCache;
     constructor(dduChar?: string[] | string, paddingChar?: string, dduOptions?: DduConstructorOptions);
@@ -17,5 +18,18 @@ export declare class Ddu64 extends BaseDdu {
     private getBinaryFromIndex;
     private validateCombinationDuplicates;
     encode(input: Buffer | string, _options?: DduOptions): string;
+    decodeToBuffer(input: string, _options?: DduOptions): Buffer;
     decode(input: string, _options?: DduOptions): string;
+    /**
+     * 테스트 및 디버깅용 getter 메서드
+     * 인코더의 내부 상태 정보를 반환
+     */
+    getCharSetInfo(): {
+        charSet: string[];
+        paddingChar: string;
+        charLength: number;
+        bitLength: number;
+        usePowerOfTwo: boolean;
+        encoding: BufferEncoding;
+    };
 }

package/dist/mjs/encoders/Ddu64.js

@@ -11,6 +11,7 @@ export class Ddu64 extends BaseDdu {
     dduBinaryLookup = new Map();
     isPredefinedCharSet;
     effectiveBitLength;
+    maxBinaryValue;
     binaryChunkToIntFn;
     indexToBinaryCache;
     constructor(dduChar, paddingChar, dduOptions) {
@@ -29,12 +30,23 @@ export class Ddu64 extends BaseDdu {
             const finalPadding = paddingChar ?? dduOptions?.paddingChar;
             if (finalDduChar) {
                 // 커스텀 charset
-                if (!finalPadding)
-                    throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
-                const arr = typeof finalDduChar === "string" ? [...new Set(finalDduChar.trim())] : finalDduChar;
+                if (!finalPadding) {
+                    throw new Error(`[Ddu64 Constructor] paddingChar is required when dduChar is provided. Received: dduChar=${typeof finalDduChar}, paddingChar=${finalPadding}`);
+                }
+                // 문자열을 배열로 변환 (중복 제거 없이)
+                const arr = typeof finalDduChar === "string" ? [...finalDduChar.trim()] : finalDduChar;
+                // 중복 검사 (useBuildErrorReturn이 true일 때만)
+                if (shouldThrowError) {
+                    const uniqueChars = new Set(arr);
+                    if (uniqueChars.size !== arr.length) {
+                        const duplicates = arr.filter((char, index) => arr.indexOf(char) !== index);
+                        throw new Error(`[Ddu64 Constructor] Character set contains duplicate characters. Total: ${arr.length}, Unique: ${uniqueChars.size}, Duplicates: [${[...new Set(duplicates)].join(', ')}]`);
+                    }
+                }
                 const len = dduOptions?.requiredLength ?? arr.length;
-                if (arr.length < len)
-                    throw new Error(`dduChar must be at least ${len} characters long. Provided: ${arr.length}`);
+                if (arr.length < len) {
+                    throw new Error(`[Ddu64 Constructor] Insufficient characters in charset. Required: ${len}, Provided: ${arr.length}`);
+                }
                 const usePow2 = dduOptions?.usePowerOfTwo === true || (dduOptions?.usePowerOfTwo === undefined && len > 0 && (len & (len - 1)) === 0);
                 if (usePow2) {
                     const exp = this.getLargestPowerOfTwoExponent(len);
@@ -79,22 +91,25 @@ export class Ddu64 extends BaseDdu {
         this.dduChar = normalized.charSet;
         this.paddingChar = normalized.padding;
         this.charLength = normalized.charLength;
-        this.bitLength = normalized.bitLength;
         this.isPredefinedCharSet = normalized.isPredefined;
         this.encoding = dduOptions?.encoding ?? this.defaultEncoding;
         const dduLength = this.dduChar.length;
+        const recalculatedBitLength = this.getBitLength(dduLength);
         this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
-        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : this.getBitLength(dduLength);
-        this.binaryChunkToIntFn = this.effectiveBitLength <= 26
-            ? (chunk) => chunk.split('').reduce((v, c) => (v << 1) | (c.charCodeAt(0) & 1), 0)
-            : (chunk) => chunk.split('').reduce((v, c) => v * 2 + (c.charCodeAt(0) & 1), 0);
+        this.bitLength = this.usePowerOfTwo
+            ? this.getLargestPowerOfTwoExponent(dduLength)
+            : recalculatedBitLength;
+        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : recalculatedBitLength;
+        this.maxBinaryValue = 2 ** this.effectiveBitLength;
+        // 성능 최적화: 단일 구현 사용 (벤치마크 결과 Method2가 더 빠르고 안정적)
+        // Method2는 32비트 이상에서도 오버플로우 없이 정확한 결과 제공
+        this.binaryChunkToIntFn = (chunk) => chunk.split('').reduce((v, c) => v * 2 + (c.charCodeAt(0) & 1), 0);
         this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
-        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+        if (this.charLength === 1 && !this.isPredefinedCharSet) {
             this.validateCombinationDuplicates(this.dduChar, this.paddingChar, dduLength);
         }
         if (this.effectiveBitLength <= 16) {
-            const size = 1 << this.effectiveBitLength;
-            this.indexToBinaryCache = Array.from({ length: size }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
+            this.indexToBinaryCache = Array.from({ length: this.maxBinaryValue }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
         }
         else {
             this.indexToBinaryCache = null;
@@ -118,49 +133,66 @@ export class Ddu64 extends BaseDdu {
             }
             return false;
         };
-        // 중복 제거 (커스텀 charset만)
-        if (!isPredefined) {
-            const uniqueChars = new Set(charSet);
-            if (uniqueChars.size !== charSet.length) {
-                if (shouldThrowError)
-                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${charSet.length}`);
-                charSet = Array.from(uniqueChars);
+        // 중복 제거 (모든 charset에 적용)
+        const uniqueChars = new Set(charSet);
+        if (uniqueChars.size !== charSet.length) {
+            const duplicates = charSet.filter((char, index) => charSet.indexOf(char) !== index);
+            const errorMsg = `[Ddu64 normalizeCharSet] Character set contains duplicate characters. Total: ${charSet.length}, Unique: ${uniqueChars.size}, Duplicates: [${[...new Set(duplicates)].join(', ')}]`;
+            if (shouldThrowError)
+                throw new Error(errorMsg);
+            // 중복 제거 후 계속 진행
+            charSet = Array.from(uniqueChars);
+            if (!isPredefined) {
                 requiredLength = charSet.length;
             }
         }
         // 검증
-        if (validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`)) {
+        if (validate(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters. Required: ${requiredLength}, Provided: ${charSet.length}`)) {
+            return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
+        }
+        if (validate(requiredLength < 2, `[Ddu64 normalizeCharSet] At least 2 unique characters are required. Provided: ${requiredLength}`)) {
+            return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
+        }
+        if (validate(bitLength <= 0, `[Ddu64 normalizeCharSet] Invalid bit length (${bitLength}) for charset size ${requiredLength}`)) {
             return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
         }
         let charLength = charSet[0]?.length ?? 0;
-        validate(charLength === 0, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+        validate(charLength === 0, `[Ddu64 normalizeCharSet] Empty charset. Required: ${requiredLength} characters`);
         const invalidIndex = charSet.findIndex(char => char.length !== charLength);
         if (invalidIndex !== -1) {
-            if (shouldThrowError)
-                throw new Error(`All characters must have the same length. Expected: ${charLength}, but index ${invalidIndex} has length ${charSet[invalidIndex].length}`);
+            if (shouldThrowError) {
+                throw new Error(`[Ddu64 normalizeCharSet] Inconsistent character length. Expected: ${charLength}, but character at index ${invalidIndex} ("${charSet[invalidIndex]}") has length ${charSet[invalidIndex].length}`);
+            }
             charSet = charSet.filter(char => char.length === charLength);
-            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            validate(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters after filtering. Required: ${requiredLength}, Remaining: ${charSet.length}`);
             charLength = charSet[0]?.length ?? 0;
         }
-        validate(!charSet.length, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: 0`);
-        validate(padding.length !== charLength, `Padding character must have length ${charLength}, got ${padding.length}`);
+        validate(!charSet.length, `[Ddu64 normalizeCharSet] Empty charset after validation`);
+        validate(padding.length !== charLength, `[Ddu64 normalizeCharSet] Padding character length mismatch. Expected: ${charLength}, Got: ${padding.length} (padding: "${padding}")`);
         if (new Set(charSet).has(padding)) {
-            if (shouldThrowError)
-                throw new Error(`Padding character "${padding}" cannot be in the character set`);
+            if (shouldThrowError) {
+                throw new Error(`[Ddu64 normalizeCharSet] Padding character "${padding}" conflicts with charset. Padding must not be in the character set.`);
+            }
             charSet = charSet.filter(char => char !== padding);
-            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            validate(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters after removing padding conflict. Required: ${requiredLength}, Remaining: ${charSet.length}`);
             charLength = charSet[0]?.length ?? 0;
         }
         return { charSet: charSet.slice(0, requiredLength), padding, requiredLength, bitLength, isPredefined, charLength };
     }
     getBinaryFromIndex(index) {
+        if (index < 0 || index >= this.maxBinaryValue) {
+            throw new Error(`[Ddu64] Binary index overflow. Received: ${index}, Allowed range: 0-${this.maxBinaryValue - 1}`);
+        }
         return this.indexToBinaryCache?.[index] ?? index.toString(2).padStart(this.effectiveBitLength, "0");
     }
     validateCombinationDuplicates(charSet, paddingChar, requiredLength) {
         const charLength = charSet[0].length;
+        // 조합 충돌 검사는 단일 문자 집합이면서 비교적 작은 경우(<=256)에만 적용한다.
+        if (charLength !== 1 || requiredLength > 256) {
+            return;
+        }
         const allStrings = new Set([...charSet.slice(0, requiredLength), paddingChar]);
         const limit = Math.min(charSet.length, requiredLength);
-        // 2개 조합 검사
         for (let i = 0; i < limit; i++) {
             for (let j = 0; j < limit; j++) {
                 const combo = charSet[i] + charSet[j];
@@ -170,32 +202,17 @@ export class Ddu64 extends BaseDdu {
             }
             const charPad = charSet[i] + paddingChar;
             const padChar = paddingChar + charSet[i];
-            if (allStrings.has(charPad))
+            if (allStrings.has(charPad)) {
                 throw new Error(`Combination conflict: "${charSet[i]}" + padding "${paddingChar}" = "${charPad}"`);
-            if (allStrings.has(padChar))
+            }
+            if (allStrings.has(padChar)) {
                 throw new Error(`Combination conflict: padding "${paddingChar}" + "${charSet[i]}" = "${padChar}"`);
+            }
         }
-        // 패딩 + 패딩 조합 검사
         const doublePad = paddingChar + paddingChar;
         if (allStrings.has(doublePad)) {
             throw new Error(`Combination conflict: double padding "${doublePad}" already exists`);
         }
-        // 3개 조합 검사 (100개 이하만)
-        if (charLength >= 2 && requiredLength <= 100) {
-            for (let i = 0; i < limit; i++) {
-                for (let j = 0; j < limit; j++) {
-                    for (let k = 0; k < limit; k++) {
-                        const combo = charSet[i] + charSet[j] + charSet[k];
-                        for (let start = 0; start <= combo.length - charLength; start++) {
-                            const sub = combo.substring(start, start + charLength);
-                            if (allStrings.has(sub) && sub !== charSet[i] && sub !== charSet[j] && sub !== charSet[k]) {
-                                throw new Error(`Combination conflict: substring "${sub}" from "${charSet[i]}" + "${charSet[j]}" + "${charSet[k]}"`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
     }
     encode(input, _options) {
         // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
@@ -210,8 +227,8 @@ export class Ddu64 extends BaseDdu {
         for (let i = 0; i < dduBinary.length; i++) {
             const binaryChunk = dduBinary[i];
             const charInt = this.binaryChunkToIntFn(binaryChunk);
-            if (this.charLength === 1 && !this.usePowerOfTwo) {
-                // 가변 길이 조합 인코딩
+            if (!this.usePowerOfTwo) {
+                // 가변 길이 조합 인코딩 (멀티바이트 문자도 지원)
                 const quotient = Math.floor(charInt / dduLength);
                 const remainder = charInt % dduLength;
                 resultParts[i] = this.dduChar[quotient] + this.dduChar[remainder];
@@ -228,44 +245,77 @@ export class Ddu64 extends BaseDdu {
         }
         return resultString;
     }
-    decode(input, _options) {
-        // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
-        // 패딩 정보 추출
+    decodeToBuffer(input, _options) {
         let paddingBits = 0;
-        const padCharIndex = input.indexOf(this.paddingChar);
-        if (padCharIndex >= 0) {
-            const paddingStr = input.substring(padCharIndex + this.paddingChar.length);
-            paddingBits = parseInt(paddingStr) || 0;
-            input = input.substring(0, padCharIndex);
+        if (input.length >= this.paddingChar.length) {
+            const padCharIndex = input.lastIndexOf(this.paddingChar);
+            if (padCharIndex >= 0 &&
+                padCharIndex % this.charLength === 0 &&
+                padCharIndex + this.paddingChar.length <= input.length) {
+                const paddingSection = input.slice(padCharIndex + this.paddingChar.length);
+                if (paddingSection.length === 0) {
+                    throw new Error(`[Ddu64 decode] Invalid padding format. Missing padding length after "${this.paddingChar}"`);
+                }
+                paddingBits = parseInt(paddingSection, 10);
+                if (isNaN(paddingBits) ||
+                    paddingSection !== paddingBits.toString() ||
+                    paddingBits < 0 ||
+                    paddingBits >= this.effectiveBitLength) {
+                    throw new Error(`[Ddu64 decode] Invalid padding format. Expected integer between 0 and ${this.effectiveBitLength - 1}, Got: "${paddingSection}"`);
+                }
+                input = input.substring(0, padCharIndex);
+            }
         }
         let dduBinary = "";
-        // 생성자에서 설정된 값 사용
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.effectiveBitLength;
-        if (this.charLength === 1 && !this.usePowerOfTwo) {
-            // 가변 길이 조합 디코딩 (2개씩 읽음)
-            for (let i = 0; i < input.length; i += 2) {
-                const firstChar = input[i];
-                const secondChar = input[i + 1];
+        if (!this.usePowerOfTwo) {
+            const chunkSize = this.charLength * 2;
+            for (let i = 0; i < input.length; i += chunkSize) {
+                const firstChar = input.slice(i, i + this.charLength);
+                const secondChar = input.slice(i + this.charLength, i + chunkSize);
                 const firstIndex = this.dduBinaryLookup.get(firstChar);
                 const secondIndex = this.dduBinaryLookup.get(secondChar);
-                if (firstIndex === undefined || secondIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
+                if (firstIndex === undefined || secondIndex === undefined) {
+                    const invalidChar = firstIndex === undefined ? firstChar : secondChar;
+                    throw new Error(`[Ddu64 decode] Invalid character in encoded string. Character: "${invalidChar}", Position: ${i}, Expected charset size: ${dduLength}`);
+                }
                 const value = firstIndex * dduLength + secondIndex;
+                if (value >= this.maxBinaryValue) {
+                    throw new Error(`[Ddu64 decode] Invalid character combination detected. Calculated value ${value} exceeds binary range ${this.maxBinaryValue - 1}.`);
+                }
                 dduBinary += this.getBinaryFromIndex(value);
             }
         }
         else {
-            // 고정 길이 직접 매핑 (charLength만큼씩 읽음)
             for (let i = 0; i < input.length; i += this.charLength) {
                 const charChunk = input.slice(i, i + this.charLength);
                 const charIndex = this.dduBinaryLookup.get(charChunk);
-                if (charIndex === undefined)
-                    throw new Error(`Invalid character: ${charChunk}`);
+                if (charIndex === undefined) {
+                    throw new Error(`[Ddu64 decode] Invalid character in encoded string. Character: "${charChunk}", Position: ${i}, Charset size: ${dduLength}, Character length: ${this.charLength}`);
+                }
+                if (charIndex >= this.maxBinaryValue) {
+                    throw new Error(`[Ddu64 decode] Invalid binary index ${charIndex}. Allowed range: 0-${this.maxBinaryValue - 1}`);
+                }
                 dduBinary += this.getBinaryFromIndex(charIndex);
             }
         }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);
-        return decoded.toString(this.encoding);
+        return this.dduBinaryToBuffer(dduBinary, paddingBits);
+    }
+    decode(input, _options) {
+        return this.decodeToBuffer(input, _options).toString(this.encoding);
+    }
+    /**
+     * 테스트 및 디버깅용 getter 메서드
+     * 인코더의 내부 상태 정보를 반환
+     */
+    getCharSetInfo() {
+        return {
+            charSet: [...this.dduChar],
+            paddingChar: this.paddingChar,
+            charLength: this.charLength,
+            bitLength: this.bitLength,
+            usePowerOfTwo: this.usePowerOfTwo,
+            encoding: this.encoding,
+        };
     }
 }

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@ddunigma/node",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && sh postProcess.sh",
-    "test": "NODE_OPTIONS='--expose-gc' tsx ./src/test/test-comprehensive.ts",
-    "test:no-gc": "tsx ./src/test/test-comprehensive.ts",
+    "test": "tsx ./src/test/test-quick.ts",
+    "test:comprehensive": "tsx ./src/test/test-comprehensive.ts",
+    "test:all": "tsx ./src/test/test-all-integrated.ts",
     "dev": "tsx ./src/test/test.ts"
   },
   "exports": {