@combos-fun/plugin-development-tool 0.0.27 → 0.0.28

package/dist/plugin-development-tool.d.ts

@@ -1,4 +1,4 @@
-import { Component, ComponentParams, System, UpdateParams, ComponentChanged, GameObject } from '@combos-fun/engine';
+import { GameObject, Component, ComponentParams, System, UpdateParams, ComponentChanged } from '@combos-fun/engine';
 
 /** Toggle development-tool selection / parent postMessage. Payload: `{ enabled: boolean }`. */
 declare const COMBOS_DEVELOPMENT_TOOL_SET: "combos-development-tool:set";
@@ -25,6 +25,72 @@ declare const COMBOS_DEVELOPMENT_TOOL_READY: "combos-development-tool:ready";
 declare const COMBOS_DEVELOPMENT_TOOL_SET_MUTED: "combos-development-tool:set-muted";
 /** iframe → parent (and `game.emit`): current mute snapshot after a successful change. */
 declare const COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED: "combos-development-tool:state-changed";
+/**
+ * Parent → iframe (also `window` CustomEvent / `game.emit`): toggle the marker
+ * overlay — a persistent, clickable icon on every object owning an otherwise
+ * invisible registered component (Sound first). Independent of pick mode and
+ * mute. Payload: `{ enabled: boolean }`.
+ */
+declare const COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY: "combos-development-tool:set-marker-overlay";
+/**
+ * iframe → parent (and `game.emit`): marker overlay finished (re)building.
+ * Payload: `{ enabled: boolean, total: number, markers: { componentName, count }[] }`.
+ */
+declare const COMBOS_DEVELOPMENT_TOOL_MARKER_OVERLAY_SUCCESS: "combos-development-tool:marker-overlay-success";
+
+/**
+ * Marker overlay = a reusable "pin a persistent, clickable icon on every object
+ * that owns an otherwise-invisible component" capability. Audio (`Sound`) is the
+ * first consumer; register more component kinds below (Physics, Camera, Trigger,
+ * timers, spawn points, …) to reuse the exact same layer.
+ */
+/** Glyph drawn inside a marker badge. Extend as new component kinds are added. */
+type MarkerGlyph = 'speaker' | 'dot';
+/** One kind of invisible component the overlay surfaces with a pinned icon. */
+interface MarkerComponentDef {
+    /** Engine component name to look for on each GameObject, e.g. `'Sound'`. */
+    componentName: string;
+    /** Badge fill color, `0xRRGGBB`. */
+    badgeColor: number;
+    /** Which glyph to draw inside the badge. */
+    glyph: MarkerGlyph;
+}
+/**
+ * Registered marker kinds, in priority order: a GameObject is marked by the
+ * first registered component it owns. For now this is **`Sound` only**; the
+ * mechanism is generic (append Physics / Camera / triggers / spawn points later
+ * to reuse the same layer) but only audio is wanted right now.
+ */
+declare const MARKER_COMPONENTS: readonly MarkerComponentDef[];
+/** Fixed badge size in the owner's local space. */
+declare const MARKER_ICON_SIZE = 28;
+/**
+ * First registered marker def whose component is present on `go`, else `null`.
+ * Priority follows {@link MARKER_COMPONENTS} order.
+ */
+declare function resolveMarkerDef(go: Pick<GameObject, 'getComponent'>, registry?: readonly MarkerComponentDef[]): MarkerComponentDef | null;
+/**
+ * Minimal subset of the PixiGraphics v8 surface the marker drawing uses. Keeps
+ * this module decoupled from the renderer and unit-testable with a mock.
+ */
+interface MarkerGraphicsLike {
+    clear(): unknown;
+    roundRect(x: number, y: number, width: number, height: number, radius?: number): unknown;
+    rect(x: number, y: number, width: number, height: number): unknown;
+    circle(x: number, y: number, radius: number): unknown;
+    poly(points: number[], close?: boolean): unknown;
+    fill(style: {
+        color: number;
+        alpha?: number;
+    }): unknown;
+    stroke(style: {
+        width: number;
+        color: number;
+        alpha?: number;
+    }): unknown;
+}
+/** Render a full marker (badge + glyph) into `g`, sized to `size` (local units). */
+declare function drawMarkerIcon(g: MarkerGraphicsLike, def: MarkerComponentDef, size?: number): void;
 
 /** Default inbound postMessage host suffixes (host + all subdomains). */
 declare const DEFAULT_ALLOWED_MESSAGE_HOST_SUFFIXES: readonly ["knoffice.tech", "converge.ai"];
