@zylem/editor 0.6.7 → 0.6.9

package/dist/zylem-editor.d.ts

@@ -1,5 +1,7 @@
 import { Component } from 'solid-js';
 import { LucideProps } from 'lucide-solid';
+import * as _zylem_bridge from '@zylem/bridge';
+import { BridgeDebugTool } from '@zylem/bridge';
 
 type EditorLauncherMode = 'floating' | 'hidden';
 
@@ -68,6 +70,8 @@ declare class ZylemEditorElement extends HTMLElement {
     private _config;
     private _initialized;
     private controller;
+    /** Releases this element's bridge subscription (reference-counted). */
+    private releaseBridge;
     constructor();
     /**
      * Set configuration for the editor.
@@ -93,6 +97,7 @@ declare class ZylemEditorElement extends HTMLElement {
      */
     reinitialize(): void;
     disconnectedCallback(): void;
+    private teardown;
 }
 /**
  * Register the ZylemEditorElement as a custom element.
@@ -164,53 +169,11 @@ declare class EditorEventBusWrapper {
  */
 declare const editorEvents: EditorEventBusWrapper;
 
-/**
- * Editor Events Module
- *
- * Bidirectional window CustomEvents for communication between @zylem/editor and consuming apps.
- *
- * EDITOR_STATE_DISPATCH: Editor sends state changes → external apps listen
- * EDITOR_STATE_RECEIVE: External apps send updates → editor listens
- */
-/**
- * Payload structure for editor state events.
- * Matches the nested state structure for both directions.
- */
-interface EditorUpdatePayload {
-    gameState?: {
-        debugFlag?: boolean;
-        [key: string]: unknown;
-    };
-    toolbarState?: {
-        tool?: 'select' | 'translate' | 'rotate' | 'scale' | 'delete' | 'none';
-        paused?: boolean;
-    };
-    [key: string]: unknown;
-}
-/**
- * Event name constants
- */
-declare const EDITOR_STATE_DISPATCH = "editor-state-dispatch";
-declare const EDITOR_STATE_RECEIVE = "editor-state-receive";
-declare const EDITOR_UPDATE_EVENT = "editor-state-dispatch";
-/**
- * Dispatch state changes from the editor to external consumers.
- *
- * @param payload - The state update payload
- *
- * @example
- * ```ts
- * // From GameSection when debug checkbox changes
- * dispatchEditorUpdate({ gameState: { debugFlag: true } });
- * ```
- */
-declare function dispatchEditorUpdate(payload: EditorUpdatePayload): void;
-
 /**
  * Entities state for the entities section.
  * Manages debug state and entity selection/hover.
  */
