@g1cloud/entity-modeler-next 5.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,6 @@
+(c) Copyright 2023 UZEN, all rights reserved.
+
+This software is the confidential and proprietary information of
+UZEN Co.,Ltd., Inc. You shall not disclose such Confidential
+Information and shall use it only in accordance with the terms of the
+license agreement you entered into with UZEN.

package/README.md

@@ -0,0 +1,42 @@
+# entity-modeler-next
+
+Vue 3 기반 비주얼 엔티티 모델링 / 클래스 다이어그램 에디터.
+레거시 GWT/Vaadin 7 모듈(`bluework-entitymodeler`)의 후속이며, `bluework4-tool`(Nuxt/Vue/Mongo)에 임베드된다.
+
+## 스택
+
+TypeScript · Vue 3 · **Vue Flow** · Pinia(비강제) · Vite(library mode) · Vitest · view는 `@g1cloud/open-bluesea-core`(BS) 컴포넌트 기반
+
+## 구조
+
+```
+src/
+  core/      논리/레이아웃 타입(분리)·resolve(정합성)·routing·autolayout·propagation·validation·타입 카탈로그. 프레임워크 무관
+  command/   Command(do/undo)·CommandStack·op/opSync(시맨틱 op emit + CAS 동시성)
+  editor/    reactive controller (CommandStack 래핑 컴포저블, EDITOR inject 키)
+  view/      Vue Flow 컴포넌트 (DiagramCanvas·EntityNode·GroupNode·AssociationEdge·PropertyPanel·ValidationPanel 등)
+  adapter/   레거시 PDiagram 매핑 (persisted v1/v2·fromPersisted/toPersisted/toPersistedV2 라운드트립)
+  agent/     자연어→op 트랙 (symbolicOp·resolver·schema·buildAgentBatch)
+  dev/       데모 하니스 (라이브러리 빌드에서 제외)
+```
+
+핵심 설계: **레이아웃이 논리 모델을 `modelId`로 참조(단방향)**. 논리 모델엔 geo/waypoint/style이 없다.
+**현재 구조·상태·문서 인덱스의 정본은 루트 `CLAUDE.md`** (저장 스키마 영향은 `docs/M0-schema-impact.md`).
+
+## 스크립트
+
+```bash
+pnpm dev        # 스파이크/데모 dev 서버
+pnpm test       # Vitest (core 단위 테스트)
+pnpm typecheck  # vue-tsc
+pnpm build      # 라이브러리 빌드 (dist/)
+```
+
+## M0 스파이크 검증 포인트 (브라우저)
+
+`pnpm dev` 후 다음을 확인:
+- 엔티티 노드가 속성 행·PK 마커와 함께 렌더되는가
+- 관계선이 **직각 라우팅**으로 그려지는가
+- 파란 **waypoint**를 드래그하면 경로가 갱신되는가
+- 세그먼트 중점(회색 원)을 **더블클릭**하면 waypoint가 추가되는가
+- 관계선 끝이 특정 **컬럼 행(앵커)**에 붙는가 (Order.id ↔ OrderLine.orderId)

package/dist/adapter/diagramAdapter.d.ts