@@ -103,8 +169,22 @@ declare class CombosDevelopmentToolSystem extends System<CombosDevelopmentToolSy
     private lastOutlineBounds;
     /** Remembered mute when `SoundSystem` is not registered yet. */
     private mutedWithoutSoundSystem;
+    /**
+     * Marker overlay (see {@link markerLayer}): a visual-only icon layer, toggled
+     * independently of pick mode + mute. Selection/persistence are NOT handled here
+     * — a marked object (e.g. Sound) carries its own `CombosDevelopmentToolTarget`
+     * (added by the game code), so it is picked and serialized through the normal
+     * Target path. The icon just makes the invisible object visible and, by adding
+     * to the owner's rendered bounds, gives its Target pick a clickable hit area.
+     */
+    private markerOverlayEnabled;
+    private needsMarkerRescan;
+    /** ownerGoId → its marker GO (icon child, Graphics only). */
+    private readonly markerGoByOwner;
     private readonly onWindowSet;
     private readonly onWindowSetMuted;
+    private readonly onWindowSetMarkerOverlay;
+    private readonly onGameSetMarkerOverlay;
     private readonly onWindowMessage;
     private readonly onGameSet;
     private readonly onGameRefresh;
@@ -115,6 +195,17 @@ declare class CombosDevelopmentToolSystem extends System<CombosDevelopmentToolSy
     /** Programmatic toggle (same effect as events). */
     setEnabled(on: boolean): void;
     get isEnabled(): boolean;
+    /**
+     * Toggle the marker overlay: pin a persistent icon on every object that owns a
+     * registered invisible component ({@link markerLayer}, Sound first). Independent
+     * of pick mode / mute. This layer is purely visual — the icon makes the object
+     * visible and adds to its rendered bounds so the owner's own
+     * `CombosDevelopmentToolTarget` pick gets a clickable hit area. Selecting and
+     * persisting edits (e.g. volume) still go through that Target, exactly like any
+     * other scene edit, so the object must carry a Target (added by the game code).
+     */
+    setMarkerOverlay(on: boolean): void;
+    get isMarkerOverlayEnabled(): boolean;
     /** Master mute when `SoundSystem` exists; otherwise the last requested value. */
     get isMuted(): boolean;
     /**
@@ -124,11 +215,12 @@ declare class CombosDevelopmentToolSystem extends System<CombosDevelopmentToolSy
     setMuted(muted: boolean): void;
     update(e: UpdateParams): void;
     componentChanged(changed: ComponentChanged): void;
-    /** Re-bind pick targets after dynamic scene changes while enabled. */
+    /** Re-bind pick targets / markers after dynamic scene changes while active. */
     requestSceneRescan(): void;
     private attachEditMode;
     private collectGameObjects;
     private isIgnoredPickGo;
+    private isMarkerGo;
     private stripGameEvent;
     private restoreDisabledGameEvents;
     private detachAllPicks;
@@ -145,6 +237,12 @@ declare class CombosDevelopmentToolSystem extends System<CombosDevelopmentToolSy
     private releasePick;
     private postSetSuccess;
     private postStateChanged;
+    /** (Re)build markers for every object owning a registered marker component. */
+    private attachMarkers;
+    private createMarker;
+    private removeMarker;
+    private detachAllMarkers;
+    private postMarkerOverlaySuccess;
     private getSoundSystem;
     private ensureOutline;
     private onSelect;
