@simplysm/sd-claude 14.0.47 → 14.0.49

package/claude/references/sd-simplysm14/core-browser/usage.md

@@ -1,306 +0,0 @@
-# @simplysm/core-browser
-
-브라우저 전용 유틸리티 패키지. DOM 프로토타입 확장, 파일 다운로드/업로드, HTTP fetch, IndexedDB 추상화를 제공한다.
-
-## Installation
-
-```bash
-npm install @simplysm/core-browser
-```
-
-## API Overview
-
-### Extensions
-
-사이드 이펙트 모듈로, 패키지를 임포트하면 자동으로 `Element`와 `HTMLElement` 프로토타입에 메서드가 추가된다.
-
-| API | Type | Description |
-|-----|------|-------------|
-| `ElementBounds` | interface | 요소 경계 정보 (target, top, left, width, height) |
-| `copyElement` | function | copy 이벤트 핸들러에서 요소 내 input/textarea 값을 클립보드에 복사 |
-| `pasteToElement` | function | paste 이벤트 핸들러에서 클립보드 텍스트를 요소 내 input/textarea에 붙여넣기 |
-| `getBounds` | function | IntersectionObserver로 여러 요소의 경계 정보를 비동기 조회 |
-| `Element.prototype.findAll` | prototype extension | 선택자와 일치하는 모든 하위 요소 검색 |
-| `Element.prototype.findFirst` | prototype extension | 선택자와 일치하는 첫 번째 요소 검색 |
-| `Element.prototype.prependChild` | prototype extension | 요소를 첫 번째 자식으로 삽입 |
-| `Element.prototype.getParents` | prototype extension | 모든 부모 요소를 가까운 순서로 조회 |
-| `Element.prototype.findTabbableParent` | prototype extension | 첫 번째 탭 이동 가능한 부모 요소 검색 (tabbable 사용) |
-| `Element.prototype.findFirstTabbableChild` | prototype extension | 첫 번째 탭 이동 가능한 자식 요소 검색 (tabbable 사용) |
-| `Element.prototype.isOffsetElement` | prototype extension | position이 relative/absolute/fixed/sticky인지 확인 |
-| `Element.prototype.isVisible` | prototype extension | 요소가 화면에 보이는지 확인 (clientRects, visibility, opacity) |
-| `HTMLElement.prototype.repaint` | prototype extension | 강제 리페인트 트리거 (offsetHeight 접근) |
-| `HTMLElement.prototype.getRelativeOffset` | prototype extension | 부모 요소 기준 상대 위치 계산 (CSS top/left 용) |
-| `HTMLElement.prototype.scrollIntoViewIfNeeded` | prototype extension | offset 영역에 가려진 경우 대상이 보이도록 스크롤 |
-
-#### `ElementBounds`
-
-```typescript
-export interface ElementBounds {
-  target: Element;
-  top: number;
-  left: number;
-  width: number;
-  height: number;
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `target` | `Element` | 측정 대상 요소 |
-| `top` | `number` | 뷰포트 기준 상단 위치 |
-| `left` | `number` | 뷰포트 기준 좌측 위치 |
-| `width` | `number` | 요소 너비 |
-| `height` | `number` | 요소 높이 |
-
-#### `copyElement`
-
-```typescript
-export function copyElement(event: ClipboardEvent): void
-```
-
-copy 이벤트 핸들러와 함께 사용한다. 이벤트 타겟 요소 내의 첫 번째 `input` 또는 `textarea`를 찾아 그 값을 클립보드에 설정한다. 해당 요소가 없으면 아무 동작도 하지 않는다.
-
-#### `pasteToElement`
-
-```typescript
-export function pasteToElement(event: ClipboardEvent): void
-```
-
-paste 이벤트 핸들러와 함께 사용한다. 이벤트 타겟 요소 내의 첫 번째 `input` 또는 `textarea`를 찾아 값 전체를 클립보드 텍스트로 교체한다. 커서 위치나 선택 영역은 고려하지 않는다. `input` 이벤트를 dispatch한다.
-
-#### `getBounds`
-
-```typescript
-export async function getBounds(els: Element[], timeout?: number): Promise<ElementBounds[]>
-```
-
-IntersectionObserver를 사용하여 여러 요소의 경계 정보를 비동기로 조회한다. 중복 요소는 자동 제거되며, 입력 순서대로 결과가 정렬된다. `timeout` 기본값은 5000ms이며, 시간 내에 응답이 없으면 `TimeoutError`를 던진다.
-
-#### Element Prototype Extensions
-
-`Element.prototype`에 추가되는 메서드들:
-
-```typescript
-// 선택자와 일치하는 모든 하위 요소 검색 (빈 선택자 -> 빈 배열)
-element.findAll<TEl extends Element = Element>(selector: string): TEl[]
-
-// 선택자와 일치하는 첫 번째 요소 (빈 선택자 -> undefined)
-element.findFirst<TEl extends Element = Element>(selector: string): TEl | undefined
-
-// 요소를 첫 번째 자식으로 삽입
-element.prependChild<TEl extends Element>(child: TEl): TEl
-
-// 모든 부모 요소 배열 (가까운 순서)
-element.getParents(): Element[]
-
-// 첫 번째 탭 이동 가능한 부모 요소 (tabbable 라이브러리 사용)
-element.findTabbableParent(): HTMLElement | undefined
-
-// 첫 번째 탭 이동 가능한 자식 요소 (tabbable 라이브러리 사용)
-element.findFirstTabbableChild(): HTMLElement | undefined
-
-// position이 relative/absolute/fixed/sticky인지 확인
-element.isOffsetElement(): boolean
-
-// 화면에 보이는지 확인 (clientRects, visibility, opacity)
-element.isVisible(): boolean
-```
-
-#### HTMLElement Prototype Extensions
-
-`HTMLElement.prototype`에 추가되는 메서드들:
-
-```typescript
-// 강제 리페인트 (offsetHeight 접근으로 reflow 트리거)
-htmlElement.repaint(): void
-
-// 부모 요소 기준 상대 위치 계산 (CSS top/left에 사용 가능)
-// parent: HTMLElement 또는 CSS 선택자 문자열
-// border 두께, CSS transform 변환 포함
-// 부모를 찾을 수 없으면 ArgumentError throw
-htmlElement.getRelativeOffset(parent: HTMLElement | string): { top: number; left: number }
-
-// offset 영역에 가려진 경우 스크롤 조정
-// target: 컨테이너 내 대상 위치 (offsetTop, offsetLeft)
-// offset: 가려지면 안 되는 영역 크기 (기본값 { top: 0, left: 0 })
-// 상단/좌측 방향만 처리, 하단/우측은 브라우저 기본 동작에 의존
-htmlElement.scrollIntoViewIfNeeded(
-  target: { top: number; left: number },
-  offset?: { top: number; left: number }
-): void
-```
-
-### Utils
-
-| API | Type | Description |
-|-----|------|-------------|
-| `downloadBlob` | function | Blob을 파일로 다운로드 (링크 클릭 방식) |
-| `DownloadProgress` | interface | 다운로드 진행 정보 (receivedLength, contentLength) |
-| `fetchUrlBytes` | function | URL에서 Uint8Array 다운로드 (진행 콜백 지원) |
-| `openFileDialog` | function | 파일 선택 대화상자를 프로그래밍 방식으로 열기 |
-| `StoreConfig` | interface | IndexedDbStore 스토어 설정 (name, keyPath) |
-| `IndexedDbStore` | class | IndexedDB를 Promise 기반으로 래핑한 저수준 CRUD 클래스 |
-| `VirtualFsEntry` | interface | 가상 파일시스템 엔트리 (kind, dataBase64) |
-| `IndexedDbVirtualFs` | class | IndexedDB 기반 경로 기반 가상 파일시스템 |
-
-#### `downloadBlob`
-
-```typescript
-export function downloadBlob(blob: Blob, fileName: string): void
-```
-
-Blob을 파일로 다운로드한다. `<a>` 태그를 생성하여 클릭하는 방식이다. Object URL은 1초 후 자동 해제된다.
-
-#### `DownloadProgress`
-
-```typescript
-export interface DownloadProgress {
-  receivedLength: number;
-  contentLength: number;
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `receivedLength` | `number` | 현재까지 수신한 바이트 수 |
-| `contentLength` | `number` | 전체 콘텐츠 길이 (Content-Length 헤더 값) |
-
-#### `fetchUrlBytes`
-
-```typescript
-export async function fetchUrlBytes(
-  url: string,
-  options?: { onProgress?: (progress: DownloadProgress) => void },
-): Promise<Uint8Array>
-```
-
-URL에서 바이너리 데이터를 `Uint8Array`로 다운로드한다. `Content-Length` 헤더가 있으면 사전 할당으로 메모리 효율을 높이고, 없으면 청크 수집 후 `bytes.concat`으로 병합한다. 진행 콜백은 `options.onProgress`로 수신한다. 응답이 실패하면 Error를 던진다.
-
-#### `openFileDialog`
-
-```typescript
-export function openFileDialog(options?: {
-  accept?: string;
-  multiple?: boolean;
-}): Promise<File[] | undefined>
-```
-
-프로그래밍 방식으로 파일 선택 대화상자를 연다. `accept`로 파일 형식 필터, `multiple`로 다중 선택 여부를 지정한다. 파일 선택 시 `File[]` 반환, 취소 시 `undefined` 반환.
-
-#### `StoreConfig`
-
-```typescript
-export interface StoreConfig {
-  name: string;
-  keyPath: string;
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `name` | `string` | object store 이름 |
-| `keyPath` | `string` | 기본 키 경로 |
-
-#### `IndexedDbStore`
-
-```typescript
-export class IndexedDbStore {
-  constructor(dbName: string, dbVersion: number, storeConfigs: StoreConfig[])
-
-  open(): Promise<IDBDatabase>
-  withStore<TResult>(storeName: string, mode: IDBTransactionMode, fn: (store: IDBObjectStore) => Promise<TResult>): Promise<TResult>
-  get<TValue>(storeName: string, key: IDBValidKey): Promise<TValue | undefined>
-  put(storeName: string, value: unknown): Promise<void>
-  delete(storeName: string, key: IDBValidKey): Promise<void>
-  getAll<TItem>(storeName: string): Promise<TItem[]>
-  close(): void
-}
-```
-
-IndexedDB를 Promise 기반으로 래핑한 저수준 클래스. 생성자에서 DB 이름, 버전, 스토어 설정을 받는다.
-
-| Method | Description |
-|--------|-------------|
-| `open()` | DB 연결을 열고 `IDBDatabase`를 반환. 중복 호출에 안전 (이미 열려 있으면 기존 인스턴스 반환) |
-| `withStore(storeName, mode, fn)` | 지정 스토어에서 트랜잭션을 열고 `fn`을 실행. fn이 에러를 던지면 트랜잭션을 abort한다 |
-| `get(storeName, key)` | 키로 단일 항목 조회. 없으면 `undefined` |
-| `put(storeName, value)` | 항목 추가/갱신 (keyPath에 해당하는 필드가 value에 포함되어야 함) |
-| `delete(storeName, key)` | 키로 항목 삭제 |
-| `getAll(storeName)` | 스토어의 모든 항목 조회 |
-| `close()` | DB 연결 닫기 |
-
-#### `VirtualFsEntry`
-
-```typescript
-export interface VirtualFsEntry {
-  kind: "file" | "dir";
-  dataBase64?: string;
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `kind` | `"file" \| "dir"` | 엔트리 종류 (파일 또는 디렉토리) |
-| `dataBase64` | `string \| undefined` | 파일 데이터 (Base64 인코딩, 디렉토리인 경우 없음) |
-
-#### `IndexedDbVirtualFs`
-
-```typescript
-export class IndexedDbVirtualFs {
-  constructor(db: IndexedDbStore, storeName: string, keyField: string)
-
-  getEntry(fullKey: string): Promise<VirtualFsEntry | undefined>
-  putEntry(fullKey: string, kind: "file" | "dir", dataBase64?: string): Promise<void>
-  deleteByPrefix(keyPrefix: string): Promise<boolean>
-  listChildren(prefix: string): Promise<{ name: string; isDirectory: boolean }[]>
-  ensureDir(fullKeyBuilder: (path: string) => string, dirPath: string): Promise<void>
-}
-```
-
-`IndexedDbStore` 위에 경로 기반 가상 파일시스템을 구현하는 클래스. 키는 `/path/to/file` 형태의 문자열.
-
-| Method | Description |
-|--------|-------------|
-| `getEntry(fullKey)` | 경로에 해당하는 엔트리 조회. 없으면 `undefined` |
-| `putEntry(fullKey, kind, dataBase64?)` | 엔트리 추가/갱신. `kind`는 `"file"` 또는 `"dir"` |
-| `deleteByPrefix(keyPrefix)` | 접두사와 일치하는 모든 엔트리 삭제. 삭제된 항목이 있으면 `true` |
-| `listChildren(prefix)` | 접두사 바로 아래 자식 목록 반환. 이름과 디렉토리 여부 포함 |
-| `ensureDir(fullKeyBuilder, dirPath)` | 경로의 모든 중간 디렉토리를 재귀적으로 생성. 이미 있으면 건너뜀 |
-
-## Usage Examples
-
-### Blob 파일 다운로드
-
-```typescript
-import { downloadBlob } from "@simplysm/core-browser";
-
-const data = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
-const blob = new Blob([data], { type: "application/octet-stream" });
-downloadBlob(blob, "output.bin");
-```
-
-### IndexedDB CRUD
-
-```typescript
-import { IndexedDbStore } from "@simplysm/core-browser";
-
-const store = new IndexedDbStore("myDb", 1, [{ name: "items", keyPath: "id" }]);
-
-await store.put("items", { id: "key1", value: "hello" });
-const item = await store.get<{ id: string; value: string }>("items", "key1");
-const all = await store.getAll<{ id: string; value: string }>("items");
-await store.delete("items", "key1");
-store.close();
-```
-
-### DOM 프로토타입 확장 사용
-
-```typescript
-import "@simplysm/core-browser";
-
-const container = document.querySelector(".container")!;
-const buttons = container.findAll<HTMLButtonElement>("button");
-const firstInput = container.findFirst<HTMLInputElement>("input[type=text]");
-const parents = container.getParents();
-const focusable = container.findFirstTabbableChild();
-```

package/claude/references/sd-simplysm14/core-common/docs/errors.md

@@ -1,82 +0,0 @@
-# Errors
-
-## `SdError`
-
-트리 구조 에러 체인을 지원하는 에러 클래스. ES2024 `cause` 속성을 활용한다.
-
-```typescript
-export class SdError extends Error {
-  override cause?: Error;
-
-  /** 원인 에러를 감싸서 생성. 메시지는 역순으로 결합됨 */
-  constructor(cause: Error, ...messages: string[]);
-  /** 메시지만으로 생성 */
-  constructor(...messages: string[]);
-}
-```
-
-생성자에 전달된 메시지들은 역순으로 결합된다. `cause`가 `Error` 인스턴스이면 그 메시지도 체인 끝에 추가된다.
-
-```typescript
-throw new SdError(err, "API 호출 실패", "사용자 로드 실패");
-// message: "사용자 로드 실패 => API 호출 실패 => 원본 에러 메시지"
-
-throw new SdError("잘못된 상태", "처리 불가");
-// message: "처리 불가 => 잘못된 상태"
-```
-
-## `ArgumentError`
-
-유효하지 않은 인자를 전달받았을 때 발생하는 에러. 인자 객체를 YAML 형식으로 메시지에 포함하여 디버깅을 용이하게 한다.
-
-```typescript
-export class ArgumentError extends SdError {
-  /** 기본 메시지("잘못된 인자입니다.")와 함께 인자 객체를 YAML 형식으로 출력 */
-  constructor(argObj: Record<string, unknown>);
-  /** 커스텀 메시지와 함께 인자 객체를 YAML 형식으로 출력 */
-  constructor(message: string, argObj: Record<string, unknown>);
-}
-```
-
-```typescript
-throw new ArgumentError({ userId: 123, name: null });
-// message: "잘못된 인자입니다.\n\nuserId: 123\nname: null"
-
-throw new ArgumentError("잘못된 사용자", { userId: 123 });
-// message: "잘못된 사용자\n\nuserId: 123"
-```
-
-## `NotImplementedError`
-
-아직 구현되지 않은 기능이 호출되었을 때 발생하는 에러.
-
-```typescript
-export class NotImplementedError extends SdError {
-  constructor(message?: string);
-}
-```
-
-```typescript
-throw new NotImplementedError("서브클래스에서 구현 필요");
-// message: "미구현: 서브클래스에서 구현 필요"
-```
-
-## `TimeoutError`
-
-대기 시간이 초과되었을 때 발생하는 에러. `wait.until()`에서 최대 시도 횟수를 초과하면 자동으로 발생한다.
-
-```typescript
-export class TimeoutError extends SdError {
-  constructor(count?: number, message?: string);
-}
-```
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `count` | `number \| undefined` | 시도 횟수 |
-| `message` | `string \| undefined` | 추가 메시지 |
-
-```typescript
-throw new TimeoutError(50, "API 응답 대기 초과");
-// message: "대기 시간 초과(50회 시도): API 응답 대기 초과"
-```

package/claude/references/sd-simplysm14/core-common/docs/extensions.md

@@ -1,167 +0,0 @@
-# Extensions (Prototype)
-
-`@simplysm/core-common`을 import하면 `Array`, `Map`, `Set` 프로토타입 확장이 자동 등록된다.
-
-```typescript
-import "@simplysm/core-common"; // side-effect import — 확장 등록
-```
-
-## Array Extensions (Immutable)
-
-새 배열을 반환하며 원본 배열을 변경하지 않는다.
-
-| Method | Signature | Description |
-|--------|-----------|-------------|
-| `single` | `(predicate?) => T \| undefined` | 조건에 맞는 단일 요소 반환. 2개 이상이면 `ArgumentError` 발생 |
-| `first` | `(predicate?) => T \| undefined` | 첫 번째 요소 반환 |
-| `last` | `(predicate?) => T \| undefined` | 마지막 요소 반환 |
-| `filterExists` | `() => NonNullable<T>[]` | null/undefined 제거 |
-| `ofType` | `(type) => TNarrow[]` | 특정 타입의 요소만 필터 (`PrimitiveTypeStr` 또는 생성자) |
-| `mapAsync` | `(selector) => Promise<TResult[]>` | 비동기 매핑 (순차 실행) |
-| `filterAsync` | `(predicate) => Promise<T[]>` | 비동기 필터 (순차 실행) |
-| `mapMany` | `(selector?) => TResult[]` | 매핑 후 평탄화 (또는 중첩 배열 평탄화) |
-| `mapManyAsync` | `(selector?) => Promise<TResult[]>` | 비동기 매핑 후 평탄화 (순차 실행) |
-| `parallelAsync` | `(fn) => Promise<TResult[]>` | 비동기 병렬 처리 (`Promise.all` 사용) |
-| `groupBy` | `(keySelector, valueSelector?) => { key, values }[]` | key 기준 그룹화. 객체 key는 O(n²), 원시 key는 O(n) |
-| `toMap` | `(keySelector, valueSelector?) => Map<TKey, TValue>` | Map으로 변환. 중복 key이면 `ArgumentError` 발생 |
-| `toMapAsync` | `(keySelector, valueSelector?) => Promise<Map<TKey, TValue>>` | 비동기 Map으로 변환 |
-| `toArrayMap` | `(keySelector, valueSelector?) => Map<TKey, TValue[]>` | 그룹 Map으로 변환. O(n) 성능 |
-| `toSetMap` | `(keySelector, valueSelector?) => Map<TKey, Set<TValue>>` | 그룹 Set Map으로 변환 |
-| `toMapValues` | `(keySelector, valueSelector) => Map<TKey, TValue>` | 그룹화 후 그룹별로 값 변환 |
-| `toObject` | `(keySelector, valueSelector?) => Record<string, TValue>` | 일반 객체로 변환. 중복 key이면 `ArgumentError` 발생 |
-| `toTree` | `(keyProp, parentKey) => TreeArray<T>[]` | 평면 배열을 트리 구조로 변환. O(n) 복잡도 |
-| `distinct` | `(options?) => T[]` | 중복 제거. 객체 배열에서 `keyFn` 없이 사용하면 O(n²) |
-| `orderBy` | `(selector?) => T[]` | 오름차순 정렬 |
-| `orderByDesc` | `(selector?) => T[]` | 내림차순 정렬 |
-| `diffs` | `(target, options?) => ArrayDiffsResult<T, P>[]` | 두 배열 비교 (INSERT/DELETE/UPDATE) |
-| `oneWayDiffs` | `(orgItems, keyPropNameOrGetValFn, options?) => ArrayOneWayDiffResult<T>[]` | 단방향 차이 계산 (create/update/same) |
-| `merge` | `(target, options?) => (T \| P \| T&P)[]` | 두 배열 병합 |
-| `sum` | `(selector?) => number` | 합계. 빈 배열이면 0 |
-| `min` | `(selector?) => T \| undefined` | 최솟값 |
-| `max` | `(selector?) => T \| undefined` | 최댓값 |
-| `shuffle` | `() => T[]` | 무작위 섞기 |
-
-### `toTree` 상세
-
-```typescript
-interface Item {
-  id: number;
-  parentId?: number;
-  name: string;
-}
-
-const items: Item[] = [
-  { id: 1, name: "root" },
-  { id: 2, parentId: 1, name: "child1" },
-  { id: 3, parentId: 2, name: "grandchild" },
-];
-
-const tree = items.toTree("id", "parentId");
-// [{ id: 1, name: "root", children: [
-//   { id: 2, name: "child1", children: [
-//     { id: 3, name: "grandchild", children: [] }
-//   ]}
-// ]}]
-```
-
-### `diffs` 상세
-
-```typescript
-const diffs = newItems.diffs(oldItems, { keys: ["id"], excludes: ["updatedAt"] });
-// ArrayDiffsResult: { source: undefined, target: item } (INSERT)
-//                  { source: item, target: undefined } (DELETE)
-//                  { source: item, target: item }       (UPDATE)
-```
-
-### `oneWayDiffs` 상세
-
-```typescript
-const diffs = newItems.oneWayDiffs(orgItems, "id", { includeSame: false });
-// ArrayOneWayDiffResult: { type: "create", item, orgItem: undefined }
-//                        { type: "update", item, orgItem }
-//                        { type: "same", item, orgItem }
-```
-
-## Array Extensions (Mutable)
-
-원본 배열을 직접 변경한다.
-
-| Method | Signature | Description |
-|--------|-----------|-------------|
-| `insert` | `(index, ...items) => this` | 지정 위치에 항목 삽입 |
-| `remove` | `(item \| selector) => this` | 항목 또는 조건에 맞는 항목 제거 |
-| `toggle` | `(item) => this` | 항목 토글 (있으면 제거, 없으면 추가) |
-| `clear` | `() => this` | 배열 비우기 |
-| `distinctThis` | `(options?) => T[]` | 원본 배열에서 중복 제거 |
-| `orderByThis` | `(selector?) => T[]` | 원본 배열을 오름차순 정렬 |
-| `orderByDescThis` | `(selector?) => T[]` | 원본 배열을 내림차순 정렬 |
-
-## Map Extensions
-
-| Method | Signature | Description |
-|--------|-----------|-------------|
-| `getOrCreate` | `(key, newValue \| newValueFn) => V` | key가 없으면 새 값을 설정하고 반환. V 타입이 함수이면 팩토리로 감싸야 함 |
-| `update` | `(key, updateFn) => void` | 기존 값을 기반으로 업데이트. key가 없어도 `updateFn`이 호출됨 |
-
-```typescript
-const map = new Map<string, number[]>();
-const arr = map.getOrCreate("key", []); // 없으면 [] 설정 후 반환
-
-const countMap = new Map<string, number>();
-countMap.update("key", (v) => (v ?? 0) + 1); // 카운터 증가
-```
-
-## Set Extensions
-
-| Method | Signature | Description |
-|--------|-----------|-------------|
-| `adds` | `(...values: T[]) => this` | 여러 값을 한 번에 추가 |
-| `toggle` | `(value, addOrDel?) => this` | 값 토글. `addOrDel`로 강제 추가/제거 가능 |
-
-```typescript
-const set = new Set<number>([1, 2, 3]);
-set.adds(4, 5, 6); // 여러 항목 추가
-set.toggle(2); // 2가 있으므로 제거 → {1, 3, 4, 5, 6}
-set.toggle(99, "add"); // 강제 추가
-set.toggle(99, "del"); // 강제 제거
-```
-
-## Exported Types
-
-### `ArrayDiffsResult<TOriginal, TOther>`
-
-`diffs()` 메서드의 반환 타입. discriminated union으로 `source`와 `target` 중 하나가 `undefined`이면 INSERT/DELETE, 둘 다 있으면 UPDATE.
-
-```typescript
-export type ArrayDiffsResult<TOriginal, TOther> =
-  | { source: undefined; target: TOther }    // INSERT
-  | { source: TOriginal; target: undefined } // DELETE
-  | { source: TOriginal; target: TOther };   // UPDATE
-```
-
-### `ArrayOneWayDiffResult<TItem>`
-
-`oneWayDiffs()` 메서드의 반환 타입. `type` 필드로 분기.
-
-```typescript
-export type ArrayOneWayDiffResult<TItem> =
-  | { type: "create"; item: TItem; orgItem: undefined }
-  | { type: "update"; item: TItem; orgItem: TItem }
-  | { type: "same";   item: TItem; orgItem: TItem };
-```
-
-### `TreeArray<TNode>`
-
-`toTree()` 메서드의 반환 타입. 원본 타입에 `children` 속성이 추가된다.
-
-```typescript
-export type TreeArray<TNode> = TNode & { children: TreeArray<TNode>[] };
-```
-
-### `ComparableType`
-
-`orderBy`, `orderByDesc`, `orderByThis`, `orderByDescThis`의 selector 반환 타입.
-
-```typescript
-export type ComparableType = string | number | boolean | DateTime | DateOnly | Time | undefined;
-```

package/claude/references/sd-simplysm14/core-common/docs/features.md

@@ -1,136 +0,0 @@
-# Features
-
-## `EventEmitter<TEvents>`
-
-EventTarget 기반의 타입 안전한 이벤트 이미터. 브라우저와 Node.js 모두에서 사용 가능하다.
-
-```typescript
-export class EventEmitter<
-  TEvents extends { [K in keyof TEvents]: unknown } = Record<string, unknown>,
-> {
-  on<TEventName extends keyof TEvents & string>(
-    type: TEventName,
-    listener: (data: TEvents[TEventName]) => void,
-  ): void;
-
-  off<TEventName extends keyof TEvents & string>(
-    type: TEventName,
-    listener: (data: TEvents[TEventName]) => void,
-  ): void;
-
-  emit<TEventName extends keyof TEvents & string>(
-    type: TEventName,
-    ...args: TEvents[TEventName] extends void ? [] : [data: TEvents[TEventName]]
-  ): void;
-
-  listenerCount<TEventName extends keyof TEvents & string>(type: TEventName): number;
-
-  dispose(): void;
-}
-```
-
-### 메서드
-
-| Method | Description |
-|--------|-------------|
-| `on(type, listener)` | 이벤트 리스너 등록. 같은 리스너를 같은 이벤트에 중복 등록하면 무시됨 |
-| `off(type, listener)` | 이벤트 리스너 제거 |
-| `emit(type, data?)` | 이벤트 발행. `void` 타입 이벤트는 인자 없이 호출 |
-| `listenerCount(type)` | 특정 이벤트의 등록된 리스너 수 반환 |
-| `dispose()` | 모든 이벤트 리스너 제거 |
-
-```typescript
-interface MyEvents {
-  data: string;
-  error: Error;
-  done: void;
-}
-
-class MyService extends EventEmitter<MyEvents> {}
-
-const svc = new MyService();
-svc.on("data", (data) => console.log(data)); // data: string
-svc.emit("data", "hello");
-svc.emit("done"); // void 타입은 인자 없이 호출
-svc.dispose(); // 모든 리스너 정리
-```
-
----
-
-## `DebounceQueue`
-
-짧은 시간 내에 여러 번 호출되면 마지막 요청만 실행하는 비동기 디바운스 큐.
-
-`EventEmitter<{ error: SdError }>`를 상속한다. 에러 리스너가 없으면 `consola`로 로그 출력한다.
-
-```typescript
-export class DebounceQueue extends EventEmitter<{ error: SdError }> {
-  constructor(delay?: number);
-
-  run(fn: () => void | Promise<void>): void;
-
-  override dispose(): void;
-}
-```
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `delay` | `number \| undefined` | 디바운스 지연 시간 (ms). 생략 시 즉시 실행 (다음 이벤트 루프) |
-
-실행 중에 추가된 요청은 디바운스 지연 없이 현재 실행 완료 직후 즉시 처리된다.
-
-```typescript
-const dq = new DebounceQueue(300);
-dq.on("error", (err) => console.error(err));
-dq.run(() => console.log("1")); // 무시됨
-dq.run(() => console.log("2")); // 무시됨
-dq.run(() => console.log("3")); // 300ms 후 실행
-
-// 자원 정리
-const dq2 = new DebounceQueue(100);
-try {
-  dq2.run(() => { /* ... */ });
-} finally {
-  dq2.dispose();
-}
-```
-
----
-
-## `SerialQueue`
-
-큐에 추가된 함수들을 순차적으로 실행하는 비동기 직렬 큐. 하나의 작업이 완료된 후에야 다음 작업이 시작된다. 에러가 발생해도 후속 작업은 계속 실행된다.
-
-`EventEmitter<{ error: SdError }>`를 상속한다. 에러 리스너가 없으면 `consola`로 로그 출력한다.
-
-```typescript
-export class SerialQueue extends EventEmitter<{ error: SdError }> {
-  constructor(gap?: number);
-
-  run(fn: () => void | Promise<void>): void;
-
-  override dispose(): void;
-}
-```
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `gap` | `number` | 각 작업 사이의 간격 (ms). 기본값: 0 |
-
-`dispose()`는 대기 중인 큐를 비운다 (현재 실행 중인 작업은 완료됨).
-
-```typescript
-const sq = new SerialQueue();
-sq.on("error", (err) => console.error(err));
-sq.run(async () => await fetch("/api/1"));
-sq.run(async () => await fetch("/api/2")); // 1 완료 후 실행
-sq.run(async () => await fetch("/api/3")); // 2 완료 후 실행
-
-// 100ms 간격으로 실행, 자원 정리
-const sq2 = new SerialQueue(100);
-try {
-  sq2.run(async () => { /* ... */ });
-} finally {
-  sq2.dispose();
-}
-```