@@ -0,0 +1,44 @@
+import { EditorState } from '../command/types';
+import { ModelId } from '../core/types';
+import { PDiagram, PDiagramV2 } from './persisted';
+export interface DiagramMeta {
+    id?: string;
+    version?: number;
+    diagramVersion?: string;
+    size?: {
+        width: number;
+        height: number;
+    };
+    packageName?: string;
+    /** 데이터 형태 세대 — 1=legacy flat, 2=logical/layout(op API 대상). 부재 시 1. */
+    schemaVersion?: number;
+    /** op 쓰기 롤아웃 게이트(불변식: true ⟹ schemaVersion>=2). v2 && false = read-only 프리즈(B-0-1). */
+    opWriteEnabled?: boolean;
+    /**
+     * v2 doc일 때 RevCache 시드(컨테이너 rev + layout/logical version). v1은 undefined.
+     * controller가 OpSyncAdapter.seed로 주입(base rev 라이브 캐시 초기화).
+     */
+    revSeed?: {
+        revs: Record<ModelId, number>;
+        layoutVersion: number;
+        logicalVersion: number;
+    };
+}
+/**
+ * 마커 분기 파서 — `schemaVersion`을 보고 v1(legacy flat) vs v2(logical/layout) 경로 선택(B-0).
+ * reload(프리즈 후 재적재)도 이 진입점을 경유해 동일 분기를 탄다.
+ */
+export declare function fromPersisted(doc: PDiagram | PDiagramV2): {
+    state: EditorState;
+    meta: DiagramMeta;
+};
+export declare function toPersisted(state: EditorState, meta?: DiagramMeta): PDiagram;
+/**
+ * v2 직렬화기 — `fromPersistedV2`의 역(near-identity). element는 core 모델 그대로 기록하고
+ * 컨테이너 rev·logical/layout version만 `meta.revSeed`에서 되붙인다(부재 시 0 시드).
+ *
+ * 마이그레이션(v1→v2 fork)은 revSeed 없는 meta로 호출 → 전 컨테이너 rev 0, version 0 시드.
+ * `id`·`opWriteEnabled`는 호출자가 meta로 제어(마이그레이션은 _id 미주입 + opWriteEnabled=true).
+ * 서버는 클라 전송 doc을 신뢰 없이 재검증(schemaVersion·sourceDiagramId·_id) — M4 §3 단위 1.
+ */
+export declare function toPersistedV2(state: EditorState, meta?: DiagramMeta): PDiagramV2;

package/dist/adapter/persisted.d.ts

