@ddunigma/node 3.1.0 → 5.0.0

package/README.md

@@ -17,7 +17,7 @@ V2 추가사항
 
 ## Requirements
 
-- **Node.js >= 18.0.0**
+- **Node.js >= 22.0.0**
 
 ## Install
 
@@ -43,369 +43,195 @@ dduV1.decode(".우땨땨이?땨뜌.이.뜌이?이!.우우땨이?우뜌.우땨뜌
 
 ---
 
-## Binary Data
+## 5.0.0 사용법
+
+### 문자열과 바이너리
 
 ```typescript
+import { Ddu64 } from "@ddunigma/node";
+
 const ddu = new Ddu64();
-const input = new Uint8Array([0, 1, 127, 128, 255]);
 
-const encoded = ddu.encode(input);
-const bytes = ddu.decodeToUint8Array(encoded);
-const buffer = ddu.decodeToBuffer(encoded); // Node.js entry only
+const encodedText = ddu.encode("안녕하세요");
+const decodedText = ddu.decode(encodedText);
+
+const encodedBytes = ddu.encode(new Uint8Array([0, 1, 127, 128, 255]));
+const decodedBytes = ddu.decodeToUint8Array(encodedBytes);
+const decodedBuffer = ddu.decodeToBuffer(encodedBytes); // Node.js 전용
 ```
 
-## Presets
+### 프리셋
 
 ```typescript
 import { Ddu64, DduSetSymbol } from "@ddunigma/node";
 
-// 기본값 - 한글 종성 결합 64문자
-new Ddu64();
-
-// 구버전 호환 8문자 (아래 두 방법 모두 사용가능)
-new Ddu64({ dduSetSymbol: DduSetSymbol.DDU_V1 });
-new Ddu64(undefined, undefined, { dduSetSymbol: DduSetSymbol.DDU_V1 });
-
-// 영문+숫자 64문자 (아래 두 방법 모두 사용가능)
-new Ddu64({ dduSetSymbol: DduSetSymbol.ONECHARSET });
-new Ddu64(undefined, undefined, { dduSetSymbol: DduSetSymbol.ONECHARSET });
+const ddu = new Ddu64();
+const legacy = new Ddu64({ dduSetSymbol: DduSetSymbol.DDU_V1 });
+const oneCharset = new Ddu64({ dduSetSymbol: DduSetSymbol.ONECHARSET });
 ```
 
-| Symbol       | 문자 수 | 설명                               |
-| ------------ | ------: | ---------------------------------- |
-| `DDU`        |      64 | 한글 기본 문자 8개 × 종성 8개 조합 |
-| `DDU_V1`     |       8 | 기존 8문자 쌍 방식 (하위 호환)     |
-| `ONECHARSET` |      64 | 영문, 숫자, 일부 특수문자          |
-
-## Custom Charset
+### 커스텀 charset
 
 ```typescript
-// 문자열로 직접 지정
-const base64Like = new Ddu64(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-  "=",
-);
-
-// 한글 종성 조합으로 커스텀 charset 생성
-const hangulCoda = new Ddu64(["가", "나", "다", "라"], "뭐", {
+import { Ddu64 } from "@ddunigma/node";
+
+const base64 = new Ddu64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=");
+
+const hangul = new Ddu64(["가", "나", "다", "라"], "뭐", {
   codaChar: ["", "ㄱ", "ㄲ", "ㄷ"],
 });
-// → 가, 각, 갂, 갇, 나, 낙, 낚, 낟, 다, 닥, 닦, 닫, 라, 락, 랔, 랗 (16문자)
 ```
 
-## CharsetBuilder
-
-```typescript
-import { CharsetBuilder, Ddu64 } from "@ddunigma/node";
+charset 문자와 `paddingChar`는 각각 단일 UTF-16 코드 유닛이어야 합니다.
 
-// Base64에서 혼동 문자 제거 후 2의 제곱수로 맞추기
-const { charset, padding } = CharsetBuilder.base64()
-  .excludeConfusing()
-  .limitToPowerOfTwo()
-  .buildWithPadding();
+### 사용 가능한 옵션
 
-const ddu = new Ddu64(charset, padding);
+생성자 옵션은 인스턴스의 기본값으로 적용됩니다. `encode`, `decode`, `getStats` 계열 메서드에
+같은 옵션을 전달하면 해당 호출에서만 기본값을 덮어씁니다.
 
-// 유니코드 범위에서 생성
-const chars = CharsetBuilder.fromUnicodeRange(0x4e00, 0x4e3f)
-  .shuffle(12345)
-  .limitToPowerOfTwo()
-  .build();
-```
+#### 공통 옵션
 
-## Compression
+| 옵션                   | 타입                              | 기본값      | 용도                               |
+| ---------------------- | --------------------------------- | ----------- | ---------------------------------- |
+| `compress`             | `boolean`                         | `false`     | 압축 사용                          |
+| `compressionAlgorithm` | `"deflate" \| "brotli"`           | `"deflate"` | 압축 알고리즘                      |
+| `compressionLevel`     | `number`                          | `6`         | 압축 레벨                          |
+| `checksum`             | `boolean`                         | `false`     | CRC32 체크섬 추가 및 검증          |
+| `checksumScope`        | `"plaintext" \| "output"`         | `"output"`  | CRC32 계산 범위                    |
+| `chunkSize`            | `number`                          | 미사용      | 출력 문자열 분할 크기              |
+| `chunkSeparator`       | `string`                          | `"\n"`      | 청크 구분자                        |
+| `maxDecodedBytes`      | `number`                          | `67108864`  | 최대 디코딩 바이트 수              |
+| `maxDecompressedBytes` | `number`                          | `67108864`  | 최대 압축 해제 바이트 수           |
+| `obfuscate`            | `boolean`                         | `false`     | 암호화된 출력을 한글 음절로 난독화 |
+| `onProgress`           | `(info: DduProgressInfo) => void` | 미사용      | 처리 진행률 콜백                   |
 
-```typescript
-const ddu = new Ddu64({
-  compress: true, // 압축 활성화
-  compressionAlgorithm: "deflate", // "deflate" | "brotli"
-  compressionLevel: 6, // deflate: 0-9, brotli: 0-11
-});
+#### 생성자 전용 옵션
 
-const encoded = ddu.encode("A".repeat(1000)); // 압축되어 짧아짐
-const decoded = ddu.decode(encoded);
-```
+| 옵션               | 타입                   | 기본값      | 용도                                |
+| ------------------ | ---------------------- | ----------- | ----------------------------------- |
+| `dduSetSymbol`     | `DduSetSymbol`         | `DDU`       | 기본 charset 프리셋 선택            |
+| `dduChar`          | `string \| string[]`   | 프리셋 사용 | 커스텀 charset                      |
+| `codaChar`         | `string[]`             | 미사용      | 기본 문자와 조합할 한글 종성        |
+| `paddingChar`      | `string`               | 프리셋 사용 | 커스텀 패딩 문자                    |
+| `requiredLength`   | `number`               | `64`        | 필요한 charset 문자 수              |
+| `usePowerOfTwo`    | `boolean`              | 자동 결정   | 2의 제곱수 charset 직접 인덱스 모드 |
+| `useRepeatPadding` | `boolean`              | 프리셋 설정 | 반복 패딩 방식 사용                 |
+| `throwOnError`     | `boolean`              | `true`      | 잘못된 charset 설정에서 예외 발생   |
+| `urlSafe`          | `boolean`              | `false`     | URL-Safe 출력 변환                  |
+| `encryptionKey`    | `string`               | 미사용      | AES-256-GCM 암호화 키               |
+| `keyDerivation`    | `KeyDerivationOptions` | `pbkdf2`    | 암호화 키 파생 방식                 |
+| `adapter`          | `PlatformAdapter`      | 진입점 설정 | 플랫폼 어댑터 직접 주입             |
+| `wasmThreshold`    | `number`               | `16384`     | WASM 사용을 시작할 입력 크기        |
 
-압축은 원본보다 작아질 때만 적용됩니다. 압축 결과가 더 크면 비압축으로 저장됩니다.
-브라우저 진입점은 `deflate-raw`를 지원하는 CompressionStream/DecompressionStream 런타임에서 압축을 사용합니다.
-브라우저 Brotli는 런타임 지원 여부를 feature detection으로 확인하며, Web API 특성상 `compressionLevel`은 적용되지 않을 수 있습니다.
+`encoding`은 레거시 타입 호환을 위해서만 남아 있으며 런타임 문자열 처리는 항상 UTF-8입니다.
+`encrypt`와 `omitFooter`는 스트림 및 내부 파이프라인 제어용이므로 일반 사용에서는 지정하지 않습니다.
 
-## Encryption
+### 압축, 암호화, 체크섬
 
 ```typescript
-// SHA-256 키 파생 (기본)
+import { Ddu64 } from "@ddunigma/node";
+
 const ddu = new Ddu64({
+  compress: true,
+  compressionAlgorithm: "deflate",
+  compressionLevel: 6,
   encryptionKey: "my-secret-key",
-});
-
-const encoded = ddu.encode("secret message");
-const decoded = ddu.decode(encoded); // 같은 키로만 복호화 가능
-
-// PBKDF2 키 파생
-const dduPbkdf2 = new Ddu64({
-  encryptionKey: "user password",
   keyDerivation: {
     algorithm: "pbkdf2",
-    salt: "app-specific-salt",
+    salt: "my-application-salt",
     iterations: 210_000,
-    hash: "SHA-256",
   },
+  checksum: true,
 });
-```
 
-PBKDF2 `iterations`는 기본값이 `210_000`이며, `10_000` 미만의 양수는 `10_000`으로 보정됩니다.
-0 이하 또는 유한하지 않은 값은 기본값으로 대체됩니다.
+const encoded = ddu.encode("보호할 데이터");
+const decoded = ddu.decode(encoded);
+```
 
-## Checksum
+복호화할 때는 인코딩에 사용한 `encryptionKey`와 키 파생 설정을 동일하게 사용해야 합니다.
+체크섬을 호출별 옵션으로 사용한 경우 디코딩에도 `checksum: true`를 지정합니다.
 
 ```typescript
-const ddu = new Ddu64({ checksum: true });
-
-const encoded = ddu.encode("data"); // CRC32 체크섬 포함
-const decoded = ddu.decode(encoded); // 무결성 검증 후 반환
+const encoded = ddu.encode("data", { checksum: true });
+const decoded = ddu.decode(encoded, { checksum: true });
 ```
 
-## URL-Safe
+### URL-Safe와 청크 분할
 
 ```typescript
 const ddu = new Ddu64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=", {
   urlSafe: true,
-});
-
-// +→- /→_ =→. 로 자동 변환
-const encoded = ddu.encode("URL safe text");
-```
-
-## Chunking
-
-```typescript
-const ddu = new Ddu64({
   chunkSize: 76,
   chunkSeparator: "\n",
 });
 
