@umicat/phaser-sdk 1.0.1 → 1.0.3

package/dist/editor/EditorBridge.d.ts

@@ -2,6 +2,7 @@ import Phaser from 'phaser';
 import { AssetRecord } from '../scene/types.js';
 import { TilemapEditOp } from '../protocol.js';
 export declare function setupEditorBridge(game: Phaser.Game): void;
+export declare function postSelectionRect(game: Phaser.Game): void;
 /**
  * FB.9a — return ALL entities at the given world coords, sorted by depth
  * DESC (topmost first). Used by EditorOverlayScene's Alt+click handler

package/dist/editor/EditorBridge.js

@@ -43,6 +43,16 @@ export function setupEditorBridge(game) {
             return;
         handleMessage(game, data);
     });
+    // Boot-time edit flag (2026-06-11). When the host remounts the iframe
+    // while edit mode is on (post-save / post-agent-turn rebuild), it appends
+    // `umicatEdit=1` to the iframe URL. Enter edit IMMEDIATELY at game
+    // construction so scenes pause before their first update. Without this
+    // the game visibly plays for a second or two after every rebuild: the
+    // host's `enter` postMessage can't arrive any earlier because main.ts
+    // awaits font fetches before createUmicatGame installs this listener.
+    if (typeof window !== 'undefined' && /[?&]umicatEdit=1/.test(window.location.search)) {
+        enterEdit(game);
+    }
 }
 function handleMessage(game, msg) {
     switch (msg.type) {
@@ -134,6 +144,15 @@ function enterEdit(game) {
     restoreCanvasAfterEditor(game);
     setEditorActive(game, true);
     pauseActiveNonEditor(game);
+    // Continuous pause enforcement (2026-06-11) — the bounded 3s re-attempt
+    // loop below misses scenes that finish booting later than 3s after
+    // enter (slow CDN fetch of scene assets, etc.), and even within the
+    // window a scene can run for up to 100ms before the next tick pauses
+    // it. A PRE_STEP hook pauses any newly-active non-editor scene BEFORE
+    // its first update, for as long as edit mode is on. pauseActiveNonEditor
+    // skips already-paused scenes, so the per-frame cost is a short loop
+    // over the scene list.
+    installPauseEnforcement(game);
     // P1 infinite canvas — expand the Phaser canvas to fill its container
     // (host's iframe). Without this, the editor surface stays locked to
     // the game's intrinsic aspect ratio (720×1280 portrait, etc.) with
@@ -199,6 +218,33 @@ function enterEdit(game) {
     };
     setTimeout(reattempt, 100);
 }
+const PAUSE_ENFORCER_FLAG = '__umicatEditorPauseEnforcer';
+/**
+ * While edit mode is active, pause any non-editor scene before each game
+ * step. Catches scenes that boot AFTER enterEdit (iframe rebuild path) no
+ * matter how late — the game never visibly plays under the editor.
+ * Self-disarms via the active check; uninstalled on exitEdit.
+ */
+function installPauseEnforcement(game) {
+    const bag = game;
+    if (bag[PAUSE_ENFORCER_FLAG])
+        return;
+    const handler = () => {
+        if (!getEditorState(game).active)
+            return;
+        pauseActiveNonEditor(game);
+    };
+    game.events.on(Phaser.Core.Events.PRE_STEP, handler);
+    bag[PAUSE_ENFORCER_FLAG] = handler;
+}
+function uninstallPauseEnforcement(game) {
+    const bag = game;
+    const handler = bag[PAUSE_ENFORCER_FLAG];
+    if (!handler)
+        return;
+    game.events.off(Phaser.Core.Events.PRE_STEP, handler);
+    delete bag[PAUSE_ENFORCER_FLAG];
+}
 function pauseActiveNonEditor(game) {
     // P1 infinite canvas (2026-05-17) — use `setActive(false)` instead of
     // `pause()` so scenes STOP updating (game logic frozen) but KEEP
@@ -250,6 +296,9 @@ function exitEdit(game) {
     if (!getEditorState(game).active)
         return;
     setEditorActive(game, false);
+    // Active is false now so the enforcer self-disables, but remove the
+    // hook too — no point paying the per-frame check during play.
+    uninstallPauseEnforcement(game);
     setSelection(game, null);
     // Allow next enter to re-post the snapshot (scene file may have changed).
     delete game[SNAPSHOT_POSTED_FLAG];
@@ -407,7 +456,7 @@ function postRulesSnapshot(game) {
 // inside one RAF tick — Inspector spam (per-keystroke transform edits)
 // would otherwise spam the postMessage channel.
 const RECT_RAF_FLAG = '__unboxyEditorSelectionRectRafScheduled';
-function postSelectionRect(game) {
+export function postSelectionRect(game) {
     const bag = game;
     if (bag[RECT_RAF_FLAG])
         return;

package/dist/editor/EditorOverlayScene.d.ts

@@ -225,6 +225,11 @@ export declare class EditorOverlayScene extends Phaser.Scene {
      * stay constant size on screen regardless of how zoomed in/out.
      */
     private hitTestTilemapResizeHandle;
+    /**
+     * Shared handle hit-test body — used by both the tilemap and the
+     * rect-entity resize affordances (same 8-handle geometry).
+     */
+    private hitTestResizeHandlesAt;
     /**
      * Set canvas cursor to a resize-arrow when hovering a handle, or restore
      * default. Direction matches the handle's axis (Figma / Sketch / browser
@@ -263,6 +268,36 @@ export declare class EditorOverlayScene extends Phaser.Scene {
      * normal editTilemap dispatch (which mutates the live runtime).
      */
     private commitTilemapResize;
+    /**
+     * Selected rect entity's bounds + 8 handle positions in world coords.
+     * Returns null when the selection isn't a rect, in HUD mode, or when the
+     * rect is rotated (axis-aligned handle math would shear a rotated rect —
+     * v1 simply hides the handles there).
+     */
+    private entityResizeHandlePositions;
+    private hitTestEntityResizeHandle;
+    private beginEntityResizeDrag;
+    /**
+     * Update the in-flight rect resize from the cursor position. Edges the
+     * handle owns follow the cursor (snapped to whole pixels); opposite edges
+     * stay anchored. Applies the result to the live GameObject immediately.
+     */
+    private updateEntityResizeDrag;
+    /** Mutate the live GameObject to the preview size + center (display px). */
+    private applyEntityResizePreview;
+    /**
+     * Commit the rect resize — the GO is already at its final size (applied
+     * live per pointermove); post `entityResized` with BASE dims (entity-
+     * record units) so the host records the modify-entity command. Undo
+     * replays the `before` patch through the normal applyEdit path.
+     */
+    private commitEntityResize;
+    /**
+     * Render the 8 resize handles around the selected rect entity. No bounds
+     * outline (the blue selection rect already draws it) and no ghost rect
+     * (the live GO resizes in place during the drag).
+     */
+    private drawEntityResizeOverlay;
     update(): void;
     /**
      * Render the 8 resize handles (when paint mode is active) and the

package/dist/editor/EditorOverlayScene.js

@@ -3,8 +3,8 @@ import { getEntityRegistry } from '../scene/EntityRegistry.js';
 import { findHudEntity, findHudRegistry, UMICAT_HUD_SCENE_KEY, } from '../scene/HudRuntime.js';
 import { isPerFrameHitbox } from '../scene/types.js';
 import { getManifest } from '../scene/SceneLoader.js';
-import { getEditorState, startDrag, clearDrag, getDrag, getSelection, getEditorMode, getDebugOverlayState, getTilemapToolState, isTilemapPaintMode, beginTilemapStroke, beginAutotileStroke, appendTilemapStrokeCell, appendAutotileStrokeClick, endTilemapStroke, getTilemapStroke, beginTilemapRect, updateTilemapRect, endTilemapRect, getTilemapRect, getTilemapResize, beginTilemapResize, updateTilemapResize, endTilemapResize, } from './EditorState.js';
-import { applyTilemapOp, findTilemapLayerById, handleEditTilemap } from './EditorBridge.js';
+import { getEditorState, startDrag, clearDrag, getDrag, getSelection, getEditorMode, getDebugOverlayState, getTilemapToolState, isTilemapPaintMode, beginTilemapStroke, beginAutotileStroke, appendTilemapStrokeCell, appendAutotileStrokeClick, endTilemapStroke, getTilemapStroke, beginTilemapRect, updateTilemapRect, endTilemapRect, getTilemapRect, getTilemapResize, beginTilemapResize, updateTilemapResize, endTilemapResize, getEntityResize, beginEntityResize, updateEntityResize, endEntityResize, } from './EditorState.js';
+import { applyTilemapOp, findTilemapLayerById, handleEditTilemap, postSelectionRect } from './EditorBridge.js';
 import { applyAutotile, findTerrain, getAutotileKind } from '../scene/autotile.js';
 /**
  * Editor overlay — slice 2.
@@ -258,6 +258,16 @@ export class EditorOverlayScene extends Phaser.Scene {
             // selection so the user can click out of paint mode by clicking
             // another entity / empty canvas.
         }
+        // Rect-entity resize handles (2026-06-10) — selected rect entities get
+        // the same 8-handle resize affordance as tilemaps. Checked BEFORE the
+        // entity hit-test so grabbing an edge/corner resizes instead of
+        // re-selecting + starting a move-drag.
+        const entityHandle = this.hitTestEntityResizeHandle(px, py);
+        if (entityHandle) {
+            this.beginEntityResizeDrag(entityHandle);
+            event?.preventDefault?.();
+            return;
+        }
         const hit = this.hitTest(px, py);
         const modifiers = {
             shift: !!event?.shiftKey,
@@ -321,6 +331,13 @@ export class EditorOverlayScene extends Phaser.Scene {
             this.updateTilemapResizeDrag(px, py);
             return;
         }
+        // Rect-entity resize drag in flight — live-applies setSize + center to
+        // the GameObject per move (no ghost; Rectangle.setSize is cheap).
+        if (getEntityResize(this.game)) {
+            const { x: px, y: py } = this.pointerCoords(pointer);
+            this.updateEntityResizeDrag(px, py);
+            return;
+        }
         // Slice 6 Phase B: continue an in-flight tilemap stroke (brush/eraser
         // drag) OR rect drag. handleTilemapPaintMove already branches on
         // which one is active internally — we just need to route to it
@@ -377,6 +394,12 @@ export class EditorOverlayScene extends Phaser.Scene {
             this.commitTilemapResize();
             return;
         }
+        // Rect-entity resize drag — GO is already at the final size (live-applied
+        // per move); post `entityResized` so the host records one undo command.
+        if (getEntityResize(this.game)) {
+            this.commitEntityResize();
+            return;
+        }
         // Slice 6 Phase B: end an in-flight tilemap stroke (brush/eraser) OR
         // rect drag. Both compose a single TilemapEditOp + post `tilemapEdited`
         // so undo reverts the whole stroke/rect in one step.
@@ -1151,6 +1174,13 @@ export class EditorOverlayScene extends Phaser.Scene {
         const info = this.tilemapHandlePositions();
         if (!info)
             return null;
+        return this.hitTestResizeHandlesAt(worldX, worldY, info);
+    }
+    /**
+     * Shared handle hit-test body — used by both the tilemap and the
+     * rect-entity resize affordances (same 8-handle geometry).
+     */
+    hitTestResizeHandlesAt(worldX, worldY, info) {
         const cam = this.findActiveEditorCamera();
         const zoom = cam?.zoom ?? 1;
         const halfHandleWorld = 7 / zoom; // 14px square = 7px half-side
@@ -1202,13 +1232,22 @@ export class EditorOverlayScene extends Phaser.Scene {
             return;
         let handle = null;
         const inDrag = getTilemapResize(this.game);
+        const inEntityDrag = getEntityResize(this.game);
         if (inDrag) {
             handle = inDrag.handle;
         }
+        else if (inEntityDrag) {
+            handle = inEntityDrag.handle;
+        }
         else if (isTilemapPaintMode(this.game)) {
             const { x, y } = this.pointerCoords(pointer);
             handle = this.hitTestTilemapResizeHandle(x, y);
         }
+        else {
+            // Rect-entity handles — hover feedback whenever a rect is selected.
+            const { x, y } = this.pointerCoords(pointer);
+            handle = this.hitTestEntityResizeHandle(x, y);
+        }
         if (!handle) {
             // Only reset when WE set it earlier; don't clobber pan-grab or other
             // cursor states future features might add.
@@ -1350,6 +1389,198 @@ export class EditorOverlayScene extends Phaser.Scene {
             window.parent.postMessage(message, '*');
         }
     }
+    // --- Rect-entity resize-handle drag (2026-06-10) --------------------------
+    //
+    // Same 8-handle affordance as the tilemap resize above, generalized to
+    // rect entities: handles render whenever a rect entity is selected (no
+    // paint-mode gate — rects have no paint mode), sizes are pixel-based
+    // (no cell snapping), and the live GameObject is mutated during the drag
+    // because Rectangle.setSize is cheap (tilemap resize rebuilds layers, so
+    // it previews with a ghost rect instead). Commit posts `entityResized`
+    // so the host records ONE modify-entity command — undo/redo + Cmd+S
+    // persistence ride the existing flat-patch path (width/height at the
+    // patch root, center shift in transform.x/y).
+    /**
+     * Selected rect entity's bounds + 8 handle positions in world coords.
+     * Returns null when the selection isn't a rect, in HUD mode, or when the
+     * rect is rotated (axis-aligned handle math would shear a rotated rect —
+     * v1 simply hides the handles there).
+     */
+    entityResizeHandlePositions() {
+        if (getEditorMode(this.game) === 'hud')
+            return null;
+        const selectedId = getSelection(this.game);
+        if (!selectedId)
+            return null;
+        const registry = this.findEntityRegistry();
+        if (!registry)
+            return null;
+        const go = registry.byId(selectedId);
+        if (!go || go.getData('entityKind') !== 'rect')
+            return null;
+        const rect = go;
+        if (rect.rotation)
+            return null;
+        const pxW = rect.displayWidth ?? 0;
+        const pxH = rect.displayHeight ?? 0;
+        if (pxW <= 0 || pxH <= 0)
+            return null;
+        const cx = rect.x;
+        const cy = rect.y;
+        const left = cx - pxW / 2;
+        const right = cx + pxW / 2;
+        const top = cy - pxH / 2;
+        const bottom = cy + pxH / 2;
+        return {
+            entityId: selectedId,
+            center: { x: cx, y: cy },
+            pxW,
+            pxH,
+            handles: [
+                { id: 'nw', x: left, y: top },
+                { id: 'n', x: cx, y: top },
+                { id: 'ne', x: right, y: top },
+                { id: 'e', x: right, y: cy },
+                { id: 'se', x: right, y: bottom },
+                { id: 's', x: cx, y: bottom },
+                { id: 'sw', x: left, y: bottom },
+                { id: 'w', x: left, y: cy },
+            ],
+        };
+    }
+    hitTestEntityResizeHandle(worldX, worldY) {
+        const info = this.entityResizeHandlePositions();
+        if (!info)
+            return null;
+        return this.hitTestResizeHandlesAt(worldX, worldY, info);
+    }
+    beginEntityResizeDrag(handle) {
+        const info = this.entityResizeHandlePositions();
+        if (!info)
+            return;
+        beginEntityResize(this.game, {
+            entityId: info.entityId,
+            handle,
+            startSize: { width: info.pxW, height: info.pxH },
+            startCenter: { x: info.center.x, y: info.center.y },
+            previewWidth: info.pxW,
+            previewHeight: info.pxH,
+            previewCenter: { x: info.center.x, y: info.center.y },
+        });
+    }
+    /**
+     * Update the in-flight rect resize from the cursor position. Edges the
+     * handle owns follow the cursor (snapped to whole pixels); opposite edges
+     * stay anchored. Applies the result to the live GameObject immediately.
+     */
+    updateEntityResizeDrag(worldX, worldY) {
+        const resize = getEntityResize(this.game);
+        if (!resize)
+            return;
+        const MIN_SIZE = 2; // px — keeps the rect grabbable
+        const { handle, startSize, startCenter } = resize;
+        let newLeft = startCenter.x - startSize.width / 2;
+        let newRight = startCenter.x + startSize.width / 2;
+        let newTop = startCenter.y - startSize.height / 2;
+        let newBottom = startCenter.y + startSize.height / 2;
+        const movesLeft = handle === 'nw' || handle === 'w' || handle === 'sw';
+        const movesRight = handle === 'ne' || handle === 'e' || handle === 'se';
+        const movesTop = handle === 'nw' || handle === 'n' || handle === 'ne';
+        const movesBottom = handle === 'sw' || handle === 's' || handle === 'se';
+        if (movesLeft)
+            newLeft = Math.min(Math.round(worldX), newRight - MIN_SIZE);
+        if (movesRight)
+            newRight = Math.max(Math.round(worldX), newLeft + MIN_SIZE);
+        if (movesTop)
+            newTop = Math.min(Math.round(worldY), newBottom - MIN_SIZE);
+        if (movesBottom)
+            newBottom = Math.max(Math.round(worldY), newTop + MIN_SIZE);
+        const previewWidth = newRight - newLeft;
+        const previewHeight = newBottom - newTop;
+        const previewCenter = {
+            x: (newLeft + newRight) / 2,
+            y: (newTop + newBottom) / 2,
+        };
+        updateEntityResize(this.game, { previewWidth, previewHeight, previewCenter });
+        this.applyEntityResizePreview(resize.entityId, previewWidth, previewHeight, previewCenter);
+    }
+    /** Mutate the live GameObject to the preview size + center (display px). */
+    applyEntityResizePreview(entityId, displayW, displayH, center) {
+        const registry = this.findEntityRegistry();
+        const go = registry?.byId(entityId);
+        if (!go)
+            return;
+        // setSize takes BASE dims; divide the display size by the transform
+        // scale (palette rects spawn at scale 1, but be correct regardless).
+        const sx = go.scaleX || 1;
+        const sy = go.scaleY || 1;
+        go.setSize?.(displayW / sx, displayH / sy);
+        go.x = center.x;
+        go.y = center.y;
+    }
+    /**
+     * Commit the rect resize — the GO is already at its final size (applied
+     * live per pointermove); post `entityResized` with BASE dims (entity-
+     * record units) so the host records the modify-entity command. Undo
+     * replays the `before` patch through the normal applyEdit path.
+     */
+    commitEntityResize() {
+        const resize = endEntityResize(this.game);
+        if (!resize)
+            return;
+        const { entityId, startSize, startCenter, previewWidth, previewHeight, previewCenter } = resize;
+        if (previewWidth === startSize.width &&
+            previewHeight === startSize.height &&
+            previewCenter.x === startCenter.x &&
+            previewCenter.y === startCenter.y) {
+            return;
+        }
+        const registry = this.findEntityRegistry();
+        const go = registry?.byId(entityId);
+        const sx = go?.scaleX || 1;
+        const sy = go?.scaleY || 1;
+        const message = {
+            type: 'umicat:editor:entityResized',
+            entityId,
+            before: {
+                x: startCenter.x,
+                y: startCenter.y,
+                width: startSize.width / sx,
+                height: startSize.height / sy,
+            },
+            after: {
+                x: previewCenter.x,
+                y: previewCenter.y,
+                width: previewWidth / sx,
+                height: previewHeight / sy,
+            },
+        };
+        if (typeof window !== 'undefined' && window.parent) {
+            window.parent.postMessage(message, '*');
+        }
+        // The selection rect changed size — refresh the host's anchor rect.
+        postSelectionRect(this.game);
+    }
+    /**
+     * Render the 8 resize handles around the selected rect entity. No bounds
+     * outline (the blue selection rect already draws it) and no ghost rect
+     * (the live GO resizes in place during the drag).
+     */
+    drawEntityResizeOverlay() {
+        const info = this.entityResizeHandlePositions();
+        if (!info)
+            return;
+        const cam = this.findActiveEditorCamera();
+        const zoom = cam?.zoom ?? 1;
+        const handleSize = 14 / zoom; // 14px on screen regardless of zoom
+        const half = handleSize / 2;
+        for (const h of info.handles) {
+            this.graphics.fillStyle(0xffffff, 1);
+            this.graphics.fillRect(h.x - half, h.y - half, handleSize, handleSize);
+            this.graphics.fillStyle(SELECTION_COLOR, 1);
+            this.graphics.fillRect(h.x - half + 1.5 / zoom, h.y - half + 1.5 / zoom, handleSize - 3 / zoom, handleSize - 3 / zoom);
+        }
+    }
     update() {
         this.graphics.clear();
         // Slice 6 Phase B (fix): sync tilemap layer world positions to their
@@ -1473,6 +1704,9 @@ export class EditorOverlayScene extends Phaser.Scene {
         // host Inspector). Ghost rect preview shows the new bounds during
         // an active resize drag.
         this.drawTilemapResizeOverlay();
+        // Rect-entity resize handles — render whenever a rect entity is
+        // selected (2026-06-10).
+        this.drawEntityResizeOverlay();
     }
     /**
      * Render the 8 resize handles (when paint mode is active) and the

package/dist/editor/EditorState.d.ts

@@ -177,6 +177,32 @@ interface EditorStateShape {
             y: number;
         };
     } | null;
+    /**
+     * Rect-entity resize-handle drag in flight (2026-06-10). Same handle
+     * mechanics as tilemapResize but pixel-based (no cell snapping) and the
+     * live GameObject is mutated during the drag — Rectangle.setSize is cheap,
+     * unlike tilemap layer rebuilds, so the user sees the real rect resize
+     * rather than a ghost preview. All sizes are DISPLAY px (scale applied);
+     * the commit converts back to base dims before posting `entityResized`.
+     */
+    entityResize: {
+        entityId: string;
+        handle: TilemapResizeHandle;
+        startSize: {
+            width: number;
+            height: number;
+        };
+        startCenter: {
+            x: number;
+            y: number;
+        };
+        previewWidth: number;
+        previewHeight: number;
+        previewCenter: {
+            x: number;
+            y: number;
+        };
+    } | null;
 }
 /**
  * Tilemap resize handle identity. 4 corners + 4 edge midpoints. Each
@@ -248,4 +274,8 @@ export declare function getTilemapResize(game: AnyObject): EditorStateShape['til
 export declare function beginTilemapResize(game: AnyObject, resize: NonNullable<EditorStateShape['tilemapResize']>): void;
 export declare function updateTilemapResize(game: AnyObject, patch: Partial<Pick<NonNullable<EditorStateShape['tilemapResize']>, 'previewWidth' | 'previewHeight' | 'previewCenter'>>): void;
 export declare function endTilemapResize(game: AnyObject): EditorStateShape['tilemapResize'];
+export declare function getEntityResize(game: AnyObject): EditorStateShape['entityResize'];
+export declare function beginEntityResize(game: AnyObject, resize: NonNullable<EditorStateShape['entityResize']>): void;
+export declare function updateEntityResize(game: AnyObject, patch: Partial<Pick<NonNullable<EditorStateShape['entityResize']>, 'previewWidth' | 'previewHeight' | 'previewCenter'>>): void;
+export declare function endEntityResize(game: AnyObject): EditorStateShape['entityResize'];
 export {};

package/dist/editor/EditorState.js

@@ -31,6 +31,7 @@ export function getEditorState(game) {
         tilemapStroke: null,
         tilemapRect: null,
         tilemapResize: null,
+        entityResize: null,
     };
     b[KEY] = fresh;
     return fresh;
@@ -195,3 +196,21 @@ export function endTilemapResize(game) {
     getEditorState(game).tilemapResize = null;
     return r;
 }
+// --- Rect-entity resize-handle drag (2026-06-10) --------------------------
+export function getEntityResize(game) {
+    return getEditorState(game).entityResize;
+}
+export function beginEntityResize(game, resize) {
+    getEditorState(game).entityResize = resize;
+}
+export function updateEntityResize(game, patch) {
+    const r = getEditorState(game).entityResize;
+    if (!r)
+        return;
+    Object.assign(r, patch);
+}
+export function endEntityResize(game) {
+    const r = getEditorState(game).entityResize;
+    getEditorState(game).entityResize = null;
+    return r;
+}

package/dist/protocol.d.ts

@@ -638,6 +638,36 @@ export interface EditorDragEndMessage {
         y: number;
     };
 }
+/**
+ * Rect-entity resize-handle drag completed (2026-06-10).
+ *
+ * Selected rect entities get the same 8-handle (4 corners + 4 edges)
+ * resize affordance as tilemaps. The SDK applies the new size + center to
+ * the live GameObject during the drag (Rectangle.setSize is cheap); on
+ * pointer-up it posts this message so the host records ONE modify-entity
+ * command for undo + flush — mirrors how `dragEnd` works for moves.
+ *
+ * `width` / `height` are the entity record's BASE dims (display px divided
+ * by transform scale), i.e. exactly what belongs in `RectEntity.width/
+ * height`. `x` / `y` are the entity transform's center position — it shifts
+ * during a resize because the opposite edge stays anchored.
+ */
+export interface EditorEntityResizedMessage {
+    type: 'umicat:editor:entityResized';
+    entityId: string;
+    before: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    after: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
 /**
  * Editor keyboard shortcut intercepted inside the iframe (user clicked the
  * canvas, so focus is on the iframe and the host window doesn't see the
@@ -746,7 +776,7 @@ export interface EditorTilemapTilePickedMessage {
     layerId: string;
     tileIndex: number | null;
 }
-export type EditorSdkToHostMessage = EditorSceneLoadedMessage | EditorSelectionPickedMessage | EditorDragEndMessage | EditorShortcutMessage | EditorSelectionRectMessage | EditorRulesLoadedMessage | EditorCameraStateMessage | EditorTilemapEditedMessage | EditorTilemapTilePickedMessage;
+export type EditorSdkToHostMessage = EditorSceneLoadedMessage | EditorSelectionPickedMessage | EditorDragEndMessage | EditorEntityResizedMessage | EditorShortcutMessage | EditorSelectionRectMessage | EditorRulesLoadedMessage | EditorCameraStateMessage | EditorTilemapEditedMessage | EditorTilemapTilePickedMessage;
 export type RpcMethod = 'saves.get' | 'saves.set' | 'saves.delete' | 'saves.list' | 'gameData.get' | 'gameData.set' | 'gameData.delete' | 'gameData.list' | 'realtime.getToken';
 export interface SavesGetParams {
     key: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umicat/phaser-sdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Umicat Phaser 3 SDK — game infrastructure for the Umicat platform",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",