@@ -0,0 +1,245 @@
+import { Association, DiagramLayout, Entity, LogicalGroup, ModelId, MultiLangText, Point } from '../core/types';
+export interface PGeo {
+    location: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+}
+export interface PStyle {
+    properties: Record<string, unknown>;
+}
+export interface PDbAttr {
+    modelId: string;
+    physicalName: string;
+    logicalName?: MultiLangText;
+    dataType: string;
+    length?: number;
+    scale?: number;
+    unique?: boolean;
+    autoIncrement?: boolean;
+    updatable?: boolean;
+    /** JPA @Column(insertable=…). undefined=기본 따름. v1 레거시엔 없는 신규 옵션. */
+    insertable?: boolean;
+    /**
+     * 공유 통화 컬럼(SHARED_REF) — 같은 엔터티 내 다른 컬럼 modelId 참조(read-only 투영, 물리 컬럼 0).
+     * 논리 모델 DbColumn.sharedColumnRef 직렬화. FK 전파용 targetModelId와는 별개 개념. v1 레거시 없음.
+     */
+    sharedColumnRef?: string;
+    /** 레거시 AttributeDatabaseAttribute.multiValue. 라운드트립 보존 전용. */
+    multiValue?: boolean;
+    /** 레거시 AttributeDatabaseAttribute.multiValueSeparator(기본 "|"). 라운드트립 보존 전용. */
+    multiValueSeparator?: string;
+    /** 레거시 AttributeDatabaseAttribute.sequenceName. 라운드트립 보존 전용. */
+    sequenceName?: string;
+    /** FK 컬럼이 참조하는 부모 PK 컬럼 modelId. 식별자 전파(derivedFrom) 재구성의 명시 링크. */
+    targetModelId?: string;
+}
+export interface PAttribute {
+    modelId: string;
+    name: string;
+    type: string;
+    customType?: string;
+    attrType: string;
+    identifier: boolean;
+    notNull: boolean;
+    transient_?: boolean;
+    description?: MultiLangText;
+    attributeGroup?: string;
+    groupCode?: string;
+    /** 레거시 AttributeModel.defaultValue. 코드성 속성은 groupCode의 code 문자열, 그 외 자유 입력. */
+    defaultValue?: string;
+    /** 레거시 AttributeModel.personalInfoAttributeType(enum 이름). 라운드트립 보존 전용. */
+    personalInfoAttributeType?: string;
+    order?: number;
+    dbAttrs: PDbAttr[];
+    style?: PStyle;
+}
+/**
+ * association end에 인라인 저장되는 속성. 레거시 실데이터는 전체 PAttribute를 인라인으로 기록하나
+ * (FK 본체·nav 참조), next-native가 기록한 문서는 `{modelId}` 참조만 가질 수 있어 둘 다 수용한다.
+ */
+export type PInlineAttribute = {
+    modelId: string;
+} & Partial<Omit<PAttribute, 'modelId'>>;
+export interface PAssocEnd {
+    endModel: {
+        refId: string;
+    };
+    multiplicity: string;
+    navigable: boolean;
+    composition: boolean;
+    jpaAttribute?: {
+        fetchType?: string;
+        cascadeTypes?: string[];
+        orphanRemoval?: boolean;
+        orderBy?: string;
+        collectionType?: string;
+        collectionTable?: string;
+        orderColumn?: string;
+    };
+    attribute?: PInlineAttribute;
+}
+export interface PAssociation {
+    modelId: string;
+    description?: string;
+    locations?: Point[];
+    end1: PAssocEnd;
+    end2: PAssocEnd;
+    style?: PStyle;
+}
+/**
+ * 레거시 OperationModel 직렬화 형태. ⚠️ description은 평문 string(PEntity/PAttribute의 MultiLangText와 비대칭).
+ * parent(back-ref)·properties 등 미매핑 키는 index signature로 수용 → 어댑터가 legacyRaw로 verbatim 보존.
+ */
+export interface POperation {
+    modelId: string;
+    name: string;
+    visibility?: string;
+    sourceCode?: string;
+    description?: string;
+    order?: number;
+    personalInfoAttributeType?: string;
+    style?: PStyle;
+    [key: string]: unknown;
+}
+export interface PEntity {
+    modelId: string;
+    name: string;
+    stereotype: string;
+    packageName?: string;
+    superClass?: string;
+    schema?: string;
+    description?: MultiLangText;
+    abstractClass?: boolean;
+    hasPersonalInfo?: boolean;
+    declarationOfInterfaces?: string[];
+    attributes: PAttribute[];
+    operations?: POperation[];
+    ownedAssociations?: PAssociation[];
+    indexes?: PIndex[];
+    jpaAttrs?: PJpaAttrs;
+    dbAttrs?: {
+        physicalName: string;
+        logicalName?: MultiLangText;
+    };
+    geo?: PGeo;
+    style?: PStyle;
+    collapsed?: boolean;
+}
+export interface PIndex {
+    modelId: string;
+    name: string;
+    unique: boolean;
+    description?: string;
+    parameters?: string;
+    indexColumns: {
+        targetColumn: {
+            refId: string;
+        };
+        descending: boolean;
+    }[];
+}
+export interface PJpaAttrs {
+    useVersion?: boolean;
+    useCacheable?: boolean;
+    useDynamicInsert?: boolean;
+    useDynamicUpdate?: boolean;
+    useDiscriminator?: boolean;
+    /** 레거시 EntityJPAAttribute discriminator 상세. 어댑터가 jpaAttrs 객체 통째 패스스루라 자동 round-trip. */
+    discriminatorColumnName?: string;
+    discriminatorType?: string;
+    discriminatorLength?: number;
+}
+export interface PGroup {
+    modelId: string;
+    name?: MultiLangText;
+    description?: string;
+    packageName?: string;
+    excludeDDLGeneration?: boolean;
+    entities?: PEntity[];
+    /** 레거시는 노트를 엔티티처럼 그룹 멤버로 중첩 저장(그룹 상대좌표). 그룹 밖 자유 노트는 PDiagram.notes. */
+    notes?: PNote[];
+    geo?: PGeo;
+    style?: PStyle;
+}
+/**
+ * 레거시 NoteModel 직렬화 형태. 연결선은 `ownedConnections`(end1/end2/locations 구조)로 저장되고
+ * next-native가 쓰는 `connections`(targetRef/waypoints)와 비대칭 — 둘 다 수용한다. `parent`(back-ref)·
+ * `properties` 등 미매핑 키는 index signature로 받아 어댑터가 legacyRaw로 verbatim 보존.
+ */
+export interface PNote {
+    modelId: string;
+    memo: string;
+    geo: PGeo;
+    style?: PStyle;
+    connections?: {
+        targetRef: string;
+        waypoints: Point[];
+    }[];
+    [key: string]: unknown;
+}
+export interface PDiagram {
+    /** Mongo _id (문자열화) */
+    id?: string;
+    /**
+     * 데이터 형태 세대(트랙 B 마커). 부재/1 = 레거시 flat(이 PDiagram 형태), 2 = logical/layout(PDiagramV2).
+     * `fromPersisted` 분기 신호. 레거시 doc은 이 필드가 없다.
+     */
+    schemaVersion?: number;
+    /** op 쓰기 롤아웃 게이트(불변식: true ⟹ schemaVersion>=2). v1 doc엔 무의미. */
+    opWriteEnabled?: boolean;
+    diagramVersion?: string;
+    version?: number;
+    size?: {
+        width: number;
+        height: number;
+    };
+    packageName?: string;
+    entities?: PEntity[];
+    groups?: PGroup[];
+    notes?: PNote[];
+}
+/** v2 logical 컨테이너 — core 모델 + 컨테이너 rev(영속 전용 CAS 메타, 파서가 RevCache로 분리). */
+export type PV2Entity = Entity & {
+    rev?: number;
+};
+export type PV2Association = Association & {
+    rev?: number;
+};
+export type PV2Group = LogicalGroup & {
+    rev?: number;
+};
+export interface PV2Logical {
+    /** logicalVersion — 거친 stale 마커(reconcile 힌트, CAS 게이트 아님). M2 §4.2. */
+    version?: number;
+    modelId: ModelId;
+    packageName?: string;
+    entities: PV2Entity[];
+    associations: PV2Association[];
+    groups: PV2Group[];
+}
+export interface PV2Layout extends DiagramLayout {
+    /** layout.version — layout op LWW CAS 게이트. M2 §4.2. */
+    version?: number;
+}
+export interface PDiagramV2 {
+    /** Mongo _id (문자열화) */
+    id?: string;
+    schemaVersion: 2;
+    /** op 쓰기 롤아웃 게이트. false = read-only 프리즈(B-0-1, 쓰기 kill-switch). */
+    opWriteEnabled?: boolean;
+    /** doc-level optlock(기존 version 계승). */
+    version?: number;
+    diagramVersion?: string;
+    packageName?: string;
+    size?: {
+        width: number;
+        height: number;
+    };
+    logical: PV2Logical;
+    layout: PV2Layout;
+}

