@umicat/phaser-sdk 1.0.0 → 1.0.2

package/SDK-GUIDE.md

@@ -626,10 +626,11 @@ class GameScene extends Phaser.Scene {
     // ...wire physics + input on `this.player`...
   }
   update() {
-    // Safe: loadWorldScene suspends update() during its await, so any
-    // class field assigned after `await loadWorldScene(...)` is defined
-    // by the first time update() ticks. No `if (!this.player) return;`
-    // guard needed.
+    // Safe: an async create() suspends update() until it resolves. The SDK
+    // gates this in createUmicatGame (since 1.0.1) for EVERY registered
+    // scene, so any class field assigned after ANY `await` in create() —
+    // loadWorldScene, saves.get(), umicatReady, a fetch — is defined by the
+    // first time update() ticks. No `if (!this.player) return;` guard needed.
     this.player.setVelocityX(0);
   }
 }

package/dist/core/UmicatGame.js

@@ -6,11 +6,70 @@ import { setupEditorModeListener } from '../scene/EditorMode.js';
 import { ORIENTATION_DIMENSIONS } from '../orientation.js';
 import { setRenderScriptRegistry, } from '../scene/renderScripts.js';
 import { UmicatHudScene } from '../scene/HudRuntime.js';
+/**
+ * Make a Promise-returning `create()` safe against Phaser's update loop.
+ *
+ * Phaser does NOT await an async `create()`. The moment `create()` suspends
+ * at its first `await`, Phaser flips the scene to RUNNING and starts calling
+ * `update()` every frame — so any object the game builds *after* that await
+ * (a HUD text, the player sprite) is `undefined` for those frames. An
+ * `update()` that reads it throws on every frame and the game appears frozen
+ * on the loading screen. This is a very easy trap to fall into: the docs
+ * pattern `const hi = await saves.get('highScore')` at the top of `create()`
+ * is enough to trigger it.
+ *
+ * We give async `create()` the same guarantee `preload()` already has —
+ * "update() does not run until setup is finished" — by wrapping each scene so
+ * `update()` is a no-op until the `create()` promise settles. Synchronous
+ * `create()` is untouched (it never returns a thenable, so the gate is never
+ * armed). Re-runs cleanly across `scene.restart()` since the flag lives on
+ * the scene instance and is re-armed each create().
+ */
+function guardAsyncCreate(SceneClass) {
+    const proto = SceneClass.prototype;
+    // Patch the prototype at most once, even under HMR / repeated factory calls.
+    if (proto.__umicatGuarded)
+        return;
+    const origCreate = proto.create;
+    if (typeof origCreate !== 'function')
+        return; // no create() → nothing to gate
+    proto.__umicatGuarded = true;
+    const PENDING = '__umicatCreatePending';
+    proto.create = function (...args) {
+        const ret = origCreate.apply(this, args);
+        if (ret && typeof ret.then === 'function') {
+            this[PENDING] = true;
+            Promise.resolve(ret)
+                .catch((e) => {
+                // Surface the failure instead of hanging update() forever.
+                // eslint-disable-next-line no-console
+                console.error('[umicat] async create() rejected:', e);
+            })
+                .finally(() => {
+                this[PENDING] = false;
+            });
+        }
+        return ret;
+    };
+    const origUpdate = proto.update;
+    if (typeof origUpdate === 'function') {
+        proto.update = function (...args) {
+            if (this[PENDING])
+                return undefined; // setup still running — skip this frame
+            return origUpdate.apply(this, args);
+        };
+    }
+}
 /**
  * Create an Umicat-enhanced Phaser game instance.
  * Includes built-in integrations: screenshot capture, preserveDrawingBuffer, etc.
  */
 export function createUmicatGame(options) {
+    // Harden every game scene against the async-create()/update() race before
+    // Phaser instantiates them (see guardAsyncCreate). The auto-registered
+    // UmicatHudScene is ours and uses a sync create(), so it's left alone.
+    for (const SceneClass of options.scenes)
+        guardAsyncCreate(SceneClass);
     const { width, height } = 'orientation' in options && options.orientation
         ? ORIENTATION_DIMENSIONS[options.orientation]
         : { width: options.width, height: options.height };

package/dist/core/phaser-global.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/phaser-global.js

@@ -0,0 +1,10 @@
+import Phaser from 'phaser';
+// phaser3-rex-plugins (e.g. the NinePatch plugin) were written for Phaser 3's
+// UMD build, which set a global `window.Phaser`. Their module bodies reference a
+// bare `Phaser` at eval time (e.g. `Phaser.Utils.Objects.GetValue`). Phaser 4 is
+// pure ESM and does NOT expose a global, so those plugins throw
+// "Phaser is not defined". Expose Phaser on globalThis here.
+//
+// IMPORTANT: this module must be imported BEFORE any `phaser3-rex-plugins/*`
+// import so the global exists before the plugin's top-level code evaluates.
+globalThis.Phaser = Phaser;

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

@@ -407,7 +407,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.0",
+  "version": "1.0.2",
   "description": "Umicat Phaser 3 SDK — game infrastructure for the Umicat platform",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",