@umicat/phaser-sdk 1.0.0

package/dist/editor/EditorState.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Per-game editor state, shared between EditorBridge (postMessage handler)
+ * and EditorOverlayScene (canvas renderer + pointer source).
+ *
+ * Design 03 §13.5: in Edit mode the editor overlay captures clicks before
+ * they reach game systems; this state carries the selection + drag-in-progress
+ * info both sides read.
+ */
+/**
+ * Editor mode — slice 5. World mode edits the active world scene; HUD mode
+ * edits the HUD scene attached to that world (manifest's `scenes[].hud`).
+ * Toggled by host via `umicat:editor:setEditMode`.
+ */
+export type EditorMode = 'world' | 'hud';
+/**
+ * Editor debug-overlay flags (slice 8). Toggled by the host via
+ * `umicat:editor:setDebugOverlay`; read each frame by EditorOverlayScene.
+ */
+export interface EditorDebugOverlayState {
+    /** Draw hitbox rects + depth-anchor crosshairs on sprites with metadata. */
+    showHitboxes: boolean;
+}
+/**
+ * Tilemap painter active state (slice 6 Phase B).
+ *
+ * When the user selects a tilemap entity, the host pushes the current tool
+ * + active tile + active layer via `umicat:editor:setTilemapTool`. The SDK
+ * caches this; on canvas pointer events over the tilemap, the overlay
+ * scene reads it to drive paint behavior locally (no per-cell host
+ * round-trip — same split-state pattern as drag-to-move).
+ *
+ * After each completed stroke (pointerup), the SDK posts
+ * `umicat:sdk:tilemapEdited { entityId, op }` so the host can record an
+ * undo command + persist on save.
+ *
+ * `tilemapEditingId` doubles as the "are we in paint mode?" flag — when
+ * non-null AND the selected entity is a tilemap, paint mode is active.
+ */
+export type TilemapTool = 'brush' | 'eraser' | 'rect' | 'fill' | 'picker';
+export interface TilemapToolState {
+    /** Tilemap entity currently being painted. Null = not in paint mode. */
+    tilemapEditingId: string | null;
+    /** Which layer (within the tilemap) the brush affects. */
+    activeLayerId: string | null;
+    /** Active tool — defaults to 'brush' when entering paint mode. */
+    tool: TilemapTool;
+    /**
+     * Tile index in the layer's tileset image (0-based, row-major).
+     * Null when no tile is picked yet — brush/rect/fill no-op in that case.
+     * Eraser ignores this field.
+     */
+    activeTile: number | null;
+    /**
+     * Slice 6 Phase D — Wang terrain id when in autotile mode. Non-null
+     * flips brush + eraser to autotile semantics: the click cascades
+     * across the 3×3 cell neighborhood, vertices toggle, ruleMap[bitmask]
+     * picks the tile per cell. Null = stamp-mode (Phase B behavior).
+     */
+    activeTerrainId: string | null;
+}
+interface EditorStateShape {
+    active: boolean;
+    selectedId: string | null;
+    mode: EditorMode;
+    /**
+     * Drag-in-progress info. While set, the overlay scene mutates the entity's
+     * x/y directly per pointermove without going through the host. On
+     * pointerup it posts dragEnd with before/after, and the host pushes a
+     * single command. This is the "SDK holds short-lived visual state" path
+     * from the slice-2 design discussion.
+     */
+    drag: {
+        entityId: string;
+        startWorld: {
+            x: number;
+            y: number;
+        };
+        startEntity: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    debugOverlay: EditorDebugOverlayState;
+    /** Slice 6 Phase B — tilemap painter active state. See TilemapToolState docs. */
+    tilemap: TilemapToolState;
+    /**
+     * Slice 6 Phase B — paint-stroke accumulator. Brush/eraser collect cells
+     * during a pointer drag; on pointerup the SDK emits ONE `tilemapEdited`
+     * op carrying the whole stroke so undo reverts the entire stroke
+     * atomically. Null when no stroke is in flight.
+     */
+    tilemapStroke: {
+        entityId: string;
+        layerId: string;
+        /** Cells touched by the stroke. `index = null` for eraser cells. */
+        cells: Array<{
+            x: number;
+            y: number;
+            index: number | null;
+            prevIndex: number | null;
+        }>;
+        /**
+         * Slice 6 Phase D — autotile-mode stroke metadata. Present only when
+         * the stroke is painting with a terrain (not stamping a tile index).
+         *
+         * The `cells` array above tracks EVERY affected cell (clicked +
+         * cascade neighbors) for undo; `autotile.clickedCells` records only
+         * the user's actual click cells — that's what gets emitted in the
+         * `autotilePaint` op's `cells` field so undo can replay the inverse
+         * stroke and reproduce the cascade exactly.
+         */
+        autotile?: {
+            terrainId: string;
+            erase: boolean;
+            clickedCells: Array<{
+                x: number;
+                y: number;
+            }>;
+        };
+    } | null;
+    /**
+     * Slice 6 Phase B.4 — rect-drag in-flight state. EditorOverlayScene.update
+     * draws a preview rectangle while non-null. On pointerup the SDK composes
+     * a `fillRect` op covering startCell → endCell. Null when no rect drag.
+     */
+    tilemapRect: {
+        entityId: string;
+        layerId: string;
+        /** Cell coords (tile grid units), inclusive on both ends. */
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+        /**
+         * Slice 6 Phase D — autotile-mode rect. When set, the rect commits
+         * as one `autotilePaint` op (each in-rect cell counts as a clicked
+         * cell) instead of `fillRect`.
+         */
+        autotile?: {
+            terrainId: string;
+            erase: boolean;
+        };
+    } | null;
+    /**
+     * Slice 6 Phase B.6.1 — tilemap resize-handle drag in flight. Set on
+     * pointerdown over a corner/edge handle, cleared on pointerup. Drives:
+     * (a) live ghost-rect preview in update(), (b) computing the final
+     * resize op + transformDelta on commit.
+     *
+     * Anchor flags (left/right/top/bottom = true) mark which edges the
+     * drag moves. The opposite edges stay fixed → transformDelta keeps
+     * them anchored after the resize op rebuilds layers around the new
+     * center.
+     */
+    tilemapResize: {
+        entityId: string;
+        handle: TilemapResizeHandle;
+        /** Original size + center at drag-start, in cells + world px. */
+        startSize: {
+            width: number;
+            height: number;
+        };
+        startCenter: {
+            x: number;
+            y: number;
+        };
+        tileSize: {
+            width: number;
+            height: number;
+        };
+        /** Current preview dims (snapped to integer cells). Updated per pointermove. */
+        previewWidth: number;
+        previewHeight: number;
+        /** Current preview center (shifts as edges move). */
+        previewCenter: {
+            x: number;
+            y: number;
+        };
+    } | null;
+}
+/**
+ * Tilemap resize handle identity. 4 corners + 4 edge midpoints. Each
+ * handle defines which edges move during the drag — opposite edges stay
+ * fixed (transformDelta computed to keep them anchored).
+ */
+export type TilemapResizeHandle = 'nw' | 'ne' | 'sw' | 'se' | 'n' | 's' | 'w' | 'e';
+/**
+ * Accept any object — we only use a single internal symbol-style key, so
+ * there's no risk of collision with Phaser's own props.
+ */
+type AnyObject = object;
+export declare function getEditorState(game: AnyObject): EditorStateShape;
+export declare function setEditorActive(game: AnyObject, active: boolean): void;
+export declare function getEditorMode(game: AnyObject): EditorMode;
+export declare function setEditorMode(game: AnyObject, mode: EditorMode): void;
+export declare function setSelection(game: AnyObject, id: string | null): void;
+export declare function getSelection(game: AnyObject): string | null;
+export declare function startDrag(game: AnyObject, entityId: string, startWorld: {
+    x: number;
+    y: number;
+}, startEntity: {
+    x: number;
+    y: number;
+}): void;
+export declare function clearDrag(game: AnyObject): void;
+export declare function getDrag(game: AnyObject): EditorStateShape['drag'];
+export declare function getDebugOverlayState(game: AnyObject): EditorDebugOverlayState;
+export declare function setDebugOverlayState(game: AnyObject, patch: Partial<EditorDebugOverlayState>): void;
+export declare function getTilemapToolState(game: AnyObject): TilemapToolState;
+export declare function setTilemapToolState(game: AnyObject, patch: Partial<TilemapToolState>): void;
+export declare function isTilemapPaintMode(game: AnyObject): boolean;
+export declare function getTilemapStroke(game: AnyObject): EditorStateShape['tilemapStroke'];
+export declare function beginTilemapStroke(game: AnyObject, entityId: string, layerId: string): void;
+/**
+ * Slice 6 Phase D — start an autotile-mode stroke. Same shape as
+ * `beginTilemapStroke` but carries the autotile discriminator so the
+ * pointerup commit emits an `autotilePaint` op (not `paint` / `erase`).
+ */
+export declare function beginAutotileStroke(game: AnyObject, entityId: string, layerId: string, terrainId: string, erase: boolean): void;
+export declare function appendTilemapStrokeCell(game: AnyObject, cell: {
+    x: number;
+    y: number;
+    index: number | null;
+    prevIndex: number | null;
+}): void;
+/**
+ * Slice 6 Phase D — record a user-clicked cell + its cascade-affected
+ * cells into the stroke. Click cell goes into `autotile.clickedCells`
+ * (dedup'd, last-wins by x/y); every affected cell (including the click
+ * itself and cascade neighbors) goes into `cells` (dedup'd, FIRST-wins
+ * by x/y so `prevIndex` reflects the state at the start of the stroke).
+ */
+export declare function appendAutotileStrokeClick(game: AnyObject, clickX: number, clickY: number, affected: Array<{
+    x: number;
+    y: number;
+    index: number;
+    prevIndex: number;
+}>): void;
+export declare function endTilemapStroke(game: AnyObject): EditorStateShape['tilemapStroke'];
+export declare function getTilemapRect(game: AnyObject): EditorStateShape['tilemapRect'];
+export declare function beginTilemapRect(game: AnyObject, entityId: string, layerId: string, x: number, y: number, autotile?: {
+    terrainId: string;
+    erase: boolean;
+}): void;
+export declare function updateTilemapRect(game: AnyObject, x: number, y: number): void;
+export declare function endTilemapRect(game: AnyObject): EditorStateShape['tilemapRect'];
+export declare function getTilemapResize(game: AnyObject): EditorStateShape['tilemapResize'];
+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 {};

package/dist/editor/EditorState.js

@@ -0,0 +1,197 @@
+/**
+ * Per-game editor state, shared between EditorBridge (postMessage handler)
+ * and EditorOverlayScene (canvas renderer + pointer source).
+ *
+ * Design 03 §13.5: in Edit mode the editor overlay captures clicks before
+ * they reach game systems; this state carries the selection + drag-in-progress
+ * info both sides read.
+ */
+const KEY = '__unboxyEditorState';
+function bag(game) {
+    return game;
+}
+export function getEditorState(game) {
+    const b = bag(game);
+    const existing = b[KEY];
+    if (existing)
+        return existing;
+    const fresh = {
+        active: false,
+        selectedId: null,
+        mode: 'world',
+        drag: null,
+        debugOverlay: { showHitboxes: false },
+        tilemap: {
+            tilemapEditingId: null,
+            activeLayerId: null,
+            tool: 'brush',
+            activeTile: null,
+            activeTerrainId: null,
+        },
+        tilemapStroke: null,
+        tilemapRect: null,
+        tilemapResize: null,
+    };
+    b[KEY] = fresh;
+    return fresh;
+}
+export function setEditorActive(game, active) {
+    getEditorState(game).active = active;
+}
+export function getEditorMode(game) {
+    return getEditorState(game).mode;
+}
+export function setEditorMode(game, mode) {
+    getEditorState(game).mode = mode;
+}
+export function setSelection(game, id) {
+    getEditorState(game).selectedId = id;
+}
+export function getSelection(game) {
+    return getEditorState(game).selectedId;
+}
+export function startDrag(game, entityId, startWorld, startEntity) {
+    getEditorState(game).drag = { entityId, startWorld, startEntity };
+}
+export function clearDrag(game) {
+    getEditorState(game).drag = null;
+}
+export function getDrag(game) {
+    return getEditorState(game).drag;
+}
+export function getDebugOverlayState(game) {
+    return getEditorState(game).debugOverlay;
+}
+export function setDebugOverlayState(game, patch) {
+    const state = getEditorState(game).debugOverlay;
+    Object.assign(state, patch);
+}
+// --- Slice 6 Phase B — tilemap painter state -----------------------------
+export function getTilemapToolState(game) {
+    return getEditorState(game).tilemap;
+}
+export function setTilemapToolState(game, patch) {
+    const state = getEditorState(game).tilemap;
+    Object.assign(state, patch);
+}
+export function isTilemapPaintMode(game) {
+    const s = getEditorState(game);
+    return !!s.tilemap.tilemapEditingId && s.tilemap.tilemapEditingId === s.selectedId;
+}
+export function getTilemapStroke(game) {
+    return getEditorState(game).tilemapStroke;
+}
+export function beginTilemapStroke(game, entityId, layerId) {
+    getEditorState(game).tilemapStroke = { entityId, layerId, cells: [] };
+}
+/**
+ * Slice 6 Phase D — start an autotile-mode stroke. Same shape as
+ * `beginTilemapStroke` but carries the autotile discriminator so the
+ * pointerup commit emits an `autotilePaint` op (not `paint` / `erase`).
+ */
+export function beginAutotileStroke(game, entityId, layerId, terrainId, erase) {
+    getEditorState(game).tilemapStroke = {
+        entityId,
+        layerId,
+        cells: [],
+        autotile: { terrainId, erase, clickedCells: [] },
+    };
+}
+export function appendTilemapStrokeCell(game, cell) {
+    const stroke = getEditorState(game).tilemapStroke;
+    if (!stroke)
+        return;
+    // Dedupe — pointermove fires many times per cell on slow drags.
+    const last = stroke.cells[stroke.cells.length - 1];
+    if (last && last.x === cell.x && last.y === cell.y)
+        return;
+    stroke.cells.push(cell);
+}
+/**
+ * Slice 6 Phase D — record a user-clicked cell + its cascade-affected
+ * cells into the stroke. Click cell goes into `autotile.clickedCells`
+ * (dedup'd, last-wins by x/y); every affected cell (including the click
+ * itself and cascade neighbors) goes into `cells` (dedup'd, FIRST-wins
+ * by x/y so `prevIndex` reflects the state at the start of the stroke).
+ */
+export function appendAutotileStrokeClick(game, clickX, clickY, affected) {
+    const stroke = getEditorState(game).tilemapStroke;
+    if (!stroke || !stroke.autotile)
+        return;
+    const clicked = stroke.autotile.clickedCells;
+    const clickedLast = clicked[clicked.length - 1];
+    if (!clickedLast || clickedLast.x !== clickX || clickedLast.y !== clickY) {
+        clicked.push({ x: clickX, y: clickY });
+    }
+    // Build a fast (x,y) → index lookup into stroke.cells so we don't
+    // overwrite the first-seen prevIndex of cells already in the stroke.
+    // (Cascade neighbors get re-touched on every adjacent click; preserving
+    // their original prevIndex is what makes undo restore the pre-stroke
+    // state.) O(stroke.cells) per click is fine — strokes max out at a
+    // few hundred cells.
+    for (const a of affected) {
+        const existing = stroke.cells.findIndex((c) => c.x === a.x && c.y === a.y);
+        if (existing >= 0) {
+            // Update the latest tile index (so the resulting visual matches
+            // the on-canvas state), keep prevIndex from the first touch.
+            stroke.cells[existing].index = a.index < 0 ? null : a.index;
+        }
+        else {
+            stroke.cells.push({
+                x: a.x,
+                y: a.y,
+                index: a.index < 0 ? null : a.index,
+                prevIndex: a.prevIndex < 0 ? null : a.prevIndex,
+            });
+        }
+    }
+}
+export function endTilemapStroke(game) {
+    const stroke = getEditorState(game).tilemapStroke;
+    getEditorState(game).tilemapStroke = null;
+    return stroke;
+}
+export function getTilemapRect(game) {
+    return getEditorState(game).tilemapRect;
+}
+export function beginTilemapRect(game, entityId, layerId, x, y, autotile) {
+    getEditorState(game).tilemapRect = {
+        entityId,
+        layerId,
+        startX: x,
+        startY: y,
+        endX: x,
+        endY: y,
+        autotile,
+    };
+}
+export function updateTilemapRect(game, x, y) {
+    const rect = getEditorState(game).tilemapRect;
+    if (!rect)
+        return;
+    rect.endX = x;
+    rect.endY = y;
+}
+export function endTilemapRect(game) {
+    const rect = getEditorState(game).tilemapRect;
+    getEditorState(game).tilemapRect = null;
+    return rect;
+}
+// --- Slice 6 Phase B.6.1 — resize-handle drag ----------------------------
+export function getTilemapResize(game) {
+    return getEditorState(game).tilemapResize;
+}
+export function beginTilemapResize(game, resize) {
+    getEditorState(game).tilemapResize = resize;
+}
+export function updateTilemapResize(game, patch) {
+    const r = getEditorState(game).tilemapResize;
+    if (!r)
+        return;
+    Object.assign(r, patch);
+}
+export function endTilemapResize(game) {
+    const r = getEditorState(game).tilemapResize;
+    getEditorState(game).tilemapResize = null;
+    return r;
+}

package/dist/gamedata/GameDataModule.d.ts

@@ -0,0 +1,45 @@
+import type { Transport } from '../core/Transport.js';
+/**
+ * Game-scope key-value store shared by all players of a game.
+ *
+ * Unlike `umicat.saves` (per-user), `gameData` lives at the game level — one
+ * value per key, visible to everyone. Reads are public (anonymous players
+ * see the same data). Writes require an authenticated user; calling
+ * `set()` or `delete()` when `umicat.user === null` throws an `RpcError`
+ * with code `UNAUTHENTICATED`.
+ *
+ * Typical uses: scoreboards, shared inventories, tournament state, level
+ * of the day. Values are opaque JSON — primitive, object, or collection.
+ *
+ * Trust model (see SDK-GUIDE.md for details):
+ *   - The backend does not enforce invariants INSIDE a value. If you store
+ *     a list and append your entry, you own the read-modify-write loop —
+ *     including not mutating other players' entries, truncating to cap
+ *     the list size, and retrying on 409 conflicts.
+ *   - Use `ifVersion` to avoid lost updates when concurrent writes race.
+ *
+ * Quotas (enforced at the backend):
+ *   - 100 KB per value
+ *   - 1 MB total per game
+ *   - 64 keys per game
+ */
+export declare class GameDataModule {
+    private transport;
+    constructor(transport: Transport);
+    /** Read the value under `key`. Returns `null` if unset. Public — works for anonymous viewers. */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Write `value` under `key`. Requires an authenticated user.
+     * @param options.ifVersion — only succeed if the stored version matches; otherwise throws
+     *   an RpcError with code `VERSION_MISMATCH`. Use this to implement safe read-modify-write
+     *   loops for list values (scoreboards, shared lists).
+     * @returns the new version number.
+     */
+    set(key: string, value: unknown, options?: {
+        ifVersion?: number;
+    }): Promise<number>;
+    /** Delete the value at `key`. Requires an authenticated user. */
+    delete(key: string): Promise<boolean>;
+    /** List all keys that have a value set for this game. Public. */
+    list(): Promise<string[]>;
+}

package/dist/gamedata/GameDataModule.js

@@ -0,0 +1,59 @@
+/**
+ * Game-scope key-value store shared by all players of a game.
+ *
+ * Unlike `umicat.saves` (per-user), `gameData` lives at the game level — one
+ * value per key, visible to everyone. Reads are public (anonymous players
+ * see the same data). Writes require an authenticated user; calling
+ * `set()` or `delete()` when `umicat.user === null` throws an `RpcError`
+ * with code `UNAUTHENTICATED`.
+ *
+ * Typical uses: scoreboards, shared inventories, tournament state, level
+ * of the day. Values are opaque JSON — primitive, object, or collection.
+ *
+ * Trust model (see SDK-GUIDE.md for details):
+ *   - The backend does not enforce invariants INSIDE a value. If you store
+ *     a list and append your entry, you own the read-modify-write loop —
+ *     including not mutating other players' entries, truncating to cap
+ *     the list size, and retrying on 409 conflicts.
+ *   - Use `ifVersion` to avoid lost updates when concurrent writes race.
+ *
+ * Quotas (enforced at the backend):
+ *   - 100 KB per value
+ *   - 1 MB total per game
+ *   - 64 keys per game
+ */
+export class GameDataModule {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Read the value under `key`. Returns `null` if unset. Public — works for anonymous viewers. */
+    async get(key) {
+        const res = await this.transport.call('gameData.get', { key });
+        return (res?.value ?? null);
+    }
+    /**
+     * Write `value` under `key`. Requires an authenticated user.
+     * @param options.ifVersion — only succeed if the stored version matches; otherwise throws
+     *   an RpcError with code `VERSION_MISMATCH`. Use this to implement safe read-modify-write
+     *   loops for list values (scoreboards, shared lists).
+     * @returns the new version number.
+     */
+    async set(key, value, options) {
+        const res = await this.transport.call('gameData.set', {
+            key,
+            value,
+            ifVersion: options?.ifVersion,
+        });
+        return res.version;
+    }
+    /** Delete the value at `key`. Requires an authenticated user. */
+    async delete(key) {
+        const res = await this.transport.call('gameData.delete', { key });
+        return res.deleted;
+    }
+    /** List all keys that have a value set for this game. Public. */
+    async list() {
+        const res = await this.transport.call('gameData.list');
+        return res.keys;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+export { createUmicatGame } from './core/UmicatGame.js';
+export type { UmicatGameOptions } from './core/UmicatGame.js';
+export { UmicatScene } from './core/UmicatScene.js';
+export { ORIENTATION_DIMENSIONS } from './orientation.js';
+export type { Orientation } from './orientation.js';
+export { setupScreenshotListener, takeScreenshot } from './screenshot/ScreenshotManager.js';
+export { setupRecordingListener } from './recording/RecordingManager.js';
+export { Umicat } from './core/Umicat.js';
+export type { UmicatInitOptions } from './core/Umicat.js';
+export { SavesModule } from './saves/SavesModule.js';
+export { GameDataModule } from './gamedata/GameDataModule.js';
+export { RealtimeModule } from './realtime/RealtimeModule.js';
+export type { JoinOptions, RoomListEntry, RoomListOptions } from './realtime/RealtimeModule.js';
+export { UmicatRoom, PlayerDataFacade, RoomDataFacade, ChatFacade, MAX_CHAT_TEXT_LEN, } from './realtime/UmicatRoom.js';
+export type { ChatMessage, ChatMessageKind } from './realtime/UmicatRoom.js';
+export { RpcError } from './core/Transport.js';
+export type { Transport, TransportKind } from './core/Transport.js';
+export type { UmicatUser } from './protocol.js';
+export { loadWorldScene, preloadManifest, preloadSceneAssets, applyPixelArtFilters, getManifest, SCENES_BASE, MANIFEST_PATH, suspendSceneUpdates, } from './scene/SceneLoader.js';
+export type { LoadWorldSceneOptions } from './scene/SceneLoader.js';
+export { spawnEntity, parseColor, applyAssetHitbox, applyTilesetTileMetadata, getTilemapAt, addTilemapCollider, } from './scene/spawnEntity.js';
+export type { SpawnContext, AssetResolver, RenderScriptResolver, TilemapHit, } from './scene/spawnEntity.js';
+export { applyAutotile, findTerrain, getAutotileKind, invalidateAutotileCells, invalidateAutotileVertices, } from './scene/autotile.js';
+export type { AutotileAffectedCell } from './scene/autotile.js';
+export { EntityRegistry, attachEntityRegistry, getEntityRegistry, } from './scene/EntityRegistry.js';
+export { spawnPrefab, getPrefab, listPrefabs } from './scene/Prefabs.js';
+export type { SpawnPrefabOverrides, SpawnPrefabOptions } from './scene/Prefabs.js';
+export type { PrefabRecord, PrefabKind, PrefabPhysics, PrefabBase, SpritePrefab, RectPrefab, CirclePrefab, CodeRenderedPrefab, } from './scene/types.js';
+export { preloadRules, getRule, getRules, onRuleChange, patchRule } from './scene/Rules.js';
+export { loadWaveSchedule, runWaveSchedule } from './scene/Waves.js';
+export type { WaveCallbacks, WaveController, SpawnInstance } from './scene/Waves.js';
+export { loadGameConfig } from './scene/GameConfig.js';
+export type { GameConfig } from './scene/GameConfig.js';
+export type { WaveScheduleRecord, WaveRecord, SpawnInstruction, SpawnPointInstruction, SpawnFormationInstruction, FormationRecord, FormationShape, WaveEndCondition, } from './scene/types.js';
+export { setupEditorModeListener, isEditMode } from './scene/EditorMode.js';
+export { setRenderScriptRegistry, getRenderScriptRegistry, resolveRenderScript, } from './scene/renderScripts.js';
+export type { RenderScriptModule } from './scene/renderScripts.js';
+export { setupEditorBridge } from './editor/EditorBridge.js';
+export { EditorOverlayScene, EDITOR_OVERLAY_KEY } from './editor/EditorOverlayScene.js';
+export type { EditorEntityPatch, EditorEnterMessage, EditorExitMessage, EditorGetSceneMessage, EditorApplyEditMessage, EditorSetSelectionMessage, EditorPanZoomMessage, EditorHostToSdkMessage, EditorSceneLoadedMessage, EditorSelectionPickedMessage, EditorDragEndMessage, EditorShortcutMessage, EditorCreateEntityMessage, EditorDeleteEntityMessage, EditorSetEditModeMessage, EditorSelectionRectMessage, EditorSdkToHostMessage, } from './protocol.js';
+export { SCHEMA_VERSION, isPerFrameNinePatch, isPerFrameHitbox, } from './scene/types.js';
+export type { Manifest, SceneRef, HudRef, AssetRecord, AssetKind, SceneType, SceneFile, WorldScene, HudScene, WorldSceneConfig, CameraConfig, WorldEntity, WorldEntityKind, NonGroupWorldEntity, RenderableEntity, SpriteEntity, RectEntity, CircleEntity, CodeRenderedEntity, GroupEntity, TilemapEntity, TilemapLayer, TilesetMetadata, TileMetadata, TilesetAutotile, TilesetAnimation, WangTerrain, TriggerEntity, TriggerShape, HudEntity, HudEntityKind, HudEntityBase, HudTextEntity, HudImageEntity, HudIconButtonEntity, HudProgressBarEntity, HudPanelEntity, HudTextSource, HudNumberSource, HudLayer, Transform, Anchor, AnchorSide, NinePatchConfig, NinePatchPerFrame, HitboxRect, HitboxPerFrame, DepthAnchor, } from './scene/types.js';
+export { PROTOCOL_VERSION, type HelloMessage, type InitMessage, type RpcRequestMessage, type RpcResultOk, type RpcResultError, type HostToSdkMessage, type SdkToHostMessage, type RpcErrorPayload, type RpcMethod, type SavesGetParams, type SavesGetResult, type SavesSetParams, type SavesSetResult, type SavesDeleteParams, type SavesDeleteResult, type SavesListResult, type GameDataGetParams, type GameDataGetResult, type GameDataSetParams, type GameDataSetResult, type GameDataDeleteParams, type GameDataDeleteResult, type GameDataListResult, type RealtimeGetTokenParams, type RealtimeGetTokenResult, } from './protocol.js';

package/dist/index.js

@@ -0,0 +1,43 @@
+// Core
+export { createUmicatGame } from './core/UmicatGame.js';
+export { UmicatScene } from './core/UmicatScene.js';
+export { ORIENTATION_DIMENSIONS } from './orientation.js';
+// Screenshot
+export { setupScreenshotListener, takeScreenshot } from './screenshot/ScreenshotManager.js';
+// Recording
+export { setupRecordingListener } from './recording/RecordingManager.js';
+// Platform services (v0.2.1+)
+export { Umicat } from './core/Umicat.js';
+export { SavesModule } from './saves/SavesModule.js';
+export { GameDataModule } from './gamedata/GameDataModule.js';
+export { RealtimeModule } from './realtime/RealtimeModule.js';
+export { UmicatRoom, PlayerDataFacade, RoomDataFacade, ChatFacade, MAX_CHAT_TEXT_LEN, } from './realtime/UmicatRoom.js';
+export { RpcError } from './core/Transport.js';
+// Scene-as-data (visual editor foundation, slice 1)
+export { loadWorldScene, preloadManifest, preloadSceneAssets, applyPixelArtFilters, getManifest, SCENES_BASE, MANIFEST_PATH, suspendSceneUpdates, } from './scene/SceneLoader.js';
+export { spawnEntity, parseColor, applyAssetHitbox, applyTilesetTileMetadata, getTilemapAt, addTilemapCollider, } from './scene/spawnEntity.js';
+// Slice 6 Phase D — Wang autotile runtime.
+export { applyAutotile, findTerrain, getAutotileKind, invalidateAutotileCells, invalidateAutotileVertices, // deprecated alias kept for 0.2.122–0.2.124 callers
+ } from './scene/autotile.js';
+export { EntityRegistry, attachEntityRegistry, getEntityRegistry, } from './scene/EntityRegistry.js';
+// Prefabs — slice 11 Phase B.1 (2026-05-12). Runtime spawning of entity TYPES
+// from manifest.prefabs[]. Replaces inline `this.physics.add.sprite(...)`.
+export { spawnPrefab, getPrefab, listPrefabs } from './scene/Prefabs.js';
+// Rules — slice 11 Phase B.2 (2026-05-12). Tunable game parameters in
+// `public/rules.json`, read by behavior code via dot-notation paths.
+// Replaces `const X = ...` TS declarations for any user-tunable value.
+export { preloadRules, getRule, getRules, onRuleChange, patchRule } from './scene/Rules.js';
+// Waves — slice 11 Phase B.4 (2026-05-12). Spawn schedules as data in
+// `public/waves/<id>.json`. Replaces hand-rolled wave loops in
+// `GameScene.ts` for shooters / runners / survivors.
+export { loadWaveSchedule, runWaveSchedule } from './scene/Waves.js';
+// Game config — slice 11 Phase B.3 (2026-05-12). Top-level game settings
+// in `public/game.json` (orientation, dimensions, physics, controls).
+// Replaces hardcoded src/config.ts constants.
+export { loadGameConfig } from './scene/GameConfig.js';
+export { setupEditorModeListener, isEditMode } from './scene/EditorMode.js';
+export { setRenderScriptRegistry, getRenderScriptRegistry, resolveRenderScript, } from './scene/renderScripts.js';
+export { setupEditorBridge } from './editor/EditorBridge.js';
+export { EditorOverlayScene, EDITOR_OVERLAY_KEY } from './editor/EditorOverlayScene.js';
+export { SCHEMA_VERSION, isPerFrameNinePatch, isPerFrameHitbox, } from './scene/types.js';
+export { PROTOCOL_VERSION, } from './protocol.js';

package/dist/orientation.d.ts

@@ -0,0 +1,5 @@
+export type Orientation = 'portrait' | 'landscape';
+export declare const ORIENTATION_DIMENSIONS: Record<Orientation, {
+    width: number;
+    height: number;
+}>;

package/dist/orientation.js

@@ -0,0 +1,4 @@
+export const ORIENTATION_DIMENSIONS = {
+    landscape: { width: 1280, height: 720 },
+    portrait: { width: 720, height: 1280 },
+};