package/dist/agent/buildAgentBatch.d.ts

@@ -0,0 +1,16 @@
+import { ModelId } from '../core/types';
+import { OpOrigin, OpShape, PersistedOpBatch } from '../command/op';
+export interface BuildAgentBatchOptions {
+    /** clientOpId(멱등 키) 발급기 — 주입 시 테스트 결정성. 기본 newId(crypto.randomUUID). */
+    mkClientOpId?: () => string;
+    /** op 출처 — 기본 'agent'(감사·aggregation 트리거 분기). REST 브리지면 'rest'. */
+    origin?: OpOrigin;
+}
+/**
+ * 에이전트/REST 경로의 stateless 배치 조립.
+ *
+ * @param diagramId 대상 diagram id(호스트 라우트가 bizModule→DBRef로 해소하므로 doc id).
+ * @param revs base rev 스냅샷(`fromPersisted(doc).meta.revSeed.revs`). 컨테이너 modelId→rev.
+ * @param ops resolver 산출 OpShape 배치(한 원자 단위).
+ */
+export declare function buildAgentBatch(diagramId: string, revs: Record<ModelId, number>, ops: OpShape[], options?: BuildAgentBatchOptions): PersistedOpBatch;

package/dist/agent/resolver.d.ts

@@ -0,0 +1,54 @@
+import { LogicalModel, ModelId } from '../core/types';
+import { OpShape } from '../command/op';
+import { AssocHandle, Handle, SymbolicOp } from './symbolicOp';
+/** 해소 실패 — 어느 심볼릭 op(`opIndex`)의 어떤 핸들이 0개/복수 매칭인지. */
+export type ResolveError = {
+    code: 'entity-not-found';
+    opIndex: number;
+    handle: Handle;
+} | {
+    code: 'entity-ambiguous';
+    opIndex: number;
+    handle: Handle;
+    matches: ModelId[];
+} | {
+    code: 'attribute-not-found';
+    opIndex: number;
+    entity: Handle;
+    handle: Handle;
+} | {
+    code: 'attribute-ambiguous';
+    opIndex: number;
+    entity: Handle;
+    handle: Handle;
+    matches: ModelId[];
+} | {
+    code: 'association-not-found';
+    opIndex: number;
+    handle: AssocHandle;
+} | {
+    code: 'association-ambiguous';
+    opIndex: number;
+    handle: AssocHandle;
+    matches: ModelId[];
+} | {
+    code: 'self-identifying';
+    opIndex: number;
+    handle: AssocHandle;
+};
+export type ResolveResult = {
+    ok: true;
+    ops: OpShape[];
+} | {
+    ok: false;
+    errors: ResolveError[];
+};
+export interface ResolverOptions {
+    /** modelId 발급기(주입 시 테스트 결정성). 기본 newId. */
+    mkId?: () => ModelId;
+}
+/**
+ * 심볼릭 op 배치를 OpShape 배치로 해소한다.
+ * 전부 해소되면 `{ok:true, ops}`, 하나라도 실패하면 `{ok:false, errors}`(모든 실패 누적 — 에이전트가 한 번에 재질의).
+ */
+export declare function resolveSymbolicOps(model: LogicalModel, ops: SymbolicOp[], options?: ResolverOptions): ResolveResult;