-const encoded = ddu.encode("long data ".repeat(100));
-// 76자마다 줄바꿈 삽입
+const encoded = ddu.encode("long data");
+const decoded = ddu.decode(encoded);
 ```
 
-## Obfuscation (한글 난독화)
+### 한글 난독화
 
 ```typescript
 const ddu = new Ddu64({
-  encryptionKey: "secret",
-  obfuscate: true, // 암호화 필수
+  encryptionKey: "my-secret-key",
+  obfuscate: true,
 });
 
-const encoded = ddu.encode("hello");
-// 출력이 한글 음절 블록(U+AC00–U+D7A3)으로 변환됨
-```
-
-## Async (브라우저 호환)
-
-```typescript
-// 브라우저에서는 async 메서드 사용
-import { Ddu64 } from "@ddunigma/node/browser";
-
-const ddu = new Ddu64();
-const encoded = await ddu.encodeAsync("browser text");
-const decoded = await ddu.decodeAsync(encoded);
+const encoded = ddu.encode("secret");
+const decoded = ddu.decode(encoded);
 ```
 
-Node.js에서도 async 메서드를 사용할 수 있습니다. 브라우저 진입점(`@ddunigma/node/browser`)은 Node.js 내장 모듈을 임포트하지 않습니다.
-코어 진입점(`@ddunigma/node/core`)은 기본 인코딩/디코딩만 포함하며, 압축/암호화가 필요하면 명시적으로 어댑터를 전달하세요.
+난독화에는 암호화 키가 필요하며 `obfuscate: true`와 `encrypt: false`를 함께 사용할 수 없습니다.
 
-## Web Streams
+### 브라우저와 Workers
 
 ```typescript