@@ -201,5 +299,5 @@ declare function buildGameObjectDeselectedPayload(reason: DevelopmentToolDeselec
 declare function shouldNotifyGameObjectDeselected(hadSelection: boolean): boolean;
 declare function isClearSelectionMessage(data: unknown): boolean;
 
-export { COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY, COMBOS_DEVELOPMENT_TOOL_CLEAR_SELECTION, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_DESELECTED, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED, COMBOS_DEVELOPMENT_TOOL_READY, COMBOS_DEVELOPMENT_TOOL_REFRESH, COMBOS_DEVELOPMENT_TOOL_SET, COMBOS_DEVELOPMENT_TOOL_SET_MUTED, COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS, COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED, CombosDevelopmentToolSystem, CombosDevelopmentToolTarget, DEFAULT_ALLOWED_MESSAGE_HOST_SUFFIXES, applyPropertyValue, applyPropertyWithHooks, buildGameObjectDeselectedPayload, buildGameObjectSnapshot, isAllowedMessageOrigin, isClearSelectionMessage, mergeAllowedMessageOrigins, readPropertyValue, readSourceAnchor, shouldNotifyGameObjectDeselected };
-export type { CombosDevelopmentToolSystemParams, CombosDevelopmentToolTargetParams, DevelopmentToolDeselectReason, SceneEditComponentSnapshot, SceneEditGameObjectSnapshot, SceneEditPropertyRef, SceneSourceAnchor };
+export { COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY, COMBOS_DEVELOPMENT_TOOL_CLEAR_SELECTION, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_DESELECTED, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED, COMBOS_DEVELOPMENT_TOOL_MARKER_OVERLAY_SUCCESS, COMBOS_DEVELOPMENT_TOOL_READY, COMBOS_DEVELOPMENT_TOOL_REFRESH, COMBOS_DEVELOPMENT_TOOL_SET, COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY, COMBOS_DEVELOPMENT_TOOL_SET_MUTED, COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS, COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED, CombosDevelopmentToolSystem, CombosDevelopmentToolTarget, DEFAULT_ALLOWED_MESSAGE_HOST_SUFFIXES, MARKER_COMPONENTS, MARKER_ICON_SIZE, applyPropertyValue, applyPropertyWithHooks, buildGameObjectDeselectedPayload, buildGameObjectSnapshot, drawMarkerIcon, isAllowedMessageOrigin, isClearSelectionMessage, mergeAllowedMessageOrigins, readPropertyValue, readSourceAnchor, resolveMarkerDef, shouldNotifyGameObjectDeselected };
+export type { CombosDevelopmentToolSystemParams, CombosDevelopmentToolTargetParams, DevelopmentToolDeselectReason, MarkerComponentDef, MarkerGlyph, MarkerGraphicsLike, SceneEditComponentSnapshot, SceneEditGameObjectSnapshot, SceneEditPropertyRef, SceneSourceAnchor };

package/dist/plugin-development-tool.esm.js

@@ -29,6 +29,18 @@ const COMBOS_DEVELOPMENT_TOOL_READY = 'combos-development-tool:ready';
 const COMBOS_DEVELOPMENT_TOOL_SET_MUTED = 'combos-development-tool:set-muted';
 /** iframe → parent (and `game.emit`): current mute snapshot after a successful change. */
 const COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED = 'combos-development-tool:state-changed';
+/**
+ * Parent → iframe (also `window` CustomEvent / `game.emit`): toggle the marker
+ * overlay — a persistent, clickable icon on every object owning an otherwise
+ * invisible registered component (Sound first). Independent of pick mode and
+ * mute. Payload: `{ enabled: boolean }`.
+ */
+const COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY = 'combos-development-tool:set-marker-overlay';
+/**
+ * iframe → parent (and `game.emit`): marker overlay finished (re)building.
+ * Payload: `{ enabled: boolean, total: number, markers: { componentName, count }[] }`.
+ */
+const COMBOS_DEVELOPMENT_TOOL_MARKER_OVERLAY_SUCCESS = 'combos-development-tool:marker-overlay-success';
 
 /**
  * Marks a `GameObject` as selectable in editor pick mode. While the development tool is enabled,
@@ -46,6 +58,73 @@ class CombosDevelopmentToolTarget extends Component {
     }
 }
 
+/**
+ * Registered marker kinds, in priority order: a GameObject is marked by the
+ * first registered component it owns. For now this is **`Sound` only**; the
+ * mechanism is generic (append Physics / Camera / triggers / spawn points later
+ * to reuse the same layer) but only audio is wanted right now.
+ */
+const MARKER_COMPONENTS = [
+    { componentName: 'Sound', badgeColor: 0x8b5cf6, glyph: 'speaker' },
+];
+/** Fixed badge size in the owner's local space. */
+const MARKER_ICON_SIZE = 28;
+/**
+ * First registered marker def whose component is present on `go`, else `null`.
+ * Priority follows {@link MARKER_COMPONENTS} order.
+ */
+function resolveMarkerDef(go, registry = MARKER_COMPONENTS) {
+    for (const def of registry) {
+        if (go.getComponent(def.componentName)) {
+            return def;
+        }
+    }
+    return null;
+}
+const GLYPH_COLOR = 0xffffff;
+/** Draw the rounded badge background shared by every glyph. */
+function drawBadge(g, def, size) {
+    g.clear();
+    g.roundRect(0, 0, size, size, size * 0.22);
+    g.fill({ color: def.badgeColor, alpha: 0.92 });
+    g.roundRect(0, 0, size, size, size * 0.22);
+    g.stroke({ width: Math.max(1, size * 0.05), color: 0xffffff, alpha: 0.6 });
+}
+/** A speaker cone + two volume bars, normalized to the `size` box. */
+function drawSpeakerGlyph(g, s) {
+    g.poly([
+        s * 0.28, s * 0.4,
+        s * 0.42, s * 0.4,
+        s * 0.55, s * 0.26,
+        s * 0.55, s * 0.74,
+        s * 0.42, s * 0.6,
+        s * 0.28, s * 0.6,
+    ]);
+    g.fill({ color: GLYPH_COLOR, alpha: 0.96 });
+    g.rect(s * 0.62, s * 0.44, s * 0.045, s * 0.12);
+    g.fill({ color: GLYPH_COLOR, alpha: 0.96 });
+    g.rect(s * 0.71, s * 0.39, s * 0.045, s * 0.22);
+    g.fill({ color: GLYPH_COLOR, alpha: 0.96 });
+}
+/** Generic fallback glyph for component kinds without a dedicated icon. */
+function drawDotGlyph(g, s) {
+    g.circle(s * 0.5, s * 0.5, s * 0.18);
+    g.fill({ color: GLYPH_COLOR, alpha: 0.96 });
+}
+/** Render a full marker (badge + glyph) into `g`, sized to `size` (local units). */
+function drawMarkerIcon(g, def, size = MARKER_ICON_SIZE) {
+    drawBadge(g, def, size);
+    switch (def.glyph) {
+        case 'speaker':
+            drawSpeakerGlyph(g, size);
+            break;
+        case 'dot':
+        default:
+            drawDotGlyph(g, size);
+            break;
+    }
+}
+
 /** Default inbound postMessage host suffixes (host + all subdomains). */
 const DEFAULT_ALLOWED_MESSAGE_HOST_SUFFIXES = [
     'knoffice.tech',
@@ -369,6 +448,7 @@ function isClearSelectionMessage(data) {
 }
 
 const OUTLINE_GO_NAME = '__combosDevelopmentToolOutline';
+const MARKER_GO_NAME_PREFIX = '__combosDevelopmentToolMarker:';
 /**
  * **Off** at start. While enabled:
  * - soft-disables game `Event` hit targets (`container.interactive = false`, restored on disable);
@@ -409,6 +489,18 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         this.lastOutlineBounds = null;
         /** Remembered mute when `SoundSystem` is not registered yet. */
         this.mutedWithoutSoundSystem = false;
+        /**
+         * Marker overlay (see {@link markerLayer}): a visual-only icon layer, toggled
+         * independently of pick mode + mute. Selection/persistence are NOT handled here
+         * — a marked object (e.g. Sound) carries its own `CombosDevelopmentToolTarget`
+         * (added by the game code), so it is picked and serialized through the normal
+         * Target path. The icon just makes the invisible object visible and, by adding
+         * to the owner's rendered bounds, gives its Target pick a clickable hit area.
+         */
+        this.markerOverlayEnabled = false;
+        this.needsMarkerRescan = false;
+        /** ownerGoId → its marker GO (icon child, Graphics only). */
+        this.markerGoByOwner = new Map();
         this.onWindowSet = (e) => {
             const d = e.detail;
             if (d && typeof d.enabled === 'boolean') {
@@ -421,6 +513,17 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
                 this.setMuted(d.muted);
             }
         };
+        this.onWindowSetMarkerOverlay = (e) => {
+            const d = e.detail;
+            if (d && typeof d.enabled === 'boolean') {
+                this.setMarkerOverlay(d.enabled);
+            }
+        };
+        this.onGameSetMarkerOverlay = (payload) => {
+            if (payload && typeof payload.enabled === 'boolean') {
+                this.setMarkerOverlay(payload.enabled);
+            }
+        };
         this.onWindowMessage = (e) => {
             if (!isAllowedMessageOrigin(e.origin, this.allowedMessageOrigins)) {
                 return;
@@ -434,6 +537,10 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
             else if (d.type === COMBOS_DEVELOPMENT_TOOL_SET_MUTED && typeof d.muted === 'boolean') {
                 this.setMuted(d.muted);
             }
+            else if (d.type === COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY &&
+                typeof d.enabled === 'boolean') {
+                this.setMarkerOverlay(d.enabled);
+            }
             else if (d.type === COMBOS_DEVELOPMENT_TOOL_REFRESH) {
                 this.requestSceneRescan();
             }
@@ -468,11 +575,13 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         if (typeof window !== 'undefined') {
             window.addEventListener(COMBOS_DEVELOPMENT_TOOL_SET, this.onWindowSet);
             window.addEventListener(COMBOS_DEVELOPMENT_TOOL_SET_MUTED, this.onWindowSetMuted);
+            window.addEventListener(COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY, this.onWindowSetMarkerOverlay);
             window.addEventListener(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onWindowRefresh);
             window.addEventListener('message', this.onWindowMessage);
         }
         this.game.on(COMBOS_DEVELOPMENT_TOOL_SET, this.onGameSet);
         this.game.on(COMBOS_DEVELOPMENT_TOOL_SET_MUTED, this.onGameSetMuted);
+        this.game.on(COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY, this.onGameSetMarkerOverlay);
         this.game.on(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onGameRefresh);
         if (this.enabled) {
             this.needsRescan = true;
@@ -482,13 +591,16 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         if (typeof window !== 'undefined') {
             window.removeEventListener(COMBOS_DEVELOPMENT_TOOL_SET, this.onWindowSet);
             window.removeEventListener(COMBOS_DEVELOPMENT_TOOL_SET_MUTED, this.onWindowSetMuted);
+            window.removeEventListener(COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY, this.onWindowSetMarkerOverlay);
             window.removeEventListener(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onWindowRefresh);
             window.removeEventListener('message', this.onWindowMessage);
         }
         this.game.off(COMBOS_DEVELOPMENT_TOOL_SET, this.onGameSet);
         this.game.off(COMBOS_DEVELOPMENT_TOOL_SET_MUTED, this.onGameSetMuted);
+        this.game.off(COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY, this.onGameSetMarkerOverlay);
         this.game.off(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onGameRefresh);
         this.detachAllPicks();
+        this.detachAllMarkers();
         this.restoreDisabledGameEvents();
         this.clearSelectionAndNotify('pick-disabled');
     }
@@ -510,6 +622,35 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
     get isEnabled() {
         return this.enabled;
     }
+    /**
+     * Toggle the marker overlay: pin a persistent icon on every object that owns a
+     * registered invisible component ({@link markerLayer}, Sound first). Independent
+     * of pick mode / mute. This layer is purely visual — the icon makes the object
+     * visible and adds to its rendered bounds so the owner's own
+     * `CombosDevelopmentToolTarget` pick gets a clickable hit area. Selecting and
+     * persisting edits (e.g. volume) still go through that Target, exactly like any
+     * other scene edit, so the object must carry a Target (added by the game code).
+     */
+    setMarkerOverlay(on) {
+        if (this.markerOverlayEnabled === on)
+            return;
+        this.markerOverlayEnabled = on;
+        if (on) {
+            // `attachMarkers` requests the pick rescan itself, once the icons exist.
+            this.needsMarkerRescan = true;
+        }
+        else {
+            this.detachAllMarkers();
+            this.postMarkerOverlaySuccess(false, []);
+            // Shrink owners' pick hit areas back now that the icons are gone.
+            if (this.enabled) {
+                this.needsRescan = true;
+            }
+        }
+    }
+    get isMarkerOverlayEnabled() {
+        return this.markerOverlayEnabled;
+    }
     /** Master mute when `SoundSystem` exists; otherwise the last requested value. */
     get isMuted() {
         const sound = this.getSoundSystem();
@@ -538,11 +679,26 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
             this.attachEditMode();
             this.postSetSuccess(true);
         }
+        // Attaching markers is deferred to run *after* the pick rescan above so that a
+        // newly drawn icon's rebuild lands on a later frame (see `attachMarkers`): the
+        // icon child needs a rendered container before it contributes to the owner's
+        // bounds, and only then does the owner's Target pick get a hit area over it.
+        if (this.markerOverlayEnabled && this.needsMarkerRescan) {
+            this.needsMarkerRescan = false;
+            this.attachMarkers();
+        }
         for (const go of [...this.tapOwners.values()]) {
             if (go.destroyed) {
                 this.releasePick(go);
             }
         }
+        // Drop markers whose owner disappeared while the overlay is on.
+        for (const [ownerId, marker] of [...this.markerGoByOwner.entries()]) {
+            const owner = this.findGameObjectById(ownerId);
+            if (!owner || owner.destroyed || marker.destroyed) {
+                this.removeMarker(ownerId);
+            }
+        }
         if (!this.enabled || !this.selected || !this.outlineGo)
             return;
         this.updateSelectionOutline();
@@ -564,11 +720,14 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
             }
         }
     }
-    /** Re-bind pick targets after dynamic scene changes while enabled. */
+    /** Re-bind pick targets / markers after dynamic scene changes while active. */
     requestSceneRescan() {
-        if (!this.enabled)
-            return;
-        this.needsRescan = true;
+        if (this.enabled) {
+            this.needsRescan = true;
+        }
+        if (this.markerOverlayEnabled) {
+            this.needsMarkerRescan = true;
+        }
     }
     attachEditMode() {
         this.detachAllPicks();
@@ -596,7 +755,10 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         }
     }
     isIgnoredPickGo(go) {
-        return go.name === OUTLINE_GO_NAME || go === this.outlineGo;
+        return go.name === OUTLINE_GO_NAME || go === this.outlineGo || this.isMarkerGo(go);
+    }
+    isMarkerGo(go) {
+        return typeof go.name === 'string' && go.name.startsWith(MARKER_GO_NAME_PREFIX);
     }
     stripGameEvent(go) {
         if (this.disabledGameEventGoIds.has(go.id))
@@ -813,6 +975,78 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         }
         this.game.emit(COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED, state);
     }