package/dist/agent/schema.d.ts

@@ -0,0 +1,9 @@
+type JsonSchema = Record<string, unknown>;
+/** 단일 SymbolicOp의 JSON Schema(kind로 판별되는 anyOf). $defs는 최상위에서 정의. */
+export declare const SYMBOLIC_OP_SCHEMA: JsonSchema;
+/**
+ * MCP `apply_model_ops` 도구의 input_schema. 한 배치 = 한 원자 단위(resolver가 전부 해소 or 전부 실패).
+ * description은 "언제 호출하는지"를 명시 — 최신 모델은 도구를 보수적으로 집으므로 트리거 조건이 호출률을 좌우.
+ */
+export declare const APPLY_MODEL_OPS_INPUT_SCHEMA: JsonSchema;
+export {};

package/dist/agent/symbolicOp.d.ts

@@ -0,0 +1,109 @@
+import { ClassStereotype, Multiplicity } from '../core/types';
+/**
+ * 요소 지정 핸들 — modelId 대신 이름/물리명.
+ * 엔티티: 물리명(`table.physicalName`) 우선, 논리명(`name`) 보조 — 논리명은 모델 내 중복 허용(CHK-NAME-3)이라 모호 가능.
+ * 속성: 소속 엔티티 내 속성명(`name`) 또는 컬럼 물리명(`dbAttrs[].physicalName`) — 둘 다 엔티티 내 유일(CHK-NAME-1/2).
+ */
+export interface Handle {
+    /** 매칭할 이름/물리명. */
+    ref: string;
+    /** 매칭 키 고정. 미지정 시 대상별 기본 순서로 시도(엔티티=물리명→논리명, 속성=논리명→물리명). */
+    by?: 'physicalName' | 'name';
+}
+/**
+ * 관계 지정 — 관계는 무명이라 양 끝 엔티티로 주소한다.
+ * `from`=부모(end1, PK 원천 "1"측), `to`=자식(end2, FK 보유 "N"측).
+ * 같은 (from,to) 쌍에 복수 관계가 있으면 모호 → resolver가 escalation.
+ */
+export interface AssocHandle {
+    from: Handle;
+    to: Handle;
+}
+/** entity.add 페이로드 — resolver가 modelId 발급 + 빈 골격 조립. */
+export interface EntitySpec {
+    name: string;
+    /** 기본 'JPA_ENTITY'. */
+    stereotype?: ClassStereotype;
+    /** 설정 시 `table.physicalName`. */
+    physicalName?: string;
+}
+/** attribute.add 페이로드 — resolver가 modelId 발급 + dbAttr 골격 조립. */
+export interface AttrSpec {
+    name: string;
+    /** Java 타입(예: 'Long', 'String'). */
+    type: string;
+    identifier?: boolean;
+    notNull?: boolean;
+    /** 설정 시 단일 dbAttr 컬럼 생성(미설정이면 name을 물리명으로). */
+    physicalName?: string;
+    /** dbAttr 물리 타입(예: 'BIGINT'). physicalName/dataType/length/scale 중 하나라도 있으면 dbAttr 생성. */
+    dataType?: string;
+    /** dbAttr 컬럼 길이(VARCHAR(n)·DECIMAL precision). 0/미설정은 미지정. */
+    length?: number;
+    /** dbAttr 소수 자릿수(DECIMAL/NUMERIC scale). length 동반이 일반적. 0/미설정은 미지정. */
+    scale?: number;
+}
+/** association.add 페이로드 — from/to 엔티티는 resolver가 해소, modelId 발급 + end 조립. */
+export interface AssocSpec {
+    /** 부모(end1, PK 원천). */
+    from: Handle;
+    /** 자식(end2, FK 보유). */
+    to: Handle;
+    /** end1 다중성(기본 EXACTLY_ONE_INSTANCE). */
+    fromMultiplicity?: Multiplicity;
+    /** end2 다중성(기본 ZERO_OR_MORE_INSTANCES). */
+    toMultiplicity?: Multiplicity;
+    /** 식별 관계 여부(부모 PK가 자식 PK로 전파). self-association은 식별 불가(INV-3) — resolver가 거부. */
+    identifying?: boolean;
+    /** end2 composition(부모가 자식 생명주기 소유). */
+    composition?: boolean;
+}
+/**
+ * LLM이 산출하는 단일 심볼릭 op. `kind`는 op.ts 어휘와 1:1(로케이터만 심볼릭).
+ * `patch`는 OpShape.patch와 동형(부분 patch, 그대로 전달 — 값 품질은 검증 엔진이 사후 경고).
+ */
+export type SymbolicOp = {
+    kind: 'entity.add';
+    spec: EntitySpec;
+} | {
+    kind: 'entity.update';
+    entity: Handle;
+    patch: Record<string, unknown>;
+} | {
+    kind: 'entity.remove';
+    entity: Handle;
+} | {
+    kind: 'attribute.add';
+    entity: Handle;
+    spec: AttrSpec;
+} | {
+    kind: 'attribute.update';
+    entity: Handle;
+    attribute: Handle;
+    patch: Record<string, unknown>;
+} | {
+    kind: 'attribute.remove';
+    entity: Handle;
+    attribute: Handle;
+} | {
+    kind: 'association.add';
+    spec: AssocSpec;
+} | {
+    kind: 'association.remove';
+    association: AssocHandle;
+} | {
+    kind: 'association.update';
+    association: AssocHandle;
+    patch: Record<string, unknown>;
+} | {
+    kind: 'associationEnd.update';
+    association: AssocHandle;
+    end: 'from' | 'to';
+    patch: Record<string, unknown>;
+};
+/**
+ * v1이 다루는 심볼릭 op 종류의 닫힌 집합(단일 출처). resolver·JSON Schema(`schema.ts`)가 공유한다.
+ * 아래 컴파일타임 단언이 이 튜플과 `SymbolicOp['kind']`의 일치를 강제 — 한쪽만 늘리면 타입 에러.
+ */
+export declare const SYMBOLIC_OP_KINDS: readonly ["entity.add", "entity.update", "entity.remove", "attribute.add", "attribute.update", "attribute.remove", "association.add", "association.remove", "association.update", "associationEnd.update"];
+export type SymbolicOpKind = (typeof SYMBOLIC_OP_KINDS)[number];