-import { Ddu64, createReadableEncodeStream, createReadableDecodeStream } from "@ddunigma/node";
+import { Ddu64 } from "@ddunigma/node/browser";
 
 const ddu = new Ddu64({
   compress: true,
-  encryptionKey: "stream-key",
-});
-
-const encodedStream = readableByteStream.pipeThrough(
-  createReadableEncodeStream(ddu, { compress: true }),
-);
-
-const decodedStream = encodedStream.pipeThrough(createReadableDecodeStream(ddu));
-```
-
-## WASM Acceleration
-
-```typescript
-import { Ddu64, preloadWasm } from "@ddunigma/node";
-
-await preloadWasm(); // 동기 encode/decode hot path에서 WASM을 쓰려면 먼저 완료되어야 함
-
-const ddu = new Ddu64({
-  wasmThreshold: 4096, // 이 크기 이상일 때 WASM 사용
+  checksum: true,
 });
 
-const encoded = ddu.encode(new Uint8Array(1024 * 1024));
+const encoded = await ddu.encodeAsync("browser data");
+const decoded = await ddu.decodeAsync(encoded);
+const bytes = await ddu.decodeToUint8ArrayAsync(encoded);
 ```
 
-`encode()`/`decode()`의 동기 hot path는 이미 로드된 WASM만 사용합니다.
-`preloadWasm()`이 완료되지 않았거나 WASM을 사용할 수 없으면 JavaScript로 폴백됩니다.
+브라우저 압축은 실행 환경의 `CompressionStream`과 `DecompressionStream` 지원 여부에 따라 사용할 수
+있습니다.
 
-## Progress Callback
+### 인코딩 통계
 
 ```typescript