+    /** (Re)build markers for every object owning a registered marker component. */
+    attachMarkers() {
+        this.detachAllMarkers();
+        const list = [];
+        for (const tr of this.game.scene.transform.children) {
+            this.collectGameObjects(tr.gameObject, list);
+        }
+        const counts = new Map();
+        for (const go of list) {
+            if (this.isIgnoredPickGo(go))
+                continue;
+            const def = resolveMarkerDef(go);
+            if (!def)
+                continue;
+            this.createMarker(go, def);
+            counts.set(def.componentName, (counts.get(def.componentName) ?? 0) + 1);
+        }
+        const markers = [...counts.entries()].map(([componentName, count]) => ({
+            componentName,
+            count,
+        }));
+        this.postMarkerOverlaySuccess(true, markers);
+        // Rebuild picks next frame: the icons just added need a rendered container
+        // before they enlarge their owners' bounds into a clickable hit area. Runs on
+        // a later frame because the pick rescan block already executed above.
+        if (this.enabled) {
+            this.needsRescan = true;
+        }
+    }
+    createMarker(owner, def) {
+        if (this.markerGoByOwner.has(owner.id))
+            return;
+        const bounds = this.resolvePickBounds(owner);
+        const marker = new GameObject(MARKER_GO_NAME_PREFIX + owner.id, {
+            size: { width: MARKER_ICON_SIZE, height: MARKER_ICON_SIZE },
+            position: { x: bounds.x, y: bounds.y },
+            origin: { x: 0, y: 0 },
+        });
+        const gfx = marker.addComponent(new Graphics());
+        if (gfx?.graphics) {
+            drawMarkerIcon(gfx.graphics, def, MARKER_ICON_SIZE);
+        }
+        owner.addChild(marker);
+        this.markerGoByOwner.set(owner.id, marker);
+    }
+    removeMarker(ownerId) {
+        const marker = this.markerGoByOwner.get(ownerId);
+        if (!marker)
+            return;
+        this.markerGoByOwner.delete(ownerId);
+        if (!marker.destroyed) {
+            marker.destroy();
+        }
+    }
+    detachAllMarkers() {
+        for (const ownerId of [...this.markerGoByOwner.keys()]) {
+            this.removeMarker(ownerId);
+        }
+        this.markerGoByOwner.clear();
+    }
+    postMarkerOverlaySuccess(enabled, markers) {
+        const total = markers.reduce((sum, m) => sum + m.count, 0);
+        const state = { enabled, total, markers };
+        const payload = {
+            type: COMBOS_DEVELOPMENT_TOOL_MARKER_OVERLAY_SUCCESS,
+            ...state,
+        };
+        if (typeof window !== 'undefined' && window.parent && window.parent !== window) {
+            window.parent.postMessage(payload, this.postMessageOrigin);
+        }
+        this.game.emit(COMBOS_DEVELOPMENT_TOOL_MARKER_OVERLAY_SUCCESS, state);
+    }
     getSoundSystem() {
         const system = this.game.getSystem('SoundSystem');
         if (!system ||
@@ -1002,5 +1236,5 @@ Object.assign(CombosDevelopmentToolSystem$1, {
     packageVersion: "0.0.27",
 });
 
-export { COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY, COMBOS_DEVELOPMENT_TOOL_CLEAR_SELECTION, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_DESELECTED, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED, COMBOS_DEVELOPMENT_TOOL_READY, COMBOS_DEVELOPMENT_TOOL_REFRESH, COMBOS_DEVELOPMENT_TOOL_SET, COMBOS_DEVELOPMENT_TOOL_SET_MUTED, COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS, COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED, CombosDevelopmentToolSystem$1 as CombosDevelopmentToolSystem, CombosDevelopmentToolTarget, DEFAULT_ALLOWED_MESSAGE_HOST_SUFFIXES, applyPropertyValue, applyPropertyWithHooks, buildGameObjectDeselectedPayload, buildGameObjectSnapshot, isAllowedMessageOrigin, isClearSelectionMessage, mergeAllowedMessageOrigins, readPropertyValue, readSourceAnchor, shouldNotifyGameObjectDeselected };
+export { COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY, COMBOS_DEVELOPMENT_TOOL_CLEAR_SELECTION, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_DESELECTED, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED, COMBOS_DEVELOPMENT_TOOL_MARKER_OVERLAY_SUCCESS, COMBOS_DEVELOPMENT_TOOL_READY, COMBOS_DEVELOPMENT_TOOL_REFRESH, COMBOS_DEVELOPMENT_TOOL_SET, COMBOS_DEVELOPMENT_TOOL_SET_MARKER_OVERLAY, COMBOS_DEVELOPMENT_TOOL_SET_MUTED, COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS, COMBOS_DEVELOPMENT_TOOL_STATE_CHANGED, CombosDevelopmentToolSystem$1 as CombosDevelopmentToolSystem, CombosDevelopmentToolTarget, DEFAULT_ALLOWED_MESSAGE_HOST_SUFFIXES, MARKER_COMPONENTS, MARKER_ICON_SIZE, applyPropertyValue, applyPropertyWithHooks, buildGameObjectDeselectedPayload, buildGameObjectSnapshot, drawMarkerIcon, isAllowedMessageOrigin, isClearSelectionMessage, mergeAllowedMessageOrigins, readPropertyValue, readSourceAnchor, resolveMarkerDef, shouldNotifyGameObjectDeselected };
 //# sourceMappingURL=plugin-development-tool.esm.js.map