package/dist/command/commands.d.ts

@@ -0,0 +1,108 @@
+import { Association, AssociationEnd, AssociationLayout, Attribute, Entity, EntityIndex, Geo, LogicalGroup, ModelId, Note, Operation, Point } from '../core/types';
+import { Command } from './types';
+export declare function addEntity(entity: Entity, geo: Geo): Command;
+/** 엔티티 삭제 — 참조 관계·레이아웃·그룹 멤버십까지 cascade. memento로 위치 보존 복원. */
+export declare function removeEntity(entityId: ModelId): Command;
+/** 엔티티 필드 부분 수정 (name·stereotype·package·table·jpaAttrs·description 등). 얕은 patch. */
+export declare function updateEntity(entityId: ModelId, patch: Partial<Entity>): Command;
+export declare function renameEntity(entityId: ModelId, newName: string): Command;
+/** 엔티티 위치 이동 — 레이아웃만 변경 */
+export declare function moveEntity(entityId: ModelId, location: Point): Command;
+/**
+ * 엔티티 크기 변경 — 레이아웃만 변경 (그룹/노트 동형).
+ * 저장값은 수동 지정 크기 그대로. 콘텐츠 실측 최소 이하로의 클램프는 렌더(CSS min-content)가
+ * 담당하므로(레거시 evaluateWidth/Height = max(geo, contentMin) 동형) 여기선 raw size를 보관한다.
+ */
+export declare function resizeEntity(entityId: ModelId, size: {
+    width: number;
+    height: number;
+}): Command;
+/** 엔티티 헤더 바 색상 변경 (레이아웃만 변경) */
+export declare function setEntitySwatch(entityId: ModelId, token: string | null): Command;
+/** 엔티티 접기/펼치기 (레이아웃만 변경 — 속성/메서드 칸 렌더 게이트) */
+export declare function setEntityCollapsed(entityId: ModelId, collapsed: boolean): Command;
+/**
+ * 활성 다이어그램 전체 엔티티 접기/펼치기 (D2) — 사전 per-entity collapsed를 캡처한 단일 커맨드.
+ * N개 개별 커맨드가 아니라 한 번의 undo로 각 엔티티의 직전 상태를 그대로 복원한다(혼재 상태 보존).
+ */
+export declare function setAllEntitiesCollapsed(collapsed: boolean): Command;
+/** 속성 강조 색상 변경 (레이아웃 attributeStyles[attrId]) */
+export declare function setAttributeSwatch(entityId: ModelId, attributeId: ModelId, token: string | null): Command;
+export declare function addGroup(group: LogicalGroup, geo: Geo): Command;
+/** 그룹 필드 부분 수정 (name·description·packageName·excludeDDLGeneration). 얕은 patch. */
+export declare function updateGroup(groupId: ModelId, patch: Partial<LogicalGroup>): Command;
+/** 그룹 해제(삭제) — 멤버 엔티티는 남고 그룹/박스만 제거 */
+export declare function removeGroup(groupId: ModelId): Command;
+export declare function addEntityToGroup(groupId: ModelId, entityId: ModelId): Command;
+export declare function removeEntityFromGroup(groupId: ModelId, entityId: ModelId): Command;
+export declare function moveGroup(groupId: ModelId, location: Point): Command;
+export declare function resizeGroup(groupId: ModelId, size: {
+    width: number;
+    height: number;
+}): Command;
+export declare function addAttribute(entityId: ModelId, attribute: Attribute): Command;
+/** 속성 필드 부분 수정 (name·type·dataType·dbAttrs·identifier·notNull 등). 얕은 patch. */
+export declare function updateAttribute(entityId: ModelId, attributeId: ModelId, patch: Partial<Attribute>): Command;
+export declare function removeAttribute(entityId: ModelId, attributeId: ModelId): Command;
+/**
+ * 속성 재정렬 — 대상(attrIds)을 현재 표시 순서를 유지한 채 toIndex로 이동.
+ * 표시 순서 = attributes 배열 순서가 SoT이므로 배열을 splice 이동하고, 저장·range선택이
+ * 의존하는 order 필드를 0..n-1로 전체 재인덱싱한다(중간 삭제로 생긴 기존 갭도 함께 치유).
+ * toIndex = 대상을 모두 제거한 뒤의 배열(rest) 기준 삽입 위치.
+ * invert는 변경 전 배열 스냅샷(order 포함 얕은 복사)으로 통째 복원 → 재인덱싱 손실 없이 원자 원복.
+ */
+export declare function reorderAttributes(entityId: ModelId, attrIds: ModelId[], toIndex: number): Command;
+export declare function addOperation(entityId: ModelId, operation: Operation): Command;
+/** 메서드 필드 부분 수정 (name·visibility·sourceCode·description 등). 얕은 patch. */
+export declare function updateOperation(entityId: ModelId, operationId: ModelId, patch: Partial<Operation>): Command;
+export declare function removeOperation(entityId: ModelId, operationId: ModelId): Command;
+/**
+ * 메서드 재정렬 — reorderAttributes 동형. order 필드를 0..n-1 로 재인덱싱, invert는 스냅샷 통째 복원.
+ */
+export declare function reorderOperations(entityId: ModelId, operationIds: ModelId[], toIndex: number): Command;
+/**
+ * 메서드 강조 색상 변경 (레이아웃 operationStyles[operationId]) — setAttributeSwatch 동형.
+ * 고아 operationStyles 항목은 operationTo가 현존 operation에 한해서만 emit하므로 round-trip 무해(별도 정리 불요).
+ */
+export declare function setOperationSwatch(entityId: ModelId, operationId: ModelId, token: string | null): Command;
+export declare function addAssociation(association: Association, layout: AssociationLayout): Command;
+export declare function removeAssociation(assocId: ModelId): Command;
+/** 관계(end 제외) 필드 부분 수정 — identifying·description 등. 얕은 patch. */
+export declare function updateAssociation(assocId: ModelId, patch: Partial<Association>): Command;
+/** 관계 한쪽 끝 부분 수정 (multiplicity·navigable·composition·jpa). 얕은 patch. */
+export declare function updateAssociationEnd(assocId: ModelId, which: 'end1' | 'end2', patch: Partial<AssociationEnd>): Command;
+export declare function addIndex(entityId: ModelId, index: EntityIndex): Command;
+export declare function updateIndex(entityId: ModelId, indexId: ModelId, patch: Partial<EntityIndex>): Command;
+export declare function removeIndex(entityId: ModelId, indexId: ModelId): Command;
+export declare function moveWaypoint(assocId: ModelId, index: number, point: Point): Command;
+export declare function removeWaypoint(assocId: ModelId, index: number): Command;
+/** 관계선의 모든 waypoint를 (dx,dy)만큼 평행이동 (그룹 이동 시 내부 관계 꺾은점 동반) */
+export declare function translateWaypoints(assocId: ModelId, dx: number, dy: number): Command;
+/** 관계선의 모든 꺾은점(waypoint) 제거 → 직선화 */
+export declare function clearWaypoints(assocId: ModelId): Command;
+export declare function addWaypoint(assocId: ModelId, index: number, point: Point): Command;
+export declare function addNote(note: Note): Command;
+export declare function removeNote(noteId: ModelId): Command;
+export declare function moveNote(noteId: ModelId, location: Point): Command;
+export declare function resizeNote(noteId: ModelId, size: {
+    width: number;
+    height: number;
+}): Command;
+export declare function setNoteMemo(noteId: ModelId, memo: string): Command;
+/**
+ * 노트를 그룹 박스 멤버로 편입(레이아웃 GroupLayout.memberNoteRefs). 이미 멤버면 no-op.
+ * addEntityToGroup과 거울이나 대상이 논리(memberEntityRefs)가 아닌 레이아웃이다 — 노트가 순수
+ * 레이아웃 객체라 멤버십도 레이아웃에 둔다. 빈 슬롯을 새로 만들었으면 invert가 undefined로 환원
+ * (addNoteConnection의 createdArray 패턴 동형).
+ */
+export declare function addNoteToGroup(groupId: ModelId, noteId: ModelId): Command;
+/** 노트를 그룹 멤버에서 제외(레이아웃). removeEntityFromGroup과 거울. */
+export declare function removeNoteFromGroup(groupId: ModelId, noteId: ModelId): Command;
+/** 노트 → 대상(엔티티 등) 연결 추가. 같은 targetRef가 이미 있으면 no-op. */
+export declare function addNoteConnection(noteId: ModelId, targetRef: ModelId): Command;
+export declare function removeNoteConnection(noteId: ModelId, targetRef: ModelId): Command;
+export declare function moveNoteConnectionWaypoint(noteId: ModelId, targetRef: ModelId, index: number, point: Point): Command;
+export declare function addNoteConnectionWaypoint(noteId: ModelId, targetRef: ModelId, index: number, point: Point): Command;
+export declare function removeNoteConnectionWaypoint(noteId: ModelId, targetRef: ModelId, index: number): Command;
+export declare function clearNoteConnectionWaypoints(noteId: ModelId, targetRef: ModelId): Command;
+export declare function composite(label: string, commands: Command[], coalesceKey?: string): Command;