-const ddu = new Ddu64({ compress: true });
-
-ddu.encode("data", {
-  onProgress: ({ percent, stage }) => {
-    console.log(`${stage}: ${percent}%`);
-    // stage: start → compress → encrypt → encode → done
-  },
-});
+const stats = ddu.getStats("payload");
+const asyncStats = await ddu.getStatsAsync("payload", { compress: true });
 ```
 
-## Stats
+브라우저에서 압축 통계를 계산할 때는 `getStatsAsync`를 사용합니다.
 
-```typescript
-const ddu = new Ddu64({ compress: true });
-const stats = ddu.getStats("A".repeat(1000));
+### WASM 가속
 
-// { originalSize, encodedSize, compressedSize, compressionRatio, expansionRatio, charsetSize, bitLength }
-```
+```typescript
+import { Ddu64, preloadWasm } from "@ddunigma/node";
 
-## Size Limits
+await preloadWasm();
 
-```typescript
 const ddu = new Ddu64({
-  maxDecodedBytes: 10 * 1024 * 1024, // 디코딩 최대 크기 (기본 64MB)
-  maxDecompressedBytes: 50 * 1024 * 1024, // 압축해제 최대 크기 (기본 64MB)
+  wasmThreshold: 16 * 1024,
 });
 ```
 
