open-grid 1.2.0 → 1.2.1

package/dist/types/core/MutationService.d.ts

@@ -12,23 +12,52 @@ import { GridOptions, Position } from './types.js';
  * `commit(spec)` 로 수렴시키기 위한 명시 데이터계약(CommitSpec DTO). 각 mutator 의
  * **관측 가능한 발화 순서 차이는 정규화 대상이 아니라 이 필드들로 인코딩**한다
  * (R-9c 회귀0: R0 골든 `mutation-event-sequence.test.ts` 순서 보존).
+ * / Explicit data contract (CommitSpec DTO) that converges every mutator's mutate→render→emit
+ * tail into the single choke point `commit(spec)` (R4, §3.4, R-9a/R-9b). Each mutator's
+ * **observable firing-order differences are not normalized away but encoded into these
+ * fields** (R-9c, zero regression: order preserved by the R0 golden test
+ * `mutation-event-sequence.test.ts`).
  *
  * - `totals`  : VS/Pagination 행수 갱신. 'count'=현재 행수(insert/delete/push/unshift),
  *               'zero'=0(clearData). 생략=미갱신(writeCell/setData — 행수 불변 or 인라인 처리).
+ *               / Updates the VS/Pagination row count. `'count'` = current row count
+ *               (insert/delete/push/unshift), `'zero'` = 0 (clearData). Omitted = no update
+ *               (writeCell/setData — row count unchanged, or handled inline).
  * - `renderMode` : 'sync-window'=`_doRender(...visRange)`(insert/delete/write/endBatch),
  *               'full'=`_doRender(0,-1)`(clearData),
  *               'async-vs'=명령형 렌더 없음. setData 는 setTotalRows/rebuild 로 VS 가
  *               rAF 스케줄(비동기)하므로 `commit` 은 동기 `_doRender` 를 **하지 않는다**.
+ *               / `'sync-window'` = `_doRender(...visRange)` (insert/delete/write/endBatch),
+ *               `'full'` = `_doRender(0,-1)` (clearData), `'async-vs'` = no imperative render.
+ *               For setData, VS schedules via rAF through setTotalRows/rebuild, so `commit`
+ *               **does not** invoke a synchronous `_doRender`.
  * - `emitBeforeRender` : true=emit 을 render 앞에(writeCell/endBatch — 현행 순서), 기본 false=render 먼저(insert/delete).
+ *               / `true` = emit before render (writeCell/endBatch — current order); default
+ *               `false` = render first (insert/delete).
  * - `emitPayload` : `emit('dataChange', …)` 페이로드 지연 평가(thunk). getData() 시점을
  *               현행과 동일(render 뒤 or 앞)하게 유지 + 명시 onDataChange 재호출 시 2회 평가 보존.
+ *               / Lazily-evaluated (thunk) payload for `emit('dataChange', …)`. Keeps the
+ *               `getData()` evaluation point identical to current behavior (before or after
+ *               render) and preserves double evaluation when `onDataChange` is explicitly
+ *               re-invoked.
  * - `fireOnDataChangeExplicitly` : true=`_options.onDataChange?.()` 를 **명시 재호출**(bound listener 와 합쳐 DOUBLE-fire).
  *               row mutator=true, setData/clearData=false(bound listener 로 ONCE).
+ *               / `true` = **explicitly re-invokes** `_options.onDataChange?.()` (combined with
+ *               the bound listener, this DOUBLE-fires). Row mutators = `true`;
+ *               setData/clearData = `false` (bound listener fires ONCE).
  * - `flushFormula` : true=emit 전에 `_flushFormulaRecalc()`(writeCell/endBatch).
+ *               / `true` = calls `_flushFormulaRecalc()` right before emit (writeCell/endBatch).
  * - `preRender` : render 직전 훅(deleteRow 의 removedRowId invalidate 루프).
