@things-factory/board-ai 10.1.24 → 10.1.26

package/server/service/types.ts

@@ -10,6 +10,11 @@
 import type { BoardComponent, BoardModel } from '@things-factory/board-import'
 
 /* 대화 한 줄은 도메인을 모른다 — 정의는 `@things-factory/ai-assistant` 에 있다(2026-09-10). */
+/*
+ * The edit vocabulary is not this package's. A person dragging a box produces the same
+ * operations, so they live in @operato/scene-ops with the two appliers that carry them out.
+ */
+import type { SceneActionOp, SceneEditPatch } from '@operato/scene-ops'
 import type { LLMMessage } from '@things-factory/ai-assistant'
 export type { LLMMessage }
 
@@ -121,7 +126,7 @@ import type { AIAnalysisClaim, GroundedAnalysisContract } from '@things-factory/
 export type { ToolUsage }
 
 /** Board-specific extension of the shared evidence/approval analysis boundary. */
-export interface BoardGroundedAnalysis extends GroundedAnalysisContract<any, AIAnalysisClaim, BoardEditPatch | BoardActionOp[]> {
+export interface BoardGroundedAnalysis extends GroundedAnalysisContract<any, AIAnalysisClaim, SceneEditPatch | SceneActionOp[]> {
   kind: 'board.analysis.v1'
 }
 
@@ -130,12 +135,12 @@ export interface ChatResponse {
   /** 사용자에게 보여줄 텍스트 응답 */
   reply: string
   /** 보드 변경이 있으면 patch */
-  patch?: BoardEditPatch
+  patch?: SceneEditPatch
   /**
    * Scene 조작 action (ephemeral — 모델 변경 없음 / undo 영향 없음).
    * 시간순 시퀀스로 호스트가 things-scene API 직접 실행.
    */
-  actions?: BoardActionOp[]
+  actions?: SceneActionOp[]
   /** 모호한 입력 시 명확화 질문 (patch 없음) */
   followUp?: string
   /** AI 가 응답 만드는 과정에서 호출한 도구들 (시간순). UI fold-able 박스용. */
@@ -158,119 +163,13 @@ export interface ChatResponse {
   analysis?: BoardGroundedAnalysis
 }
 
-export interface BoardEditPatch {
-  ops: BoardEditOp[]
-  /** 사용자 검수용 1-2 문장 요약 */
-  summary: string
-  /** 0..1 신뢰도 */
-  confidence: number
-}
-
-/**
- * 보드 변경 op.
- *
- * 식별자 정책 — 기존 컴포넌트 타깃팅은 `refid` (number) 만 사용.
- * things-scene 의 모든 컴포넌트는 `refid` 를 자동 발급받는다 (universal).
- * `model.id` 는 optional metadata 일 뿐 — 항상 존재하지 않으므로 targeting 에는
- * 부적합. 별개 개념이므로 BoardEditOp / tool 인자에서도 별개 식별자로 분리하지
- * 않고 refid 단일 채널로 일원화.
- *
- * 계층 — 보드는 **최상위 부모** (things-scene 의 model-layer) 이고 그 자체로 자기
- * 속성을 갖는다 (fillStyle, width, height, fitMode, translate, scale, sky, skyColor,
- * exposure, hemi/dirLight 계열, camera 계열). 자식 컴포넌트와 별개. 보드 속성 변경은
- * `modifyBoard`, 자식 변경은 `modify` (refid 기반).
- *
- * 주의 — `name` 은 보드 *엔티티* (DB row) 의 컬럼이지 scene MODEL 의 필드가 아니다.
- * things-scene 의 model-layer 가 인식 안 함. modifyBoard 로 name 을 보내면 model
- * JSON 에 죽은 필드로 박힐 뿐 렌더링/동작에 영향 없음. 보드 라벨 변경은 GraphQL
- * boardPatch (BoardPatch input 의 name 필드) 영역.
- *
- * style 변경 / 이동 / 크기 변경 등 자식 컴포넌트의 변경은 모두 `modify.patch` 안에
- * 흡수. 보드 root 속성 변경은 `modifyBoard.patch` 로.
- */
-/**
- * Phase 2 — Scene 조작 op 들. 모델 차원 (좌표 / 부모-자식 관계 / z-order) 변경이지만
- * things-scene 의 자체 API (align/distribute/group/ungroup/zorder) 가 일관된 결과를
- * 보장하므로 호스트가 직접 호출. 모델 차원 시뮬레이션 (apply-patch) 은 단순화 —
- * scene 호출 결과가 정본.
- */
-export type AlignDirection =
-  | 'left'
-  | 'right'
-  | 'center'
-  | 'top'
-  | 'middle'
-  | 'bottom'
-
-export type DistributeAxis = 'horizontal' | 'vertical'
-
-export type ZorderDirection = 'front' | 'back' | 'forward' | 'backward'
-
-/**
- * Sugar layout — `arrange` op 의 layout 종류.
- *
- * 의도: align/distribute 위에 얹는 high-level 의도 표현. AI 가 "3x2 그리드로",
- * "한 줄로", "세로로 일렬" 같은 자연어를 픽셀 노가다 없이 단일 op 로 표현.
- *
- * left/top 만 변경 — width/height 는 유지. AI 가 사이즈도 바꾸려면 별도 modify.
- *
- * 위치 계산은 호스트 (things-scene 측) 가 담당 — 각 컴포넌트의 현재 width/height 를
- * 정확히 알아야 하므로 model 차원 시뮬레이션은 SCENE_ONLY (apply-patch noop).
- */
-export type ArrangeLayout =
-  | { type: 'grid'; cols: number; gap?: number; anchor?: { left: number; top: number } }
-  | {
-      type: 'row'
-      gap?: number
-      anchor?: { left: number; top: number }
-      align?: 'start' | 'center' | 'end'
-    }
-  | {
-      type: 'column'
-      gap?: number
-      anchor?: { left: number; top: number }
-      align?: 'start' | 'center' | 'end'
-    }
-
-/**
- * C-1 — Scene 조작 action 들 (ephemeral). 모델 변경 X, 따라서 BoardEditOp 와 별개
- * 채널 (board-action-execute 이벤트). undo 히스토리 미영향, dirty flag 미영향.
- *
- * 종류:
- *   - selectComponents: scene.selected 직접 set (사용자 선택 변경)
- *   - centerToComponent: 특정 컴포넌트로 view 이동
- *   - fitToView: 보드 전체가 보이도록 fit
- *   - setSceneMode: edit / view 모드 전환
- */
-export type BoardActionOp =
-  | { action: 'selectComponents'; refids: number[] }
-  | { action: 'centerToComponent'; refid: number; animated?: boolean }
-  | { action: 'fitToView'; mode?: 'fit' | 'ratio' | 'width' | 'height' }
-  | { action: 'setSceneMode'; mode: 'edit' | 'view' }
-  /** 다중 컴포넌트 outline highlight — search/finder UX 의 "이게 모두 매칭이다" 시각화.
-   *  things-scene 의 highlightSearchResults API 위임 (2D/3D 모두 지원). */
-  | { action: 'highlightComponents'; refids: number[] }
-
-export type BoardEditOp =
-  | { op: 'add'; component: BoardComponent }
-  | { op: 'remove'; refid: number }
-  | { op: 'modify'; refid: number; patch: Partial<BoardComponent> }
-  | { op: 'modifyBoard'; patch: Partial<BoardModel> }
-  | { op: 'replace'; board: BoardModel }
-  | { op: 'align'; refids: number[]; direction: AlignDirection }
-  | { op: 'distribute'; refids: number[]; axis: DistributeAxis }
-  | { op: 'group'; refids: number[] }
-  | { op: 'ungroup'; refid: number }
-  | { op: 'zorder'; refid: number; direction: ZorderDirection }
-  | { op: 'arrange'; refids: number[]; layout: ArrangeLayout }
-
 /**
  * BoardAIAssistant — 자연어 채팅으로 보드를 다루는 단일 인터페이스.
  *
  * 사용:
  *   const ai = new DefaultBoardAIAssistant(baseClient, { scopes: ['fmsim'] })
  *   const r = await ai.chat([{ role: 'user', content: 'AGV 3대 추가' }], currentBoard)
- *   if (r.patch) currentBoard = applyBoardEditPatch(currentBoard, r.patch)
+ *   if (r.patch) currentBoard = applyScenePatch(currentBoard, r.patch)
  */
 export interface BoardAIAssistant {
   readonly id: string

package/server/service/validation/board-model-schema.test.ts

@@ -622,7 +622,7 @@ describe('실 사용자 발견 시나리오 (회귀 방지)', () => {
   })
 })
 
-describe('BoardPatchSchema — modifyBoard 의 patch 검증', () => {
+describe('BoardPatchSchema — modifyScene 의 patch 검증', () => {
   test('빈 patch 통과 (모든 필드 optional)', () => {
     expect(BoardPatchSchema.safeParse({}).success).toBe(true)
   })
@@ -650,7 +650,7 @@ describe('BoardPatchSchema — modifyBoard 의 patch 검증', () => {
   })
 
   test('★ fillStyle 안 gradientStops (stale 이름) — 거부 (FillStyleSchema strict)', () => {
-    // 본 사고의 핵심 회귀 방지 — modifyBoard 로 gradientStops 흘러들어오면 catch
+    // 본 사고의 핵심 회귀 방지 — modifyScene 로 gradientStops 흘러들어오면 catch
     const r = BoardPatchSchema.safeParse({
       fillStyle: {
         type: 'gradient',
@@ -682,7 +682,7 @@ describe('BoardPatchSchema — modifyBoard 의 patch 검증', () => {
   })
 
   test('shadow nested unknown key — 거부 (ShadowSchema strict)', () => {
-    // 다른 alias leak 시나리오 — setShadow 의 옛 이름 'blur' 가 modifyBoard 를 통해
+    // 다른 alias leak 시나리오 — setShadow 의 옛 이름 'blur' 가 modifyScene 를 통해
     // shadow 안에 박히려 할 때 (실제로는 root 에 shadow 가 없지만 검증 흐름 보존)
     const r = BoardPatchSchema.safeParse({
       shadow: { blur: 8, offsetX: 4 } as any

package/server/service/validation/board-model-schema.ts

@@ -336,7 +336,7 @@ export const ComponentSchema = ComponentBaseSchema.superRefine((component, ctx)
  *   • 식별: id, refid, type
  *
  * ⚠ `name` 은 things-scene model-layer 가 인식 안 함 — Board *엔티티* 의 컬럼이지
- * scene MODEL 의 필드가 아님. AI 가 modifyBoard 로 name 을 보내도 죽은 필드. 검증
+ * scene MODEL 의 필드가 아님. AI 가 modifyScene 로 name 을 보내도 죽은 필드. 검증
  * 시에도 제거 / 무시 정책.
  *
  * `passthrough` 인 이유 — 3D 광원/카메라/sky 등 키가 너무 많아 strict 로는 회귀 위험
@@ -384,14 +384,14 @@ export const ComponentPatchSchema = z
   .passthrough() // 위치 / 크기 / 컴포넌트 specific 통과
 
 /**
- * modifyBoard op 의 patch — 보드 root partial.
+ * modifyScene op 의 patch — 보드 root partial.
  *
  * 모든 root 필드 optional (BoardModelSchema 와 달리 width/height 도 optional).
  * passthrough 로 알려지지 않은 root 키 (3D atmosphere, sky, camera 등) 통과.
  * 다만 *알려진 nested object* (fillStyle 등) 는 strict schema 재사용 — 그 안에
  * unknown key 가 들어오면 거부 (예: fillStyle 안 gradientStops 같은 stale 이름).
  *
- * AI 가 setFill 등에서 학습한 vocabulary 를 modifyBoard 로 echo 시킬 때 stale
+ * AI 가 setFill 등에서 학습한 vocabulary 를 modifyScene 로 echo 시킬 때 stale
  * key 가 fillStyle / shadow 같은 sub-object 안에 끼면 본 schema 가 catch.
  */
 export const BoardPatchSchema = z
@@ -438,7 +438,7 @@ export function validateComponent(component: unknown): ValidationResult {
   return { valid: false, errors: formatIssues(r.error) }
 }
 
-/** modifyBoard op 의 patch 검증. 보드 root partial. */
+/** modifyScene op 의 patch 검증. 보드 root partial. */
 export function validateBoardPatch(patch: unknown): ValidationResult {
   const r = BoardPatchSchema.safeParse(patch)
   if (r.success) return { valid: true }

package/server/service/validation/tool-validation.ts

@@ -147,7 +147,7 @@ export function validateWriteToolCall(
       }
       return { valid: true }
     }
-    case 'modifyBoard': {
+    case 'modifyScene': {
       // 보드 root partial 검증 — fillStyle/shadow 같은 nested 의 strict schema 가
       // unknown key (e.g. fillStyle.gradientStops 같은 stale 이름) 를 거부.
       // 이게 마지막 방어선 — 다른 styling tool 에서 학습된 vocabulary 가 leak 되면 catch.
@@ -159,7 +159,7 @@ export function validateWriteToolCall(
         return {
           valid: false,
           errors: formatValidationErrors(v),
-          suggestion: modifyBoardSuggestion()
+          suggestion: modifySceneSuggestion()
         }
       }
       return { valid: true }
@@ -174,7 +174,7 @@ export function validateWriteToolCall(
         return {
           valid: false,
           errors: formatValidationErrors(v),
-          suggestion: modifyBoardSuggestion()
+          suggestion: modifySceneSuggestion()
         }
       }
       return { valid: true }
@@ -186,9 +186,9 @@ export function validateWriteToolCall(
   }
 }
 
-function modifyBoardSuggestion(): string {
+function modifySceneSuggestion(): string {
   return (
-    'modifyBoard 의 patch 는 things-scene 의 model-layer 가 인식하는 root key 만 사용. ' +
+    'modifyScene 의 patch 는 things-scene 의 model-layer 가 인식하는 root key 만 사용. ' +
     'fillStyle / strokeStyle / shadow 같은 nested object 의 안쪽 필드는 canonical 이름 (colorStops 등) 정확히 사용. ' +
     'rect 등 자식 컴포넌트 변경은 modifyComponentByRefid 로 분리.'
   )

package/dist-server/service/apply-patch.d.ts

@@ -1,47 +0,0 @@
-/**
- * BoardEditPatch 를 BoardModel 에 적용하는 표준 helper.
- *
- * 호출자가 patch 응답을 받아 보드에 반영할 때 사용.
- * Pure function — 입력을 mutate 하지 않음.
- */
-import type { BoardComponent, BoardModel } from '@things-factory/board-import';
-import type { BoardEditOp, BoardEditPatch } from './types.js';
-export interface PatchApplyReport {
-    /** 패치 적용 후 보드. 모든 op 가 noop 이어도 입력 그대로 반환. */
-    board: BoardModel;
-    /** 실제로 보드를 바꾼 op 들. */
-    applied: BoardEditOp[];
-    /** id 매칭 실패 등으로 noop 이 된 op 들 — 호출자가 사용자에게 알릴 단서. */
-    missed: BoardEditOp[];
-}
-export declare function applyBoardEditPatch(board: BoardModel | undefined, patch: BoardEditPatch): BoardModel;
-/**
- * Verbose 변형 — 각 op 의 적용 여부를 보고.
- *
- * `modify` 와 `remove` 는 id 가 보드에 없으면 silent no-op 이 된다 (patch 함수의
- * 의도적 단순화). LLM 이 잘못된 id 를 만들어 보내면 사용자에게 "수정했습니다"
- * 라고 답하지만 실제로는 아무 변화도 없는 상황이 발생 — 호스트가 missed 를
- * 보고 사용자에게 경고할 수 있도록 별도 entry point 제공.
- */
-export declare function applyBoardEditPatchVerbose(board: BoardModel | undefined, patch: BoardEditPatch): PatchApplyReport;
-/**
- * 주어진 board 상태에서 op 의 inverse 를 계산.
- *
- * Revert 기능의 코어 — patch 적용 직전 board 와 op 만 알면 그 op 의 역연산을
- * 만들 수 있으므로, 호스트가 in-place 적용하면서 함께 누적해 두면 나중에
- * 역순 실행만으로 복원 가능.
- *
- * 반환:
- *   - inverse op 또는 null (unsupported / 데이터 부족)
- *   - add 의 inverse 는 add 후 발급되는 refid 가 필요해서 모델 단계에서 계산 불가 →
- *     호스트가 scene.add 직후 refid 를 캡처해 직접 만들 것 (이 함수는 pre-applied
- *     board 만 보고 만들 수 있는 종류만 처리: remove / modify / modifyBoard / replace)
- */
-export declare function computeInverseOp(board: BoardModel | undefined, op: BoardEditOp): BoardEditOp | null;
-export declare function applyOp(board: BoardModel, op: BoardEditOp): BoardModel;
-/**
- * 컴포넌트에 부분 patch 를 적용.
- * threeD 등 nested object 는 deep merge — 호출자가 색만 바꾸려고 했을 때 geometry 까지 사라지지 않도록.
- * patchVal === null 이면 해당 키를 제거한다 (위 시맨틱 참조).
- */
-export declare function mergeComponent(base: BoardComponent, patch: Partial<BoardComponent>): BoardComponent;

package/dist-server/service/apply-patch.js

@@ -1,369 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyBoardEditPatch = applyBoardEditPatch;
-exports.applyBoardEditPatchVerbose = applyBoardEditPatchVerbose;
-exports.computeInverseOp = computeInverseOp;
-exports.applyOp = applyOp;
-exports.mergeComponent = mergeComponent;
-const EMPTY_BOARD = {
-    width: 1000,
-    height: 600,
-    components: []
-};
-function applyBoardEditPatch(board, patch) {
-    return applyBoardEditPatchVerbose(board, patch).board;
-}
-/**
- * Verbose 변형 — 각 op 의 적용 여부를 보고.
- *
- * `modify` 와 `remove` 는 id 가 보드에 없으면 silent no-op 이 된다 (patch 함수의
- * 의도적 단순화). LLM 이 잘못된 id 를 만들어 보내면 사용자에게 "수정했습니다"
- * 라고 답하지만 실제로는 아무 변화도 없는 상황이 발생 — 호스트가 missed 를
- * 보고 사용자에게 경고할 수 있도록 별도 entry point 제공.
- */
-function applyBoardEditPatchVerbose(board, patch) {
-    let result = board ?? EMPTY_BOARD;
-    const applied = [];
-    const missed = [];
-    for (const op of patch.ops) {
-        if (SCENE_ONLY_OPS.has(op.op)) {
-            // model 차원 noop 이지만 scene 차원 실제 적용 — applied 로 분류.
-            applied.push(op);
-            continue;
-        }
-        const next = applyOp(result, op);
-        // componentsUnchanged 는 components 배열 동일 + width/height/fillStyle 동일 만 본다.
-        // modify / remove 의 silent no-op (ghost refid) 검출 전용 — modifyBoard 가 sky
-        // 등 다른 root 키만 바꿀 때 false negative 로 missed 분류되는 회귀 방지.
-        const componentMutating = op.op === 'modify' || op.op === 'remove';
-        if (next === result || (componentMutating && componentsUnchanged(result, next))) {
-            missed.push(op);
-        }
-        else {
-            applied.push(op);
-            result = next;
-        }
-    }
-    return { board: result, applied, missed };
-}
-function componentsUnchanged(prev, next) {
-    // applyOp 는 항상 새 객체를 만든다 (`{ ...board, components: ... }`). 따라서 reference
-    // 비교가 안 되고 내용 비교가 필요. components 는 map/filter 결과 reference 도 다를 수
-    // 있으므로 length + JSON 깊이 비교.
-    const a = prev.components ?? [];
-    const b = next.components ?? [];
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    // root meta (width/height/...) 비교
-    return prev.width === next.width && prev.height === next.height && prev.fillStyle === next.fillStyle;
-}
-/**
- * 주어진 board 상태에서 op 의 inverse 를 계산.
- *
- * Revert 기능의 코어 — patch 적용 직전 board 와 op 만 알면 그 op 의 역연산을
- * 만들 수 있으므로, 호스트가 in-place 적용하면서 함께 누적해 두면 나중에
- * 역순 실행만으로 복원 가능.
- *
- * 반환:
- *   - inverse op 또는 null (unsupported / 데이터 부족)
- *   - add 의 inverse 는 add 후 발급되는 refid 가 필요해서 모델 단계에서 계산 불가 →
- *     호스트가 scene.add 직후 refid 를 캡처해 직접 만들 것 (이 함수는 pre-applied
- *     board 만 보고 만들 수 있는 종류만 처리: remove / modify / modifyBoard / replace)
- */
-function computeInverseOp(board, op) {
-    if (!board)
-        return null;
-    const components = board.components ?? [];
-    switch (op.op) {
-        case 'add':
-            // add 의 inverse 는 새로 발급될 refid 를 알아야 → 호스트 측에서 처리
-            return null;
-        case 'remove': {
-            // 자식 refid 도 매칭 (deep search).
-            const target = findComponentDeep(components, op.refid);
-            if (!target)
-                return null; // 매칭 실패 — silent no-op 이라 inverse 도 없음
-            return { op: 'add', component: JSON.parse(JSON.stringify(target)) };
-        }
-        case 'modify': {
-            // 자식 refid 도 매칭 (deep search).
-            const target = findComponentDeep(components, op.refid);
-            if (!target)
-                return null;
-            // patch 가 건드린 키만 보관. nested 는 통째로.
-            const oldValues = {};
-            for (const k of Object.keys(op.patch || {})) {
-                const v = target[k];
-                oldValues[k] = v === undefined ? null : JSON.parse(JSON.stringify(v));
-            }
-            return { op: 'modify', refid: op.refid, patch: oldValues };
-        }
-        case 'modifyBoard': {
-            const oldValues = {};
-            const patch = op.patch || {};
-            for (const k of Object.keys(patch)) {
-                if (k === 'components')
-                    continue;
-                const v = board[k];
-                oldValues[k] = v === undefined ? null : JSON.parse(JSON.stringify(v));
-            }
-            return { op: 'modifyBoard', patch: oldValues };
-        }
-        case 'replace':
-            // 이전 보드 통째로 보관 — replace 의 자연스러운 inverse 는 또 다른 replace
-            return { op: 'replace', board: JSON.parse(JSON.stringify(board)) };
-        case 'zorder': {
-            // forward ↔ backward / front ↔ back — 단순 반전. front/back 의 inverse 는
-            // 정확하지 않을 수 있음 (front 했다가 back 하면 원래 위치 보장 X), 호스트가
-            // 정확한 inverse 를 만들려면 zorder 직전 index 를 캡처해서 명시 modify 시퀀스로.
-            // 여기서는 best-effort 만.
-            const opp = {
-                forward: 'backward',
-                backward: 'forward',
-                front: 'back',
-                back: 'front'
-            };
-            const dir = opp[op.direction];
-            if (!dir)
-                return null;
-            return { op: 'zorder', refid: op.refid, direction: dir };
-        }
-        case 'align':
-        case 'distribute':
-        case 'group':
-        case 'ungroup':
-        case 'arrange':
-            // 좌표 변경 / 부모 재구성 / 새 group refid 발급 등은 scene 호출 후에야
-            // 알 수 있음. 호스트가 직접 inverse 만든다 (변경 컴포넌트 좌표 백업 →
-            // modify 시퀀스, group 의 새 refid 캡처 → ungroup 등).
-            return null;
-        default:
-            return null;
-    }
-}
-/**
- * Scene 조작 op 들 — model 차원 시뮬레이션이 things-scene 의 결과와 일치 보장
- * 어려움 (things-scene 의 정확한 좌표 계산 / refid 발급 / 부모 재구성 로직). 따라서
- * apply-patch 에서는 noop. 호스트가 things-scene 의 정본 API (scene.align,
- * scene.distribute, scene.group/ungroup, scene.zorder) 를 직접 호출.
- *
- * verbose 분류에서는 무조건 applied 로 — model 변화가 안 보여도 scene 차원 실제 적용됨.
- */
-const SCENE_ONLY_OPS = new Set([
-    'align',
-    'distribute',
-    'group',
-    'ungroup',
-    'zorder',
-    'arrange'
-]);
-function applyOp(board, op) {
-    const components = board.components ?? [];
-    switch (op.op) {
-        case 'replace':
-            return op.board;
-        case 'add':
-            // top-level 추가 — 본 op 는 자식 컴포넌트로의 추가는 지원 안 함 (별도 op 필요)
-            return { ...board, components: [...components, op.component] };
-        case 'remove':
-            // 자식 (group/container 안) refid 도 매칭 — deep search.
-            return { ...board, components: removeComponentDeep(components, op.refid) };
-        case 'modify':
-            // 자식 refid 도 매칭 — group/container 안의 컴포넌트 수정 가능.
-            return { ...board, components: modifyComponentDeep(components, op.refid, op.patch) };
-        case 'modifyBoard': {
-            // 루트 속성 (fillStyle / width / height / name 등) 만 deep merge.
-            // components 키는 무시 — 자식 변경은 add/remove/modify 별도 op 로.
-            const patch = { ...op.patch };
-            delete patch.components;
-            return mergeBoardRoot(board, patch);
-        }
-        case 'align':
-        case 'distribute':
-        case 'group':
-        case 'ungroup':
-        case 'zorder':
-        case 'arrange':
-            // scene-only — model 차원 noop. 정본은 things-scene API 가.
-            return board;
-        default:
-            return board;
-    }
-}
-/**
- * patch 내 `null` 의 시맨틱 — **"이 키를 제거하라"**.
- *
- * 이유:
- *   1. fillStyle/strokeStyle 처럼 `string | object | undefined` 인 필드는
- *      null 로 set 하면 typeof null === 'object' 함정에 빠져 다운스트림이 크래시.
- *   2. computeInverseOp 가 base 에 키가 없던 (`undefined`) 경우 inverse 를 null
- *      로 발급 — "키 제거" 의도와 정확히 일치. 새 시맨틱 하에서 inverse 가
- *      자연스럽게 올바로 동작.
- *   3. mode 전환 시 stale 필드 정리도 새 patch 에 `oldKey: null` 만 끼워서 처리 가능.
- *
- * 호출자가 명시적으로 "null 값 자체를 set" 하고 싶으면 → 별도 op 를 도입해야 하나,
- * 현재 보드 모델에서 의미 있는 사용처가 없음.
- */
-function mergeBoardRoot(board, patch) {
-    const out = { ...board };
-    for (const key of Object.keys(patch)) {
-        const bv = board[key];
-        const pv = patch[key];
-        if (pv === null) {
-            delete out[key];
-        }
-        else if (bv !== null &&
-            typeof bv === 'object' &&
-            typeof pv === 'object' &&
-            !Array.isArray(bv) &&
-            !Array.isArray(pv)) {
-            out[key] = deepMergeRoot(bv, pv);
-        }
-        else {
-            out[key] = pv;
-        }
-    }
-    return out;
-}
-function deepMergeRoot(a, b) {
-    const out = { ...a };
-    for (const key of Object.keys(b)) {
-        const av = a[key];
-        const bv = b[key];
-        if (bv === null) {
-            delete out[key];
-        }
-        else if (av !== null &&
-            typeof av === 'object' &&
-            typeof bv === 'object' &&
-            !Array.isArray(av) &&
-            !Array.isArray(bv)) {
-            out[key] = deepMergeRoot(av, bv);
-        }
-        else {
-            out[key] = bv;
-        }
-    }
-    return out;
-}
-/**
- * 컴포넌트에 부분 patch 를 적용.
- * threeD 등 nested object 는 deep merge — 호출자가 색만 바꾸려고 했을 때 geometry 까지 사라지지 않도록.
- * patchVal === null 이면 해당 키를 제거한다 (위 시맨틱 참조).
- */
-function mergeComponent(base, patch) {
-    const out = { ...base };
-    for (const key of Object.keys(patch)) {
-        const baseVal = base[key];
-        const patchVal = patch[key];
-        if (patchVal === null) {
-            delete out[key];
-        }
-        else if (isPlainObject(baseVal) && isPlainObject(patchVal)) {
-            out[key] = deepMerge(baseVal, patchVal);
-        }
-        else {
-            out[key] = patchVal;
-        }
-    }
-    return out;
-}
-function deepMerge(a, b) {
-    const out = { ...a };
-    for (const key of Object.keys(b)) {
-        const av = a[key];
-        const bv = b[key];
-        if (bv === null) {
-            delete out[key];
-        }
-        else if (isPlainObject(av) && isPlainObject(bv)) {
-            out[key] = deepMerge(av, bv);
-        }
-        else {
-            out[key] = bv;
-        }
-    }
-    return out;
-}
-function isPlainObject(v) {
-    return v !== null && typeof v === 'object' && !Array.isArray(v);
-}
-// ── 자식 컴포넌트 (group/container 안) 까지 매칭 — deep search ─
-/**
- * 보드 트리 안에서 refid 로 컴포넌트 찾기 — 깊은 search.
- * top-level 만 보던 옛 동작 → group/container 자식도 매칭.
- */
-function findComponentDeep(components, refid) {
-    for (const c of components) {
-        if (!c)
-            continue;
-        if (c.refid === refid)
-            return c;
-        const children = c.components;
-        if (Array.isArray(children) && children.length > 0) {
-            const sub = findComponentDeep(children, refid);
-            if (sub)
-                return sub;
-        }
-    }
-    return undefined;
-}
-/**
- * modify op 의 deep 적용 — 자식 트리까지 walk 하며 매칭되는 컴포넌트만 mergeComponent.
- * Pure function — 변경 없는 가지는 같은 reference 반환 (structural sharing).
- */
-function modifyComponentDeep(components, refid, patch) {
-    let changed = false;
-    const out = components.map(c => {
-        if (!c)
-            return c;
-        if (c.refid === refid) {
-            changed = true;
-            return mergeComponent(c, patch);
-        }
-        const children = c.components;
-        if (Array.isArray(children) && children.length > 0) {
-            const updated = modifyComponentDeep(children, refid, patch);
-            if (updated !== children) {
-                changed = true;
-                return { ...c, components: updated };
-            }
-        }
-        return c;
-    });
-    return changed ? out : components;
-}
-/**
- * remove op 의 deep 적용 — 자식 트리까지 walk 하며 해당 refid 의 컴포넌트 제거.
- * 부모는 보존, 빈 group 도 보존 (group 이 비더라도 사용자가 의도적으로 만든 컨테이너일 수 있음).
- */
-function removeComponentDeep(components, refid) {
-    let changed = false;
-    const out = [];
-    for (const c of components) {
-        if (!c) {
-            out.push(c);
-            continue;
-        }
-        if (c.refid === refid) {
-            changed = true;
-            continue; // 이 컴포넌트 자체를 제거
-        }
-        const children = c.components;
-        if (Array.isArray(children) && children.length > 0) {
-            const updated = removeComponentDeep(children, refid);
-            if (updated !== children) {
-                changed = true;
-                out.push({ ...c, components: updated });
-                continue;
-            }
-        }
-        out.push(c);
-    }
-    return changed ? out : components;
-}
-//# sourceMappingURL=apply-patch.js.map