----
+`wasmThreshold: Infinity`를 지정하면 WASM 사용을 비활성화할 수 있습니다.
 
-## API
-
-### Node Entry
+### 진입점
 
 ```typescript
-class Ddu64 {
-  encode(data: string | Uint8Array, options?: DduOptions): string;
-  decode(encoded: string, options?: DduOptions): string;
-  decodeToUint8Array(encoded: string, options?: DduOptions): Uint8Array;
-  decodeToBuffer(encoded: string, options?: DduOptions): Buffer;
-
-  encodeAsync(data: string | Uint8Array, options?: DduOptions): Promise<string>;
-  decodeAsync(encoded: string, options?: DduOptions): Promise<string>;
-  decodeToUint8ArrayAsync(encoded: string, options?: DduOptions): Promise<Uint8Array>;
-  decodeToBufferAsync(encoded: string, options?: DduOptions): Promise<Buffer>;
-
-  getStats(data: string | Uint8Array, options?: DduOptions): DduEncodeStats;
-  getCharSetInfo(): CharSetInfo;
-}
-```
-
-### Browser Entry
+import { Ddu64 as NodeDdu64 } from "@ddunigma/node";
+import { Ddu64 as BrowserDdu64 } from "@ddunigma/node/browser";
+import { Ddu64 as CoreDdu64 } from "@ddunigma/node/core";
 
-```typescript
-class Ddu64 {
-  encode(data: string | Uint8Array, options?: DduOptions): string;
-  decode(encoded: string, options?: DduOptions): string;
-  decodeToUint8Array(encoded: string, options?: DduOptions): Uint8Array;
-
-  encodeAsync(data: string | Uint8Array, options?: DduOptions): Promise<string>;
-  decodeAsync(encoded: string, options?: DduOptions): Promise<string>;
-  decodeToUint8ArrayAsync(encoded: string, options?: DduOptions): Promise<Uint8Array>;
-
-  getStats(data: string | Uint8Array, options?: DduOptions): DduEncodeStats;
-  getCharSetInfo(): CharSetInfo;
-}
+const nodeEncoder = new NodeDdu64();
+const browserEncoder = new BrowserDdu64();
+const coreEncoder = new CoreDdu64();
 ```
