@nuraly/lumenjs 0.1.4 → 0.2.0

package/dist/editor/overlay-hmr.js

@@ -60,7 +60,8 @@ export function reselectAfterHmr() {
 }
 export function setupHmrListener() {
     try {
-        const ws = new WebSocket(`${location.protocol === 'https:' ? 'wss' : 'ws'}://${location.host}`, 'vite-hmr');
+        const base = (import.meta.env?.BASE_URL || '/').replace(/\/$/, '');
+        const ws = new WebSocket(`${location.protocol === 'https:' ? 'wss' : 'ws'}://${location.host}${base}`, 'vite-hmr');
         ws.addEventListener('message', (ev) => {
             try {
                 const msg = JSON.parse(ev.data);

package/dist/runtime/app-shell.d.ts

@@ -1 +1 @@
-export {};
+import './island.js';

package/dist/runtime/app-shell.js

@@ -1,5 +1,6 @@
 import { routes } from 'virtual:lumenjs-routes';
 import { NkRouter } from './router.js';
+import './island.js';
 function getDefaultStrategy() {
     const el = document.getElementById('__nk_prefetch__');
     if (el) {

package/dist/runtime/island.d.ts

@@ -0,0 +1,16 @@
+/**
+ * <nk-island> — Islands Architecture hydration wrapper.
+ *
+ * Strategies:
+ *   client:load    — import module immediately on page load
+ *   client:visible — import module when the element scrolls into view
+ *   client:idle    — import module when the browser is idle (requestIdleCallback)
+ *   client:media   — import module when a media query matches (value = query string)
+ *
+ * The `import` attribute specifies the module path to load.
+ */
+declare class NkIsland extends HTMLElement {
+    private _loaded;
+    connectedCallback(): void;
+    private _hydrate;
+}

package/dist/runtime/island.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * <nk-island> — Islands Architecture hydration wrapper.
+ *
+ * Strategies:
+ *   client:load    — import module immediately on page load
+ *   client:visible — import module when the element scrolls into view
+ *   client:idle    — import module when the browser is idle (requestIdleCallback)
+ *   client:media   — import module when a media query matches (value = query string)
+ *
+ * The `import` attribute specifies the module path to load.
+ */
+class NkIsland extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this._loaded = false;
+    }
+    connectedCallback() {
+        const importPath = this.getAttribute('import');
+        if (!importPath || this._loaded)
+            return;
+        if (this.hasAttribute('client:load')) {
+            this._hydrate(importPath);
+        }
+        else if (this.hasAttribute('client:visible')) {
+            const observer = new IntersectionObserver((entries) => {
+                if (entries[0]?.isIntersecting) {
+                    observer.disconnect();
+                    this._hydrate(importPath);
+                }
+            }, { rootMargin: '200px' });
+            observer.observe(this);
+        }
+        else if (this.hasAttribute('client:idle')) {
+            const cb = () => this._hydrate(importPath);
+            if ('requestIdleCallback' in window) {
+                window.requestIdleCallback(cb);
+            }
+            else {
+                setTimeout(cb, 200);
+            }
+        }
+        else if (this.hasAttribute('client:media')) {
+            const query = this.getAttribute('client:media') || '';
+            const mql = window.matchMedia(query);
+            const handler = () => {
+                if (mql.matches) {
+                    mql.removeEventListener('change', handler);
+                    this._hydrate(importPath);
+                }
+            };
+            if (mql.matches) {
+                this._hydrate(importPath);
+            }
+            else {
+                mql.addEventListener('change', handler);
+            }
+        }
+    }
+    _hydrate(importPath) {
+        if (this._loaded)
+            return;
+        this._loaded = true;
+        // Check global island registry (populated by pages with island imports)
+        const registry = window.__nk_islands;
+        const loader = registry?.[importPath];
+        const promise = loader
+            ? loader()
+            : import(/* @vite-ignore */ importPath);
+        promise.then(() => {
+            this.setAttribute('data-hydrated', '');
+            this.dispatchEvent(new Event('island-hydrated', { bubbles: true, composed: true }));
+        }).catch((err) => {
+            console.error(`[nk-island] Failed to load module: ${importPath}`, err);
+        });
+    }
+}
+if (!customElements.get('nk-island')) {
+    customElements.define('nk-island', NkIsland);
+}

package/dist/runtime/router-hydration.js

@@ -25,9 +25,16 @@ export async function hydrateInitialRoute(routes, outlet, matchRoute, onHydrated
         catch { }
         authScript.remove();
     }
-    // Strip locale prefix for route matching (routes are locale-agnostic)
+    // Strip Vite base path and locale prefix for route matching
+    let matchPath = location.pathname;
+    const base = import.meta.env?.BASE_URL;
+    if (base && base !== '/' && matchPath.startsWith(base)) {
+        matchPath = '/' + matchPath.slice(base.length);
+    }
     const config = getI18nConfig();
-    const matchPath = config ? stripLocalePrefix(location.pathname) : location.pathname;
+    if (config) {
+        matchPath = stripLocalePrefix(matchPath);
+    }
     const match = matchRoute(matchPath);
     if (!match)
         return;

package/dist/runtime/router.d.ts

@@ -10,6 +10,7 @@ export interface Route {
     tagName: string;
     hasLoader?: boolean;
     hasSubscribe?: boolean;
+    hasSocket?: boolean;
     hasMeta?: boolean;
     load?: () => Promise<any>;
     layouts?: LayoutInfo[];
@@ -27,6 +28,7 @@ export declare class NkRouter {
     private currentTag;
     private currentLayoutTags;
     private subscriptions;
+    private _sockets;
     private siteTitle;
     params: Record<string, string>;
     constructor(routes: Route[], outlet: HTMLElement, hydrate?: boolean);
@@ -48,7 +50,7 @@ export declare class NkRouter {
     private updatePageMeta;
     private handleLinkClick;
     prefetch(fullPath: string): Promise<void>;
-    /** Strip locale prefix from a path for internal route matching. */
+    /** Strip base and locale prefix from a path for internal route matching. */
     private stripLocale;
     /** Prepend locale prefix for browser-facing URLs. */
     private withLocale;

package/dist/runtime/router.js

@@ -13,6 +13,7 @@ export class NkRouter {
         this.currentTag = null;
         this.currentLayoutTags = [];
         this.subscriptions = [];
+        this._sockets = new Map();
         this.params = {};
         this.outlet = outlet;
         this.siteTitle = document.title || 'LumenJS App';
@@ -100,6 +101,10 @@ export class NkRouter {
             es.close();
         }
         this.subscriptions = [];
+        // Disconnect any active socket.io connections
+        for (const [, sock] of this._sockets)
+            sock.disconnect();
+        this._sockets.clear();
     }
     async navigate(fullPath, pushState = true) {
         this.cleanupSubscriptions();
@@ -169,6 +174,42 @@ export class NkRouter {
             };
             this.subscriptions.push(es);
         }
+        // Page socket (bidirectional via Socket.IO)
+        if (match.route.hasSocket) {
+            import('socket.io-client').then(({ io }) => {
+                const ns = `/nk${pathname === '/' ? '/index' : pathname}`;
+                const query = {};
+                if (Object.keys(match.params).length > 0)
+                    query.__params = JSON.stringify(match.params);
+                try {
+                    const locale = getLocale();
+                    if (locale)
+                        query.__locale = locale;
+                }
+                catch { }
+                const existing = this._sockets.get(pathname);
+                if (existing)
+                    existing.disconnect();
+                const socket = io(ns, { path: '/__nk_socketio/', query });
+                this._sockets.set(pathname, socket);
+                const injectEmit = () => {
+                    const pageEl = this.findPageElement(match.route.tagName);
+                    if (pageEl) {
+                        pageEl.emit = (event, payload) => {
+                            socket.emit(`nk:${event}`, payload);
+                        };
+                    }
+                };
+                injectEmit();
+                socket.on('nk:data', (data) => {
+                    const pageEl = this.findPageElement(match.route.tagName);
+                    if (pageEl) {
+                        pageEl.liveData = data;
+                        injectEmit();
+                    }
+                });
+            }).catch(err => console.error('[NkRouter] Socket connection failed:', err));
+        }
         // Layout subscriptions
         for (const layout of layouts) {
             if (layout.hasSubscribe) {
@@ -327,6 +368,8 @@ export class NkRouter {
         }
         const title = pageTitle || this.siteTitle;
         document.title = title;
+        // Let layout components adjust title (e.g. prepend badge counts)
+        window.dispatchEvent(new CustomEvent('nk-title-updated'));
         // Announce route change to screen readers
         const announcer = document.getElementById('nk-route-announcer');
         if (announcer) {
@@ -371,8 +414,13 @@ export class NkRouter {
             ...layouts.map(l => l.hasLoader ? prefetchLayoutLoaderData(l.loaderPath || '').catch(() => { }) : undefined),
         ]);
     }
-    /** Strip locale prefix from a path for internal route matching. */
+    /** Strip base and locale prefix from a path for internal route matching. */
     stripLocale(path) {
+        // Strip Vite base path (e.g. /__app_dev/{id}/) before route matching
+        const base = import.meta.env?.BASE_URL;
+        if (base && base !== '/' && path.startsWith(base)) {
+            path = '/' + path.slice(base.length);
+        }
         const config = getI18nConfig();
         return config ? stripLocalePrefix(path) : path;
     }

package/dist/runtime/webrtc.d.ts

@@ -17,6 +17,7 @@ export declare class WebRTCManager {
     private _callbacks;
     private _pendingCandidates;
     private _role;
+    private _screenStream;
     constructor(callbacks: WebRTCCallbacks, iceServers?: RTCIceServer[]);
     private _createPeerConnection;
     get localStream(): MediaStream | null;
@@ -45,3 +46,46 @@ export declare class WebRTCManager {
     /** Clean up everything */
     destroy(): void;
 }
+export interface GroupWebRTCCallbacks {
+    onLocalStream: (stream: MediaStream) => void;
+    onRemoteStream: (userId: string, stream: MediaStream) => void;
+    onRemoteStreamRemoved: (userId: string) => void;
+    onConnectionStateChange: (userId: string, state: RTCPeerConnectionState) => void;
+    onIceCandidate: (toUserId: string, candidate: RTCIceCandidate) => void;
+    onError: (error: Error) => void;
+}
+export declare class GroupWebRTCManager {
+    private _peers;
+    private _localStream;
+    private _callbacks;
+    private _iceServers;
+    private _screenStream;
+    constructor(callbacks: GroupWebRTCCallbacks, iceServers?: RTCIceServer[]);
+    get localStream(): MediaStream | null;
+    get peerCount(): number;
+    getRemoteStream(userId: string): MediaStream | null;
+    getRemoteStreams(): Map<string, MediaStream>;
+    /** Acquire local media — call once before adding peers */
+    startLocalMedia(video?: boolean, audio?: boolean): Promise<MediaStream>;
+    /** Create a peer connection for a remote user and optionally create an offer */
+    addPeer(userId: string, isCaller: boolean): Promise<string | void>;
+    /** Remove and close a peer connection */
+    removePeer(userId: string): void;
+    /** Handle an SDP offer from a remote peer and return an answer */
+    handleOffer(fromUserId: string, sdp: string): Promise<string>;
+    /** Handle an SDP answer from a remote peer */
+    handleAnswer(fromUserId: string, sdp: string): Promise<void>;
+    /** Add an ICE candidate for a specific peer */
+    addIceCandidate(fromUserId: string, candidate: string, sdpMLineIndex: number | null, sdpMid: string | null): Promise<void>;
+    private _flushPendingCandidates;
+    /** Toggle audio for all peers */
+    setAudioEnabled(enabled: boolean): void;
+    /** Toggle video for all peers */
+    setVideoEnabled(enabled: boolean): void;
+    /** Replace camera track with screen share on all peers */
+    startScreenShare(): Promise<MediaStream>;
+    /** Revert from screen share back to camera on all peers */
+    stopScreenShare(): Promise<void>;
+    /** Clean up everything */
+    destroy(): void;
+}

package/dist/runtime/webrtc.js

@@ -2,10 +2,15 @@
  * WebRTC peer connection manager.
  * Wraps RTCPeerConnection and wires to the LumenJS communication SDK signaling.
  */
-const ICE_SERVERS = [
+const DEFAULT_ICE_SERVERS = [
     { urls: 'stun:stun.l.google.com:19302' },
     { urls: 'stun:stun1.l.google.com:19302' },
 ];
+function getIceServers(custom) {
+    return custom
+        || (typeof window !== 'undefined' && window.__NK_ICE_SERVERS)
+        || DEFAULT_ICE_SERVERS;
+}
 export class WebRTCManager {
     constructor(callbacks, iceServers) {
         this._pc = null;
@@ -13,8 +18,9 @@ export class WebRTCManager {
         this._remoteStream = null;
         this._pendingCandidates = [];
         this._role = 'caller';
+        this._screenStream = null;
         this._callbacks = callbacks;
-        this._createPeerConnection(iceServers || ICE_SERVERS);
+        this._createPeerConnection(getIceServers(iceServers));
     }
     _createPeerConnection(iceServers) {
         this._pc = new RTCPeerConnection({ iceServers });
@@ -42,9 +48,22 @@ export class WebRTCManager {
     get connectionState() { return this._pc?.connectionState ?? null; }
     /** Acquire local media (camera/mic) and add tracks to the peer connection */
     async startLocalMedia(video = true, audio = true) {
+        if (!navigator.mediaDevices?.getUserMedia) {
+            const err = new Error('Media devices unavailable — HTTPS is required for calls');
+            this._callbacks.onError(err);
+            throw err;
+        }
         try {
-            this._localStream = await navigator.mediaDevices.getUserMedia({ video, audio });
+            // Always request video so both peers negotiate a video track in the SDP.
+            // For audio-only calls the video track is immediately disabled (black frame)
+            // but stays in the SDP as sendrecv, allowing replaceTrack for screen sharing.
+            this._localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio });
             this._callbacks.onLocalStream(this._localStream);
+            if (!video) {
+                for (const vt of this._localStream.getVideoTracks()) {
+                    vt.enabled = false;
+                }
+            }
             for (const track of this._localStream.getTracks()) {
                 this._pc?.addTrack(track, this._localStream);
             }
@@ -129,14 +148,18 @@ export class WebRTCManager {
     }
     /** Replace video track with screen share */
     async startScreenShare() {
-        const stream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+        if (!navigator.mediaDevices?.getDisplayMedia) {
+            throw new Error('Screen sharing unavailable — HTTPS is required');
+        }
+        const stream = await navigator.mediaDevices.getDisplayMedia({ video: true, audio: true });
         const screenTrack = stream.getVideoTracks()[0];
-        if (this._pc && this._localStream) {
+        if (this._pc) {
             const sender = this._pc.getSenders().find(s => s.track?.kind === 'video');
             if (sender) {
                 await sender.replaceTrack(screenTrack);
             }
         }
+        this._screenStream = stream;
         // When user stops sharing via browser UI
         screenTrack.onended = () => {
             this.stopScreenShare();
@@ -145,18 +168,27 @@ export class WebRTCManager {
     }
     /** Revert from screen share back to camera */
     async stopScreenShare() {
-        if (this._localStream && this._pc) {
-            const cameraTrack = this._localStream.getVideoTracks()[0];
-            if (cameraTrack) {
-                const sender = this._pc.getSenders().find(s => s.track?.kind === 'video');
-                if (sender) {
-                    await sender.replaceTrack(cameraTrack);
-                }
-            }
+        // Stop all screen share tracks so the OS stops the sharing indicator
+        if (this._screenStream) {
+            for (const track of this._screenStream.getTracks())
+                track.stop();
+            this._screenStream = null;
+        }
+        if (!this._pc || !this._localStream)
+            return;
+        const cameraTrack = this._localStream.getVideoTracks()[0] || null;
+        const sender = this._pc.getSenders().find(s => s.track?.kind === 'video');
+        if (sender) {
+            await sender.replaceTrack(cameraTrack);
         }
     }
     /** Clean up everything */
     destroy() {
+        if (this._screenStream) {
+            for (const track of this._screenStream.getTracks())
+                track.stop();
+            this._screenStream = null;
+        }
         if (this._localStream) {
             for (const track of this._localStream.getTracks()) {
                 track.stop();
@@ -176,3 +208,221 @@ export class WebRTCManager {
         this._pendingCandidates = [];
     }
 }
+// ── Group WebRTC Manager (mesh topology) ──────────────────────────
+const MAX_GROUP_PARTICIPANTS = 8;
+export class GroupWebRTCManager {
+    constructor(callbacks, iceServers) {
+        this._peers = new Map();
+        this._localStream = null;
+        this._screenStream = null;
+        this._callbacks = callbacks;
+        this._iceServers = getIceServers(iceServers);
+    }
+    get localStream() { return this._localStream; }
+    get peerCount() { return this._peers.size; }
+    getRemoteStream(userId) {
+        return this._peers.get(userId)?.remoteStream ?? null;
+    }
+    getRemoteStreams() {
+        const result = new Map();
+        for (const [uid, entry] of this._peers) {
+            if (entry.remoteStream)
+                result.set(uid, entry.remoteStream);
+        }
+        return result;
+    }
+    /** Acquire local media — call once before adding peers */
+    async startLocalMedia(video = true, audio = true) {
+        if (!navigator.mediaDevices?.getUserMedia) {
+            const err = new Error('Media devices unavailable — HTTPS is required for calls');
+            this._callbacks.onError(err);
+            throw err;
+        }
+        try {
+            this._localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio });
+            this._callbacks.onLocalStream(this._localStream);
+            if (!video) {
+                for (const vt of this._localStream.getVideoTracks())
+                    vt.enabled = false;
+            }
+            return this._localStream;
+        }
+        catch (err) {
+            this._callbacks.onError(new Error(`Failed to access media: ${err.message}`));
+            throw err;
+        }
+    }
+    /** Create a peer connection for a remote user and optionally create an offer */
+    async addPeer(userId, isCaller) {
+        if (this._peers.has(userId))
+            return;
+        if (this._peers.size >= MAX_GROUP_PARTICIPANTS - 1) {
+            this._callbacks.onError(new Error(`Group call limit reached (${MAX_GROUP_PARTICIPANTS} participants)`));
+            return;
+        }
+        const pc = new RTCPeerConnection({ iceServers: this._iceServers });
+        const entry = { pc, remoteStream: null, pendingCandidates: [] };
+        this._peers.set(userId, entry);
+        pc.onicecandidate = (event) => {
+            if (event.candidate) {
+                this._callbacks.onIceCandidate(userId, event.candidate);
+            }
+        };
+        pc.ontrack = (event) => {
+            if (!entry.remoteStream) {
+                entry.remoteStream = new MediaStream();
+                this._callbacks.onRemoteStream(userId, entry.remoteStream);
+            }
+            entry.remoteStream.addTrack(event.track);
+        };
+        pc.onconnectionstatechange = () => {
+            this._callbacks.onConnectionStateChange(userId, pc.connectionState);
+            if (pc.connectionState === 'failed') {
+                this.removePeer(userId);
+            }
+        };
+        // Add local tracks
+        if (this._localStream) {
+            for (const track of this._localStream.getTracks()) {
+                pc.addTrack(track, this._localStream);
+            }
+        }
+        if (isCaller) {
+            const offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+            return offer.sdp;
+        }
+    }
+    /** Remove and close a peer connection */
+    removePeer(userId) {
+        const entry = this._peers.get(userId);
+        if (!entry)
+            return;
+        entry.pc.close();
+        if (entry.remoteStream) {
+            for (const track of entry.remoteStream.getTracks())
+                track.stop();
+        }
+        this._peers.delete(userId);
+        this._callbacks.onRemoteStreamRemoved(userId);
+    }
+    /** Handle an SDP offer from a remote peer and return an answer */
+    async handleOffer(fromUserId, sdp) {
+        let entry = this._peers.get(fromUserId);
+        if (!entry) {
+            // Auto-create peer for the offerer
+            await this.addPeer(fromUserId, false);
+            entry = this._peers.get(fromUserId);
+        }
+        const { pc } = entry;
+        await pc.setRemoteDescription({ type: 'offer', sdp });
+        await this._flushPendingCandidates(fromUserId);
+        const answer = await pc.createAnswer();
+        await pc.setLocalDescription(answer);
+        return answer.sdp;
+    }
+    /** Handle an SDP answer from a remote peer */
+    async handleAnswer(fromUserId, sdp) {
+        const entry = this._peers.get(fromUserId);
+        if (!entry)
+            return;
+        await entry.pc.setRemoteDescription({ type: 'answer', sdp });
+        await this._flushPendingCandidates(fromUserId);
+    }
+    /** Add an ICE candidate for a specific peer */
+    async addIceCandidate(fromUserId, candidate, sdpMLineIndex, sdpMid) {
+        const init = {
+            candidate,
+            sdpMLineIndex: sdpMLineIndex ?? undefined,
+            sdpMid: sdpMid ?? undefined,
+        };
+        const entry = this._peers.get(fromUserId);
+        if (!entry)
+            return;
+        if (!entry.pc.remoteDescription) {
+            entry.pendingCandidates.push(init);
+            return;
+        }
+        try {
+            await entry.pc.addIceCandidate(init);
+        }
+        catch (err) {
+            console.warn(`[GroupWebRTC] Failed to add ICE candidate for ${fromUserId}:`, err);
+        }
+    }
+    async _flushPendingCandidates(userId) {
+        const entry = this._peers.get(userId);
+        if (!entry)
+            return;
+        for (const c of entry.pendingCandidates) {
+            try {
+                await entry.pc.addIceCandidate(c);
+            }
+            catch { }
+        }
+        entry.pendingCandidates = [];
+    }
+    /** Toggle audio for all peers */
+    setAudioEnabled(enabled) {
+        if (this._localStream) {
+            for (const track of this._localStream.getAudioTracks())
+                track.enabled = enabled;
+        }
+    }
+    /** Toggle video for all peers */
+    setVideoEnabled(enabled) {
+        if (this._localStream) {
+            for (const track of this._localStream.getVideoTracks())
+                track.enabled = enabled;
+        }
+    }
+    /** Replace camera track with screen share on all peers */
+    async startScreenShare() {
+        if (!navigator.mediaDevices?.getDisplayMedia) {
+            throw new Error('Screen sharing unavailable — HTTPS is required');
+        }
+        const stream = await navigator.mediaDevices.getDisplayMedia({ video: true, audio: true });
+        const screenTrack = stream.getVideoTracks()[0];
+        for (const [, entry] of this._peers) {
+            const sender = entry.pc.getSenders().find(s => s.track?.kind === 'video');
+            if (sender)
+                await sender.replaceTrack(screenTrack);
+        }
+        this._screenStream = stream;
+        screenTrack.onended = () => { this.stopScreenShare(); };
+        return stream;
+    }
+    /** Revert from screen share back to camera on all peers */
+    async stopScreenShare() {
+        if (this._screenStream) {
+            for (const track of this._screenStream.getTracks())
+                track.stop();
+            this._screenStream = null;
+        }
+        if (!this._localStream)
+            return;
+        const cameraTrack = this._localStream.getVideoTracks()[0] || null;
+        for (const [, entry] of this._peers) {
+            const sender = entry.pc.getSenders().find(s => s.track?.kind === 'video');
+            if (sender)
+                await sender.replaceTrack(cameraTrack);
+        }
+    }
+    /** Clean up everything */
+    destroy() {
+        if (this._screenStream) {
+            for (const track of this._screenStream.getTracks())
+                track.stop();
+            this._screenStream = null;
+        }
+        const userIds = [...this._peers.keys()];
+        for (const userId of userIds) {
+            this.removePeer(userId);
+        }
+        if (this._localStream) {
+            for (const track of this._localStream.getTracks())
+                track.stop();
+            this._localStream = null;
+        }
+    }
+}

package/dist/shared/dom-shims.js

@@ -1,3 +1,6 @@
+// Use the proper SSR HTMLElement shim so that @lit-labs/ssr's LitElementRenderer.renderAttributes()
+// finds a working `element.attributes` property. A bare `class HTMLElement {}` leaves it undefined.
+import { HTMLElement as SSRHTMLElement } from '@lit-labs/ssr-dom-shim';
 /**
  * Install DOM shims needed for SSR rendering of Lit/NuralyUI components.
  * Consolidates the various partial shim implementations across the codebase.
@@ -6,8 +9,7 @@ export function installDomShims() {
     const g = globalThis;
     const noop = () => null;
     if (!g.HTMLElement) {
-        g.HTMLElement = class HTMLElement {
-        };
+        g.HTMLElement = SSRHTMLElement;
     }
     if (!g.customElements) {
         const registry = new Map();

package/dist/shared/types.d.ts

@@ -9,6 +9,7 @@ export interface ManifestRoute {
     module: string;
     hasLoader: boolean;
     hasSubscribe: boolean;
+    hasSocket?: boolean;
     hasAuth?: boolean;
     hasMeta?: boolean;
     authRoles?: string[];