-type DebugTools = 'select' | 'translate' | 'rotate' | 'scale' | 'delete' | 'none';
+type DebugTools = 'select' | 'translate' | 'rotate' | 'scale' | 'delete' | 'add' | 'none';
 interface DebugState {
     paused: boolean;
     tool: DebugTools;
@@ -256,10 +219,20 @@ interface Vector3Like {
 interface BaseEntityInterface {
     uuid: string;
     name: string;
-    type?: string;
-    position?: Vector3Like;
-    rotation?: Vector3Like;
-    scale?: Vector3Like;
+    type?: string | undefined;
+    position?: Vector3Like | undefined;
+    rotation?: Vector3Like | undefined;
+    scale?: Vector3Like | undefined;
+    /**
+     * World-space AABB size for thumbnail rulers. Preview images themselves
+     * live in the thumbnail side-channel store, keyed by uuid, so entity state
+     * stays small enough to diff cheaply.
+     */
+    bounds?: {
+        width: number;
+        height: number;
+        depth: number;
+    } | undefined;
 }
 interface StageConfigState {
     id: string;
@@ -318,36 +291,93 @@ declare const debugStore: {
     dropTargetIndex: number | null;
 };
 
+declare const channel: _zylem_bridge.BridgeChannel;
+/**
+ * Subscribe the editor stores to game→editor bridge messages and hydrate
+ * from the channel's retained state.
+ *
+ * Reference-counted: the game gates expensive editor-only work (thumbnails,
+ * entity summaries) on these subscriptions existing, so the last editor to
+ * unmount must actually release them, while any editor still mounted must
+ * keep them alive.
+ *
+ * @returns A release function; safe to call more than once.
+ */
+declare function connectEditorBridge(): () => void;
+/** Tear down all bridge subscriptions, ignoring the reference count. */
+declare function disconnectEditorBridge(): void;
+/** Toggle the game's debug mode. */
+declare function sendDebugEnabled(enabled: boolean): void;
+/** Switch the active editor tool in the game. */
+declare function sendTool(tool: BridgeDebugTool): void;
+/** Pause or resume the game loop. */
+declare function sendPlayback(paused: boolean): void;
+/** Select an entity in the game (null clears the selection). */
+declare function sendEntitySelect(uuid: string | null): void;
+/** Focus/frame the game debug camera on an entity. */
+declare function sendEntityFocus(uuid: string): void;
+/** Write a stage variable in the running game. */
+declare function sendStageVariable(key: string, value: unknown): void;
+
 /**
  * Editor Host Helpers
  *
  * Reusable wiring for apps that embed the <zylem-editor> overlay next to a
- * running Zylem game. Consolidates the mount + state-bridge boilerplate that
- * was previously duplicated across consuming apps (examples, creator preview).
+ * running Zylem game. These helpers are thin wrappers over the shared
+ * `@zylem/bridge` channel: the game applies editor commands itself (via its
+ * bridge adapter), so hosts only need this module to mount the overlay,
+ * mirror editor commands into their own stores, or push state into the
+ * editor UI.
  */
 
+/**
+ * Nested state payload used by host-facing helpers.
+ * Mirrors the historical `editor-state-dispatch` window-event shape so
+ * existing hosts keep working; internally everything rides the bridge.
+ */
+interface EditorUpdatePayload {
+    gameState?: {
+        debugFlag?: boolean;
+        [key: string]: unknown;
+    };
+    toolbarState?: {
+        tool?: BridgeDebugTool;
+        paused?: boolean;
+    };
+    [key: string]: unknown;
+}
 interface EditorStateBridgeOptions {
     /**
-     * Called after each editor state dispatch has been applied to the
-     * game-lib debug state, so hosts can mirror the payload into their own
-     * stores (e.g. a SolidJS store).
+     * Called after each editor command has been sent to the game, so hosts
+     * can mirror the payload into their own stores (e.g. a SolidJS store).
      */
     onStateDispatch?: (payload: EditorUpdatePayload) => void;
 }
 interface EditorStateBridge {
     /** Push external app state back into the editor UI. */
     dispatchToEditor(payload: EditorUpdatePayload): void;
-    /** Remove the window listener installed by the bridge. */
+    /** Remove the bridge subscriptions installed by this helper. */
     dispose(): void;
 }
 /**
- * Dispatch a state update payload to the editor (EDITOR_STATE_RECEIVE).
- * Safe to call in non-browser environments (no-op).
+ * Push a state update payload into the editor UI (stores + game command).
+ * Safe to call in non-browser environments (no-op side effects only).
  */
 declare function dispatchToEditor(payload: EditorUpdatePayload): void;
 /**
- * Listen for editor state dispatches (EDITOR_STATE_DISPATCH) and sync them
- * into the game-lib debug state: debug flag, active tool, and pause state.
+ * Observe editor→game commands on the shared bridge.
+ *
+ * The game side applies commands itself; this helper exists so external
+ * hosts can mirror editor actions (debug toggle, tool, pause) into their own
+ * state via `onStateDispatch`.
+ *
+ * This deliberately does **not** open the editor's game→editor store
+ * subscriptions. Those are owned by `<zylem-editor>` for the duration it is
+ * mounted, and the game gates expensive work (thumbnail renders, entity
+ * summaries) on them being present. A long-lived host helper holding one open
+ * would keep that work running forever, even with no editor on screen. Hosts
+ * that render editor components without the custom element should call
+ * `connectEditorBridge()` directly and release it themselves.
  *
  * @example
  * ```ts
@@ -357,6 +387,14 @@ declare function dispatchToEditor(payload: EditorUpdatePayload): void;
  * ```
  */
 declare function attachEditorStateBridge(options?: EditorStateBridgeOptions): EditorStateBridge;
+/**
+ * Send an editor state payload as bridge commands to the running game.
+ *
+ * @deprecated Use the typed bridge commands (`sendDebugEnabled`, `sendTool`,
+ * `sendPlayback`) instead. Kept for hosts migrating off the old
+ * window-CustomEvent API.
+ */
+declare function dispatchEditorUpdate(payload: EditorUpdatePayload): void;
 interface MountZylemEditorOptions extends EditorStateBridgeOptions {
     /**
      * Controls the editor's floating launcher button.
@@ -384,4 +422,4 @@ interface MountedZylemEditor extends EditorStateBridge {
  */
 declare function mountZylemEditor(options?: MountZylemEditorOptions): MountedZylemEditor;
 
-export { EDITOR_STATE_DISPATCH, EDITOR_STATE_RECEIVE, EDITOR_UPDATE_EVENT, type EditorEvent, type EditorEventType, type EditorStateBridge, type EditorStateBridgeOptions, type EditorUpdatePayload, Icon, type MountZylemEditorOptions, type MountedZylemEditor, type ZylemEditorConfig, ZylemEditorElement, attachEditorStateBridge, debugState, debugStore, dispatchEditorUpdate, dispatchToEditor, editorEvents, gameState, mountZylemEditor, registerZylemEditor, stageState };
+export { type EditorEvent, type EditorEventType, type EditorStateBridge, type EditorStateBridgeOptions, type EditorUpdatePayload, Icon, type MountZylemEditorOptions, type MountedZylemEditor, type ZylemEditorConfig, ZylemEditorElement, attachEditorStateBridge, channel as bridgeChannel, connectEditorBridge, debugState, debugStore, disconnectEditorBridge, dispatchEditorUpdate, dispatchToEditor, editorEvents, gameState, mountZylemEditor, registerZylemEditor, sendDebugEnabled, sendEntityFocus, sendEntitySelect, sendPlayback, sendStageVariable, sendTool, stageState };