-
-브라우저 진입점(`@ddunigma/node/browser`)은 `Buffer` API를 노출하지 않습니다.
-
-### Core Entry
-
-```typescript
-class Ddu64 {
-  encode(data: string | Uint8Array, options?: DduOptions): string;
-  decode(encoded: string, options?: DduOptions): string;
-  decodeToUint8Array(encoded: string, options?: DduOptions): Uint8Array;
-
-  encodeAsync(data: string | Uint8Array, options?: DduOptions): Promise<string>;
-  decodeAsync(encoded: string, options?: DduOptions): Promise<string>;
-  decodeToUint8ArrayAsync(encoded: string, options?: DduOptions): Promise<Uint8Array>;
-
-  getStats(data: string | Uint8Array, options?: DduOptions): DduEncodeStats;
-  getCharSetInfo(): CharSetInfo;
-}
-```
-
-코어 진입점(`@ddunigma/node/core`)은 플랫폼 어댑터를 자동 로드하지 않습니다.
-압축 또는 암호화가 필요한 async 호출에는 `adapter`를 명시적으로 전달하세요.
-
-## Constructor Options
-
-```typescript
-// 옵션만 전달 (권장)
-new Ddu64(options?);
-
-// charset 직접 지정
-new Ddu64(dduChar, paddingChar, options?);
-```
-
-| Option                 | Type                    | Default     | 설명                  |
-| ---------------------- | ----------------------- | ----------- | --------------------- |
-| `dduSetSymbol`         | `DduSetSymbol`          | `DDU`       | 프리셋 선택           |
-| `dduChar`              | `string \| string[]`    | -           | 커스텀 charset        |
-| `paddingChar`          | `string`                | -           | 패딩 문자             |
-| `codaChar`             | `string[]`              | -           | 종성 조합 문자        |
-| `compress`             | `boolean`               | `false`     | 압축 활성화           |
-| `compressionAlgorithm` | `"deflate" \| "brotli"` | `"deflate"` | 압축 알고리즘         |
-| `compressionLevel`     | `number`                | `6`         | 압축 레벨             |
-| `encryptionKey`        | `string`                | -           | AES-256-GCM 암호화 키 |
-| `keyDerivation`        | `KeyDerivationOptions`  | `sha256`    | 키 파생 방식          |
-| `checksum`             | `boolean`               | `false`     | CRC32 체크섬          |
-| `urlSafe`              | `boolean`               | `false`     | URL-Safe 변환         |
-| `obfuscate`            | `boolean`               | `false`     | 한글 난독화           |
-| `chunkSize`            | `number`                | -           | 청크 분할 크기        |
-| `chunkSeparator`       | `string`                | `"\n"`      | 청크 구분자           |
-| `maxDecodedBytes`      | `number`                | `67108864`  | 디코딩 크기 제한      |
-| `maxDecompressedBytes` | `number`                | `67108864`  | 압축해제 크기 제한    |
-| `wasmThreshold`        | `number`                | `4096`      | WASM 사용 임계값      |
-| `throwOnError`         | `boolean`               | `false`     | 초기화 에러 시 throw  |
-
-## Per-Call Options
-
-`encode`, `decode`, `encodeAsync`, `decodeAsync` 등에서 호출별로 오버라이드 가능:
-
-| Option                 | Type                    | 설명               |
-| ---------------------- | ----------------------- | ------------------ |
-| `compress`             | `boolean`               | 압축 사용 여부     |
-| `compressionAlgorithm` | `"deflate" \| "brotli"` | 압축 알고리즘      |
-| `compressionLevel`     | `number`                | 압축 레벨          |
-| `encrypt`              | `boolean`               | 암호화 사용 여부   |
-| `checksum`             | `boolean`               | 체크섬 사용 여부   |
-| `obfuscate`            | `boolean`               | 난독화 사용 여부   |
-| `chunkSize`            | `number`                | 청크 크기          |
-| `maxDecodedBytes`      | `number`                | 디코딩 크기 제한   |
-| `maxDecompressedBytes` | `number`                | 압축해제 크기 제한 |
-| `onProgress`           | `(info) => void`        | 진행률 콜백        |
-
-## Entry Points
-
-| Import Path              | 용도                                  |
-| ------------------------ | ------------------------------------- |
-| `@ddunigma/node`         | Node.js 전체 기능 (동기+비동기)       |
-| `@ddunigma/node/browser` | 브라우저 최적화 (BrowserAdapter 기본) |
-| `@ddunigma/node/core`    | 최소 코어 (인코딩/디코딩만)           |
-
-## Build & Test
-
-```bash
-pnpm test
-pnpm build
-pnpm lint
-pnpm bench
-```
-
-## License
-
-BSD-2-Clause

package/dist/BrowserAdapter-HORDDCOE.js

@@ -0,0 +1,2 @@
+export{a as BrowserAdapter}from'./chunk-CQATQOBZ.js';import'./chunk-OQXMQIE3.js';//# sourceMappingURL=BrowserAdapter-HORDDCOE.js.map
+//# sourceMappingURL=BrowserAdapter-HORDDCOE.js.map

package/dist/BrowserAdapter-PB4J6FHX.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkAMOZHHMB_cjs=require('./chunk-AMOZHHMB.cjs');require('./chunk-5NSHXTMN.cjs');Object.defineProperty(exports,"BrowserAdapter",{enumerable:true,get:function(){return chunkAMOZHHMB_cjs.a}});//# sourceMappingURL=BrowserAdapter-PB4J6FHX.cjs.map
+//# sourceMappingURL=BrowserAdapter-PB4J6FHX.cjs.map

package/dist/NodeAdapter-5FBNCJSG.js