+ *               / Hook that runs immediately before render (deleteRow's removedRowId
+ *               invalidation loop).
  * - `coalescable` : true 인 커밋만 배치 개구 중 render/emit 을 no-op 하고 `_batchDirty` 를 세운다.
  *               **writeCell 만 원래 배치를 감지**했으므로 나머지 mutator(coalescable 생략)는
  *               배치 안에서도 즉시 렌더(현행 보존 — 배치 게이트를 전 mutator 로 확대하지 않는다).
+ *               / Only commits with `true` no-op render/emit while a batch is open and instead
+ *               set `_batchDirty`. **Only writeCell originally detected batches**, so the
+ *               remaining mutators (which omit `coalescable`) still render immediately even
+ *               inside a batch (current behavior preserved — the batch gate is not widened to
+ *               every mutator).
  */
 export interface CommitSpec {
     totals?: 'count' | 'zero';
@@ -50,6 +79,18 @@ export interface CommitSpec {
  * render 는 주입된 `doRenderWindow`/`doRenderFull` 콜백으로만 유발한다. 값(vs/pagination/recalc
  * 등)은 늦은-null / 재할당(worksheet 전환)을 견디도록 전부 getter 클로저로 읽는다.
  * 배치 코얼레싱(`_batchDepth`/`_batchDirty`) 시맨틱은 R4 와 1:1 동일하다(회귀 0).
+ * / Dependency contract that moves the data-mutation surface (setData/insert/push/delete/
+ * writeCell/writeCells + batch API) and the single commit choke point `commit(CommitSpec)`
+ * introduced by R4 out of the `OpenGrid` God object with **behavior unchanged** (R6, §3.1 C5,
+ * §6-R6). `OpenGrid` retains only thin delegating public methods (public API unchanged).
+ *
+ * Strangler principle (A2): `DataLayer` is still owned by `OpenGrid`; it is only **injected**
+ * here via the `*Deps` closure-inversion pattern. **The service has no direct knowledge of
+ * rendering** (Yourdon I/O separation): render is only triggered through the injected
+ * `doRenderWindow`/`doRenderFull` callbacks. Values (vs/pagination/recalc, etc.) are all read
+ * through getter closures so they tolerate late-null / reassignment (worksheet switching).
+ * Batch coalescing semantics (`_batchDepth`/`_batchDirty`) are 1:1 identical to R4 (zero
+ * regression).
  */
 export interface MutationServiceDeps<T extends Record<string, any> = any> {
     getData: () => DataLayer<T>;
@@ -62,29 +103,38 @@ export interface MutationServiceDeps<T extends Record<string, any> = any> {
     getRowMgr: () => RowManager<T>;
     getGrpMgr: () => GroupTreeManager<T>;
     getOptions: () => Required<GridOptions<T>>;
-    /** EventEmitter fan (this.emit) — 'dataChange'/'editEnd'/'writeCellsSkip'. */
+    /** EventEmitter fan(this.emit) — 'dataChange'/'editEnd'/'writeCellsSkip'. / EventEmitter fan-out (this.emit) for 'dataChange'/'editEnd'/'writeCellsSkip'. */
     emit: (event: string, payload?: any) => void;
-    /** aria-live announce (C8.1 공용 인프라). */
+    /** aria-live announce(C8.1 공용 인프라). / aria-live announce (C8.1 shared infrastructure). */
     announce: (msg: string) => void;
     /** i18n: 데이터 로드/스킵 announce 해석. / i18n: resolve data load/skip announces. */
     t: (key: string, params?: Record<string, string | number>) => string;
-    /** sort/filter 재적용(setData). */
+    /** sort/filter 재적용(setData). / Re-apply sort/filter (setData). */
     applyFilters: () => void;
-    /** writeCell/endBatch 커밋 emit 직전 수식 dirty seed 소비. */
+    /** writeCell/endBatch 커밋 emit 직전 수식 dirty seed 소비. / Consume formula dirty seeds right before the writeCell/endBatch commit emit. */
     flushFormula: () => void;
-    /** 현재 가시 범위 렌더(this._doRender(...this._visRange())). 서비스는 렌더 내부를 모른다. */
+    /** 현재 가시 범위 렌더(this._doRender(...this._visRange())). 서비스는 렌더 내부를 모른다. / Render the current visible range (this._doRender(...this._visRange())). The service has no knowledge of render internals. */
     doRenderWindow: () => void;
-    /** 전체 렌더(this._doRender(0, -1)) — clearData full 모드. */
+    /** 전체 렌더(this._doRender(0, -1)) — clearData full 모드. / Full render (this._doRender(0, -1)) — clearData's full mode. */
     doRenderFull: () => void;
-    /** setData: 수식 dirty seed clear + RecalcCoordinator 재생성(rowId 재발급 대응). */
+    /** setData: 수식 dirty seed clear + RecalcCoordinator 재생성(rowId 재발급 대응). / setData: clears formula dirty seeds and recreates the RecalcCoordinator (to cope with rowId reissuance). */
     resetFormulaState: () => void;
-    /** writeCell: 값이 바뀐 셀을 수식 dirty seed 로 적립(kind==='data' 일 때만). */
+    /** writeCell: 값이 바뀐 셀을 수식 dirty seed 로 적립(kind==='data' 일 때만). / writeCell: accumulates a changed cell as a formula dirty seed (only when kind === 'data'). */
     seedFormulaDirty: (rowIndex: number, field: string) => void;
-    /** deleteRow: 제거된 rowId 를 deps 로 갖는 수식들을 #REF 로 무효화(preRender). */
+    /** deleteRow: 제거된 rowId 를 deps 로 갖는 수식들을 #REF 로 무효화(preRender). / deleteRow: invalidates formulas that depend on a removed rowId to #REF (preRender). */
     invalidateRemovedRows: (rowIds: string[]) => void;
-    /** deleteRow: 제거 전 flat index 의 안정 rowId 확보. */
+    /** deleteRow: 제거 전 flat index 의 안정 rowId 확보. / deleteRow: captures the stable rowId at a flat index before removal. */
     getRowIdAt: (rowIndex: number) => string | undefined;
 }
+/**
+ * 모든 데이터 변경(mutation)의 단일 초크포인트. / Single chokepoint for all data mutations.
+ *
+ * setData/insertRow/pushRow/deleteRow/writeCell/writeCells + 배치 API를 소유하며, 각 연산의
+ * mutate→render→emit 꼬리를 {@link CommitSpec} 을 통해 `commit()` 하나로 수렴시킨다(R4/R6).
+ * / Owns setData/insertRow/pushRow/deleteRow/writeCell/writeCells plus the batch API, and
+ * converges every operation's mutate→render→emit tail into a single `commit()` call driven
+ * by a {@link CommitSpec} (R4/R6).
+ */
 export declare class MutationService<T extends Record<string, any> = any> {
     private _deps;
     /** reentrant 카운터. 0 초과면 배치 중(writeCell 이 render/dataChange 를 지연). */
@@ -97,21 +147,66 @@ export declare class MutationService<T extends Record<string, any> = any> {
      * 꼬리를 여기로 수렴. **관측 순서는 spec 필드로 인코딩**(정규화 아님 — R0 골든 diff=0).
      * 배치 코얼레싱을 내재화: `coalescable` 커밋은 배치 개구 중 render/emit 을 지연하고
      * `_batchDirty` 만 세운다(가장 바깥 endBatch 에서 1회 flush).
+     * / Single commit chokepoint (R4, §3.4, R-9a). Converges the post-mutate
+     * totals→(preRender)→flush→render/emit tail here. **Observable order is encoded via the
+     * spec fields** (not normalized — R0 golden diff = 0). Internalizes batch coalescing:
+     * commits marked `coalescable` defer render/emit while a batch is open and only set
+     * `_batchDirty` (flushed once by the outermost endBatch).
+     *
+     * @param spec - 커밋 데이터계약 / The commit data contract
      */
     commit(spec: CommitSpec): void;
+    /**
+     * 전체 데이터를 교체한다. rowId 를 재발급하므로 기존 stable-id 앵커 수식은 전량 무효화된다.
+     * / Replace the entire dataset. Reissues rowIds, so any existing stable-id-anchored formulas
+     * are fully invalidated.
+     *
+     * @param data - 새 행 데이터 배열 / New array of row data
+     */
     setData(data: T[]): void;
+    /**
+     * 행 하나를 삽입한다. / Insert a single row.
+     *
+     * @param item - 삽입할 행 데이터(부분) / Row data to insert (partial)
+     * @param position - 삽입 위치. 기본 'last' / Insert position. Default `'last'`
+     */
     insertRow(item: Partial<T>, position?: Position): void;
+    /**
+     * 하나 이상의 행을 끝에 추가한다(트리거 브래킷 없음). / Append one or more rows to the end (no trigger bracket).
+     *
+     * @param items - 추가할 행(단일 또는 배열) / Row(s) to append (single or array)
+     */
     pushRow(items: Partial<T> | Partial<T>[]): void;
+    /**
+     * 하나 이상의 행을 제거한다. 제거된 rowId 에 의존하던 수식은 #REF 로 무효화된다.
+     * / Remove one or more rows. Formulas depending on a removed rowId are invalidated to #REF.
+     *
+     * @param rowIndex - 제거할 행의 (표시) 인덱스, 단일 또는 배열 / (Displayed) index of the row(s) to remove, single or array
+     */
     deleteRow(rowIndex: number | number[]): void;
+    /**
+     * 셀 하나에 값을 쓴다. 배치 개구 중이면 render/emit 을 coalesce 한다.
+     * / Write a value to a single cell. Coalesces render/emit while a batch is open.
+     *
+     * @param rowIndex - 대상 행의 flat index / Flat index of the target row
+     * @param field - 컬럼 field 명 / Column field name
+     * @param value - 기록할 값 / Value to write
+     */
     writeCell(rowIndex: number, field: string, value: any): void;
     /**
      * 배치 쓰기 시작(C2.1). 이후 writeCell 호출들은 render/dataChange 를 지연·coalesce 한다.
      * 중첩 호출은 카운팅(reentrant) — 가장 바깥 endBatch 에서만 실제로 flush 된다.
+     * / Begin batched writes (C2.1). Subsequent writeCell calls defer and coalesce
+     * render/dataChange. Nested calls are counted (reentrant) — only the outermost endBatch
+     * actually flushes.
      */
     beginBatch(): void;
     /**
      * 배치 종료(C2.1). 카운터가 0 이 되는 시점에 한해 배치 중 발생한 쓰기가 있으면
      * _doRender 1회 + dataChange 1회를 발생시킨다(둘 다 0회 또는 1회 — 폭주 차단).
+     * / End the batch (C2.1). Only when the counter reaches 0 and a write occurred during the
+     * batch does this fire one `_doRender` and one `dataChange` (each either 0 or 1 times — no
+     * runaway firing).
      */
     endBatch(): void;
     /**
@@ -119,6 +214,14 @@ export declare class MutationService<T extends Record<string, any> = any> {
      * FlatRowModel.resolveFlatRow 로 해소해 kind!=='data' (group/tree/detail 의사행)이면
      * 쓰기 전에 skip 한다(C0.3 쓰기 안전, filler 에 writeCell 절대 금지).
      * 건너뛴 셀 수를 반환하고, 1건이라도 있으면 announce + 'writeCellsSkip' 이벤트로 표면화한다.
+     * / A beginBatch+loop+endBatch wrapper (C2.1). `rowIndex` in each patch is a flat index —
+     * if resolving it via `FlatRowModel.resolveFlatRow` yields `kind !== 'data'` (a group/tree/
+     * detail pseudo-row), the write is skipped (C0.3 write safety — writeCell is never allowed
+     * on fillers). Returns the number of skipped cells and, if any were skipped, surfaces it via
+     * announce + a `'writeCellsSkip'` event.
+     *
+     * @param patches - 적용할 셀 패치 배열 / Array of cell patches to apply
+     * @returns 건너뛴 셀 수 / Number of cells skipped
      */
     writeCells(patches: Array<{
         rowIndex: number;

package/dist/types/core/OrgChart.d.ts

@@ -1,20 +1,54 @@
+/**
+ * 조직도 노드 카드의 컬럼(필드) 정의. / Column (field) definition for an org-chart node card.
+ */
 export interface OrgChartColumnDef {
+    /** 표시할 데이터 필드명. / Data field name to display. */
     field: string;
+    /** 셀 래퍼에 추가할 CSS 클래스명. / Extra CSS class name for the cell wrapper. */
     className?: string;
+    /** 인라인 스타일 문자열 또는 (값, 행)→스타일 함수. / Inline style string or (value, row)→style function. */
     style?: string | ((value: any, row: Record<string, any>) => string);
+    /** 커스텀 렌더러. 문자열 반환 시 innerHTML, 엘리먼트 반환 시 append. / Custom renderer; a string is set as innerHTML, an element is appended. */
     renderer?: (value: any, row: Record<string, any>) => HTMLElement | string;
 }
+/**
+ * 조직도 생성 옵션. / Org-chart construction options.
+ */
 export interface OrgChartOptions {
+    /** 각 행의 고유 id 필드명. / Field name holding each row's unique id. */
     idField: string;
+    /** 부모 id 를 담은 필드명(트리 구성 기준). / Field name holding the parent id (tree structure key). */
     parentIdField: string;
+    /** 노드 카드에 렌더할 컬럼 정의 배열. / Column definitions rendered inside each node card. */
     columns: OrgChartColumnDef[];
+    /** 노드 카드 너비(px). 기본 160. / Node card width in px. Default 160. @defaultValue 160 */
     nodeWidth?: number;
+    /** 노드 카드 높이(px). 기본 72. / Node card height in px. Default 72. @defaultValue 72 */
     nodeHeight?: number;
+    /** 레벨(세대) 간 세로 간격(px). 기본 52. / Vertical gap between levels in px. Default 52. @defaultValue 52 */
     levelGap?: number;
+    /** 형제 노드 간 가로 간격(px). 기본 20. / Horizontal gap between siblings in px. Default 20. @defaultValue 20 */
     siblingGap?: number;
+    /** 최초 로드 시 전체 펼침 여부. 기본 true. / Whether to expand all on first load. Default true. @defaultValue true */
     expandOnLoad?: boolean;
+    /** 노드 클릭 콜백 (id, 행데이터). / Node click callback (id, row data). */
     onNodeClick?: (id: any, data: Record<string, any>) => void;
 }
+/**
+ * 조직도 컴포넌트. / Org-chart component.
+ *
+ * 부모/자식 관계(idField/parentIdField)를 가진 평면 데이터를 트리로 구성해
+ * SVG 연결선 + 노드 카드로 렌더한다. 그리드와 독립된 standalone 컴포넌트다.
+ * / Builds a tree from flat parent/child data (idField/parentIdField) and renders it as
+ * SVG connectors plus node cards. A standalone component independent of the grid.
+ *
+ * @example
+ * const chart = new OrgChart('#org', {
+ *   idField: 'id', parentIdField: 'managerId',
+ *   columns: [{ field: 'name' }, { field: 'title' }],
+ * });
+ * chart.setData([{ id: 1, managerId: null, name: 'CEO', title: '대표' }]);
+ */
 export declare class OrgChart {
     private _container;
     private _opts;
@@ -22,12 +56,33 @@ export declare class OrgChart {
     private _roots;
     private _expandedKeys;
     private _selectedId;
+    /**
+     * @param selector - 마운트할 컨테이너 셀렉터 문자열 또는 엘리먼트 / Container selector string or element to mount into
+     * @param opts - 조직도 옵션 / Org-chart options
+     */
     constructor(selector: string | HTMLElement, opts: OrgChartOptions);
+    /**
+     * 조직도 데이터를 설정하고 렌더한다. / Set org-chart data and render.
+     *
+     * @param data - 부모/자식 관계를 가진 평면 행 배열 / Flat array of rows with parent/child relations
+     */
     setData(data: Record<string, any>[]): void;
+    /**
+     * COLOR 축 테마를 컨테이너에 설정한다. / Set the COLOR-axis theme on the container.
+     *
+     * @param theme - data-og-theme 값 / data-og-theme value
+     */
     setTheme(theme: string): void;
-    /** R12b: FORM(스킨) 축 — data-og-skin 을 자기 컨테이너에 설정(setTheme 과 동형, 색과 직교). */
+    /**
+     * R12b: FORM(스킨) 축 — data-og-skin 을 자기 컨테이너에 설정(setTheme 과 동형, 색과 직교).
+     * / R12b: FORM (skin) axis — set data-og-skin on the container (symmetric to setTheme, orthogonal to color).
+     *
+     * @param skin - data-og-skin 값 / data-og-skin value
+     */
     setSkin(skin: string): void;
+    /** 모든 노드를 펼친다. / Expand all nodes. */
     expandAll(): void;
+    /** 모든 노드를 접는다(루트만 표시). / Collapse all nodes (roots only). */
     collapseAll(): void;
     private _toggle;
     private _rebuild;

package/dist/types/core/OverrideKernel.d.ts

@@ -12,17 +12,34 @@
  * 본 커널은 단독 클래스로, OpenGrid 인스턴스를 host 로 받아 프로토타입 메서드를
  * 인스턴스 프로퍼티로 shadowing(순수 런타임 래핑, C1-clean) 한다. 소스 본문 0줄 수정.
  */
+/** override 커널의 호스트(임의 메서드를 가진 객체, 보통 OpenGrid 인스턴스). / Host of the override kernel (an object with arbitrary methods, usually an OpenGrid instance). */
 export interface OverrideKernelHost {
     [name: string]: any;
 }
-/** override() 호출 시 레이어가 받는 함수 시그니처: 첫 인자는 안쪽(원본 근접) 함수. */
+/**
+ * override() 호출 시 레이어가 받는 함수 시그니처: 첫 인자는 안쪽(원본 근접) 함수.
+ * / Layer function signature received by override(): the first argument is the inner (closest-to-original) function.
+ */
 export type OverrideLayer = (orig: (...args: any[]) => any, ...args: any[]) => any;
+/** override 옵션. / Override options. */
 export interface OverrideOptions {
-    /** 동일 name 재진입을 허용(정당한 재귀). 기본 false. */
+    /** 동일 name 재진입을 허용(정당한 재귀). 기본 false. / Allow re-entry for the same name (legitimate recursion). Default false. @defaultValue false */
     reentrant?: boolean;
-    /** 'fallback' → 레이어 예외 시 경고 후 orig 실행(멱등 가정). 미지정 시 strict(전파). */
+    /** 'fallback' → 레이어 예외 시 경고 후 orig 실행(멱등 가정). 미지정 시 strict(전파). / 'fallback' → on layer exception, warn then run orig (idempotent assumption); otherwise strict (propagate). */
     onError?: 'fallback';
 }
+/**
+ * `grid.override()` 확장 커널. / The `grid.override()` extension kernel.
+ *
+ * OpenGrid 인스턴스를 host 로 받아 프로토타입 메서드를 인스턴스 프로퍼티로 shadowing 한다
+ * (순수 런타임 래핑, 소스 본문 0줄 수정). FIFO 합성 + 재진입 가드 + 에러 격리를 제공한다.
+ * / Takes an OpenGrid instance as host and shadows prototype methods with instance properties
+ * (pure runtime wrapping, zero source edits). Provides FIFO composition, re-entry guarding, and error isolation.
+ *
+ * @example
+ * const k = new OverrideKernel(grid);
+ * k.override('setData', (orig, rows) => orig(rows.filter(r => r.active)));
+ */
 export declare class OverrideKernel {
     private _host;
     /** name → this-bound 원본 함수 (최초 1회 보존) */
@@ -39,32 +56,59 @@ export declare class OverrideKernel {
     private _strict;
     /** F3: 재귀 깊이 제한 */
     private _maxDepth;
+    /**
+     * @param host - override 대상 호스트 객체 / Host object to override
+     * @param opts - strict(기본 true, 예외 전파) / maxDepth(기본 32, 재귀 깊이 제한) / strict (default true, propagate) / maxDepth (default 32, recursion depth limit)
+     */
     constructor(host: OverrideKernelHost, opts?: {
         strict?: boolean;
         maxDepth?: number;
     });
     /**
-     * 메서드 override 등록.
-     * 1. 최초 1회 원본을 this-bound 로 보존.
-     * 2. 레이어 push (FIFO 등록순).
-     * 3. reduce 좌측폴드로 합성(나중 등록 = 최외곽).
-     * 4. 재진입 가드 + 에러 격리로 감싼 dispatcher 를 host[name] 인스턴스 프로퍼티에 할당.
+     * 메서드 override 등록. / Register a method override.
+     *
+     * 1. 최초 1회 원본을 this-bound 로 보존. / Preserve the original once, this-bound.
+     * 2. 레이어 push (FIFO 등록순). / Push the layer (FIFO registration order).
+     * 3. reduce 좌측폴드로 합성(나중 등록 = 최외곽). / Compose via reduce left-fold (later registration = outermost).
+     * 4. 재진입 가드 + 에러 격리로 감싼 dispatcher 를 host[name] 인스턴스 프로퍼티에 할당. / Assign a re-entry-guarded, error-isolated dispatcher to the host[name] instance property.
+     *
+     * @param name - override 대상 메서드명 / Method name to override
+     * @param fn - override 레이어(첫 인자는 안쪽 orig) / Override layer (first arg is the inner orig)
+     * @param opts - override 옵션 / Override options
+     * @returns 체이닝용 host / The host for chaining
      */
     override(name: string, fn: OverrideLayer, opts?: OverrideOptions): OverrideKernelHost;
     /** 합성된 dispatcher 생성. override/restore 시점마다 재구성. */
     private _buildDispatcher;
-    /** strategy 슬롯 등록 (Phase 2 매니저 배선용 API). */
+    /**
+     * strategy 슬롯 등록(매니저 배선용 API). / Register a strategy slot (manager-wiring API).
+     *
+     * @param slot - 전략 슬롯 이름 / Strategy slot name
+     * @param fn - 전략 함수 / Strategy function
+     * @returns 체이닝용 host / The host for chaining
+     */
     strategy(slot: string, fn: Function): OverrideKernelHost;
-    /** strategy 슬롯 조회 — 미등록 시 fallback 반환 (매니저 read API). */
+    /**
+     * strategy 슬롯 조회 — 미등록 시 fallback 반환(매니저 read API). / Read a strategy slot — returns fallback when unregistered (manager read API).
+     *
+     * @param slot - 전략 슬롯 이름 / Strategy slot name
+     * @param fallback - 미등록 시 반환할 기본 함수 / Default function returned when unregistered
+     * @returns 등록된 전략 또는 fallback / The registered strategy or fallback
+     */
     getStrategy<F extends Function>(slot: string, fallback: F): F;
-    /** 슬롯 등록 여부. */
+    /** 전략 슬롯 등록 여부. / Whether a strategy slot is registered. */
     hasStrategy(slot: string): boolean;
-    /** 단일 메서드 원본 복구. 없으면 no-op. */
+    /**
+     * 단일 메서드 원본 복구. 없으면 no-op. / Restore a single method's original; no-op if absent.
+     *
+     * @param name - 복구할 메서드명 / Method name to restore
+     * @returns 체이닝용 host / The host for chaining
+     */
     restore(name: string): OverrideKernelHost;
-    /** 전체 복구 + strategy clear. destroy 시 호출. */
+    /** 전체 복구 + strategy clear. destroy 시 호출. / Restore everything + clear strategies; called on destroy. */
     restoreAll(): OverrideKernelHost;
-    /** override 등록 여부. */
+    /** 해당 메서드가 override 등록돼 있는가. / Whether the given method is overridden. */
     hasOverride(name: string): boolean;
-    /** override 등록된 메서드 이름 목록. */
+    /** override 등록된 메서드 이름 목록. / List of overridden method names. */
     getOverrideNames(): string[];
 }

package/dist/types/core/Pagination.d.ts

@@ -1,15 +1,25 @@
+/**
+ * 페이지 변경 시 전달되는 이벤트 페이로드. / Event payload delivered on a page change.
+ */
 export interface PageChangeEvent {
+    /** 현재(변경 후) 페이지 번호(1-base). / Current (post-change) page number (1-based). */
     page: number;
+    /** 페이지당 행 수. / Rows per page. */
     pageSize: number;
+    /** 전체 행 수. / Total row count. */
     totalRows: number;
+    /** 전체 페이지 수. / Total page count. */
     totalPages: number;
 }
+/** 페이지 변경 콜백. / Callback invoked on a page change. */
 export type PageChangeFn = (e: PageChangeEvent) => void;
 /** i18n: 페이지네이션 라벨 해석기(행/페이지·범위 배지·빈 상태). / i18n: pagination label resolver (rows-per-page, range badge, empty). */
 export type PaginationT = (key: string, params?: Record<string, string | number>) => string;
 /**
- * 그리드 하단 페이지네이션 UI + 상태 관리.
- * DataLayer의 _displayIndexes 슬라이싱을 담당.
+ * 그리드 하단 페이지네이션 UI + 상태 관리. / Grid bottom pagination UI plus state management.
+ *
+ * DataLayer의 `_displayIndexes` 슬라이싱 범위(`getRange`)를 계산해 넘겨준다.
+ * / Computes the slice range (`getRange`) used against DataLayer's `_displayIndexes`.
  */
 export declare class Pagination {
     private _el;
@@ -19,21 +29,45 @@ export declare class Pagination {
     private _onChange;
     private _t;
     constructor(container: HTMLElement, pageSize: number, onChange: PageChangeFn, t?: PaginationT);
+    /** 현재 페이지 번호(1-base). / Current page number (1-based). */
     get page(): number;
+    /** 페이지당 행 수. / Rows per page. */
     get pageSize(): number;
+    /** 전체 페이지 수(최소 1). / Total page count (minimum 1). */
     get totalPages(): number;
-    /** 전체 행 수 갱신 → 현재 페이지 유효성 검사 후 재렌더 */
+    /**
+     * 전체 행 수 갱신 → 현재 페이지 유효성 검사 후 재렌더. / Update the total row count, clamp the current page if needed, and re-render.
+     *
+     * @param n - 새 전체 행 수 / New total row count
+     */
     setTotalRows(n: number): void;
+    /**
+     * 페이지당 행 수를 변경하고 1페이지로 리셋한다. / Change rows-per-page and reset to page 1.
+     *
+     * @param size - 새 페이지당 행 수 / New rows-per-page value
+     */
     setPageSize(size: number): void;
+    /**
+     * 지정 페이지로 이동한다(범위를 벗어나면 클램프). / Navigate to the given page (clamped to valid range).
+     *
+     * @param page - 이동할 페이지 번호(1-base) / Target page number (1-based)
+     */
     goTo(page: number): void;
-    /** 현재 페이지의 [startIndex, endIndex] 반환 (DataLayer 인덱스 기준) */
+    /**
+     * 현재 페이지의 `[startIndex, endIndex]` 반환(DataLayer 인덱스 기준). / Return `[startIndex, endIndex]` for the current page (DataLayer index space).
+     *
+     * @returns 현재 페이지의 시작/끝 인덱스(포함) / Start/end index (inclusive) for the current page
+     */
     getRange(): {
         start: number;
         end: number;
     };
+    /** @internal 현재 상태로 `onChange` 콜백을 실행한다. / Invokes the `onChange` callback with the current state. */
     private _emit;
+    /** @internal 페이지네이션 바 DOM 을 전체 재렌더한다. / Fully re-renders the pagination bar DOM. */
     private _render;
     /** i18n: 상주 크롬 라벨을 활성 로케일로 다시 그린다(setLocale 경로). / i18n: repaint resident chrome labels in the active locale (setLocale path). */
     refreshLabels(): void;
+    /** 페이지네이션 바 DOM 을 제거한다. / Remove the pagination bar DOM. */
     destroy(): void;
 }