@@ -0,0 +1,2 @@
+export{a as NodeAdapter}from'./chunk-7RWUNW5S.js';import'./chunk-OQXMQIE3.js';//# sourceMappingURL=NodeAdapter-5FBNCJSG.js.map
+//# sourceMappingURL=NodeAdapter-5FBNCJSG.js.map

package/dist/NodeAdapter-EQ73FGEJ.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkHZJ7PU7X_cjs=require('./chunk-HZJ7PU7X.cjs');require('./chunk-5NSHXTMN.cjs');Object.defineProperty(exports,"NodeAdapter",{enumerable:true,get:function(){return chunkHZJ7PU7X_cjs.a}});//# sourceMappingURL=NodeAdapter-EQ73FGEJ.cjs.map
+//# sourceMappingURL=NodeAdapter-EQ73FGEJ.cjs.map

package/dist/{ObfuscationLayer-D-xl5d7P.d.ts → ObfuscationLayer-BDr-0s1M.d.ts}

@@ -1,4 +1,4 @@
-import { P as PlatformAdapter, i as KeyDerivationOptions, D as Ddu64Core, e as DduOptions, O as ObfuscationLayer } from './core-DYSnygnp.js';
+import { P as PlatformAdapter, y as KeyDerivationOptions, D as Ddu64Core, u as DduOptions, O as ObfuscationLayer } from './errors-DNICpo4L.js';
 
 /**
  * 브라우저 플랫폼 어댑터 구현.
@@ -21,8 +21,9 @@ import { P as PlatformAdapter, i as KeyDerivationOptions, D as Ddu64Core, e as D
 declare class BrowserAdapter implements PlatformAdapter {
     readonly supportsSyncCrypto = false;
     readonly supportsSyncCompression = false;
-    readonly supportsBrotli: boolean;
-    readonly runtime: "browser";
+    readonly runtime: "browser" | "edge" | "deno" | "bun";
+    constructor(runtime?: "browser" | "edge" | "deno" | "bun");
+    get supportsBrotli(): boolean;
     /**
      * UTF-8 키 문자열에서 SHA-256을 통해 256비트 키를 파생합니다.
      * UTF-8 인코딩된 키에 SubtleCrypto.digest('SHA-256', ...)를 사용합니다.
@@ -35,13 +36,13 @@ declare class BrowserAdapter implements PlatformAdapter {
      * 참고: Web Crypto는 authTag를 암호문에 추가하므로,
      * 마지막 16바이트를 authTag로 추출하고 와이어 포맷에 맞게 재배치합니다.
      */
-    encrypt(data: Uint8Array, keyHash: Uint8Array): Promise<Uint8Array>;
+    encrypt(data: Uint8Array, keyHash: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
     /**
      * AES-256-GCM 페이로드를 복호화합니다.
      * 와이어 포맷 기대: IV(12바이트) + authTag(16바이트) + 암호문.
      * 복호화 전에 Web Crypto 형식(암호문 + authTag)으로 재구성합니다.
      */
-    decrypt(data: Uint8Array, keyHash: Uint8Array): Promise<Uint8Array>;
+    decrypt(data: Uint8Array, keyHash: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
     /**
      * 암호학적으로 안전한 랜덤 바이트를 생성합니다.
      */
@@ -97,8 +98,8 @@ declare function detectRuntime(): RuntimeId;
  * 모든 최신 브라우저와 Node.js에서 사용 가능합니다.
  *
  * 스트리밍 모드:
- * - 압축/암호화/체크섬 비활성화 + 2의 제곱수 charset: 진정한 청크 단위 스트리밍
- * - 그 외: 전체 축적 후 일괄 처리 (알고리즘/와이어 포맷 제약)
+ * - 인코딩: 압축/암호화/체크섬 비활성화 + 2의 제곱수 charset에서 청크 단위 출력
+ * - 디코딩: footer의 압축/암호화 마커를 최종 신뢰하기 위해 payload를 축적 후 처리
  *
  * 스트림 헤더 형식: [pad]DDS1[D|B|N][1|0][pad]
  * D=deflate, B=brotli, N=없음 (압축), 1/0 (암호화).
@@ -122,11 +123,8 @@ declare function createReadableEncodeStream(encoder: Ddu64Core, options?: DduOpt
  * charset 인코딩 문자열을 바이너리 데이터로 역변환하는
  * Web Streams API TransformStream을 생성합니다.
  *
- * 스트림은 DDS1 스트림 헤더를 파싱하여 압축 및 암호화 설정을 감지한 후
- * 페이로드를 그에 맞게 디코딩합니다.
- *
- * 압축/암호화/체크섬이 없고 charset이 2의 제곱수인 스트림은 헤더 파싱 후 각 청크를 즉시 디코딩합니다.
- * 그 외에는 전체 페이로드를 축적 후 일괄 디코딩합니다.
+ * 스트림은 DDS1 스트림 헤더를 조기 검증하되, 헤더만으로 복호화/압축해제를 비활성화하지 않습니다.
+ * footer가 최종 wire metadata이므로 전체 페이로드를 축적 후 일괄 디코딩합니다.
  *
  * @param encoder - 디코딩에 사용할 Ddu64Core 인스턴스
  * @param options - 디코딩 옵션
@@ -193,13 +191,31 @@ declare class HangulObfuscationLayer implements ObfuscationLayer {
 /**
  * 주어진 charset 설정에 대한 ObfuscationLayer를 생성합니다.
  *
- * charset 문자와 패딩 문자로부터 완전한 알파벳을 구성한 후
- * 한글 난독화 레이어를 생성합니다.
+ * @deprecated 인코더 출력과 호환되지 않습니다(charset/패딩만 포함, footer 마커·숫자 미포함).
+ * 인코더 출력을 deobfuscate하려면 `createEncoderObfuscationLayer`를, 일반 난독화는 `Ddu64`의
+ * `obfuscate` 옵션을 사용하세요. 이 함수는 다음 메이저에서 제거될 수 있습니다.
+ *
+ * charset 문자와 패딩 문자로부터 알파벳을 구성한 후 한글 난독화 레이어를 생성합니다.
  *
  * @param charSet - 인코딩에 사용되는 charset 문자
  * @param paddingChar - 패딩 문자
  * @returns ObfuscationLayer 인스턴스
  */
 declare function createObfuscationLayer(charSet: string[], paddingChar: string): ObfuscationLayer;
+/**
+ * Ddu64 인코더 출력과 호환되는 ObfuscationLayer를 생성합니다.
+ *
+ * `createObfuscationLayer`와 달리 charset/패딩 외에 footer 마커
+ * (ELYSIA/GRISEO/ENC/V3/V4)와 숫자(0-9)까지 알파벳에 포함하므로, 압축/암호화/파이프라인
+ * 마커가 붙은 실제 인코더 출력도 안전하게 deobfuscate할 수 있습니다.
+ *
+ * 일반적으로는 `Ddu64`의 `obfuscate` 옵션을 쓰는 것으로 충분하며, 이 헬퍼는 인코더와
+ * 동일한 난독화 매핑을 외부에서 재현해야 할 때 사용합니다.
+ *
+ * @param charSet - 인코딩에 사용되는 charset 문자
+ * @param paddingChar - 패딩 문자
+ * @returns 인코더 호환 ObfuscationLayer 인스턴스
+ */
+declare function createEncoderObfuscationLayer(charSet: string[], paddingChar: string): ObfuscationLayer;
 
-export { BrowserAdapter as B, HangulObfuscationLayer as H, createReadableDecodeStream as a, createReadableEncodeStream as b, createObfuscationLayer as c, detectRuntime as d };
+export { BrowserAdapter as B, HangulObfuscationLayer as H, createObfuscationLayer as a, createReadableDecodeStream as b, createEncoderObfuscationLayer as c, createReadableEncodeStream as d, detectRuntime as e };