@nuraly/lumenjs 0.1.2 → 0.1.4

package/dist/runtime/router.js

@@ -1,6 +1,6 @@
-import { fetchLoaderData, fetchLayoutLoaderData, render404 } from './router-data.js';
+import { fetchLoaderData, fetchLayoutLoaderData, prefetchLoaderData, prefetchLayoutLoaderData, connectSubscribe, connectLayoutSubscribe, render404 } from './router-data.js';
 import { hydrateInitialRoute } from './router-hydration.js';
-import { getI18nConfig, getLocale, stripLocalePrefix, buildLocalePath } from './i18n.js';
+import { getI18nConfig, getLocale, initI18n, stripLocalePrefix, buildLocalePath } from './i18n.js';
 /**
  * Simple client-side router for LumenJS pages.
  * Handles popstate and link clicks for SPA navigation.
@@ -12,27 +12,79 @@ export class NkRouter {
         this.outlet = null;
         this.currentTag = null;
         this.currentLayoutTags = [];
+        this.subscriptions = [];
         this.params = {};
         this.outlet = outlet;
+        this.siteTitle = document.title || 'LumenJS App';
         this.routes = routes.map(r => ({
             ...r,
             ...this.compilePattern(r.path),
         }));
+        // Initialize i18n from inlined data before any rendering
+        const i18nScript = document.getElementById('__nk_i18n__');
+        if (i18nScript) {
+            try {
+                const i18nData = JSON.parse(i18nScript.textContent || '');
+                initI18n(i18nData.config, i18nData.locale, i18nData.translations);
+            }
+            catch { /* ignore */ }
+            if (!hydrate)
+                i18nScript.remove();
+        }
         window.addEventListener('popstate', () => {
             const path = this.stripLocale(location.pathname);
             this.navigate(path, false);
         });
+        // Re-run loader when page is restored from bfcache (back/forward on mobile Safari, etc.)
+        window.addEventListener('pageshow', (e) => {
+            if (e.persisted) {
+                const path = this.stripLocale(location.pathname);
+                this.navigate(path, false);
+            }
+        });
         document.addEventListener('click', (e) => this.handleLinkClick(e));
+        window.__nk_navigate = (href) => {
+            const path = this.stripLocale(href);
+            if (this.matchRoute(path.split('?')[0])) {
+                this.navigate(path);
+            }
+            else {
+                window.location.href = href;
+            }
+        };
+        window.__nk_prefetch = (href) => {
+            const path = this.stripLocale(href);
+            this.prefetch(path);
+        };
         if (hydrate) {
             hydrateInitialRoute(this.routes, this.outlet, (p) => this.matchRoute(p), (tag, layoutTags, params) => {
                 this.currentTag = tag;
                 this.currentLayoutTags = layoutTags;
                 this.params = params;
             });
+            // Wire up SSE subscriptions after hydration
+            const path = this.stripLocale(location.pathname);
+            this.setupSubscriptions(path);
         }
         else {
-            const path = this.stripLocale(location.pathname);
-            this.navigate(path, false);
+            // Initialize auth from inlined data before navigating (CSR path)
+            const authScript = document.getElementById('__nk_auth__');
+            if (authScript) {
+                import('@lumenjs/auth').then(({ initAuth }) => {
+                    try {
+                        initAuth(JSON.parse(authScript.textContent || ''));
+                    }
+                    catch { }
+                    authScript.remove();
+                }).catch(() => { }).finally(() => {
+                    const path = this.stripLocale(location.pathname);
+                    this.navigate(path, false);
+                });
+            }
+            else {
+                const path = this.stripLocale(location.pathname);
+                this.navigate(path, false);
+            }
         }
     }
     compilePattern(path) {
@@ -43,7 +95,15 @@ export class NkRouter {
         });
         return { pattern: new RegExp(`^${pattern}$`), paramNames };
     }
-    async navigate(pathname, pushState = true) {
+    cleanupSubscriptions() {
+        for (const es of this.subscriptions) {
+            es.close();
+        }
+        this.subscriptions = [];
+    }
+    async navigate(fullPath, pushState = true) {
+        this.cleanupSubscriptions();
+        const pathname = fullPath.split('?')[0];
         const match = this.matchRoute(pathname);
         if (!match) {
             if (this.outlet)
@@ -53,49 +113,74 @@ export class NkRouter {
             return;
         }
         if (pushState) {
-            const localePath = this.withLocale(pathname);
+            const localePath = this.withLocale(fullPath);
             history.pushState(null, '', localePath);
+            window.scrollTo(0, 0);
         }
         this.params = match.params;
-        // Lazy-load the page component if not yet registered
-        if (match.route.load && !customElements.get(match.route.tagName)) {
-            await match.route.load();
-        }
-        // Load layout components
-        const layouts = match.route.layouts || [];
-        for (const layout of layouts) {
-            if (layout.load && !customElements.get(layout.tagName)) {
-                await layout.load();
-            }
-        }
-        // Fetch loader data for page
-        let loaderData = undefined;
-        if (match.route.hasLoader) {
+        // Auth guard: SPA-navigate unauthenticated users to login page
+        if (match.route.__nk_has_auth) {
             try {
-                loaderData = await fetchLoaderData(pathname, match.params);
-            }
-            catch (err) {
-                console.error('[NkRouter] Loader fetch failed:', err);
+                const { isAuthenticated } = await import('@lumenjs/auth');
+                if (!isAuthenticated()) {
+                    const loginPath = '/auth/login';
+                    const loginUrl = `${loginPath}?returnTo=${encodeURIComponent(pathname)}`;
+                    history.pushState(null, '', loginUrl);
+                    this.navigate(loginPath, false);
+                    return;
+                }
             }
+            catch { }
         }
-        // Fetch loader data for layouts
-        const layoutDataList = [];
+        const layouts = match.route.layouts || [];
+        // Load all component JS chunks in parallel
+        await Promise.all([
+            match.route.load && !customElements.get(match.route.tagName) ? match.route.load() : undefined,
+            ...layouts.map(l => l.load && !customElements.get(l.tagName) ? l.load() : undefined),
+        ]);
+        // Fetch all loader data in parallel
+        const loaderPromises = [
+            match.route.hasLoader
+                ? fetchLoaderData(pathname, match.params).catch(err => { console.error('[NkRouter] Loader fetch failed:', err); return undefined; })
+                : Promise.resolve(undefined),
+            ...layouts.map(layout => layout.hasLoader
+                ? fetchLayoutLoaderData(layout.loaderPath || '').catch(err => { console.error('[NkRouter] Layout loader fetch failed:', err); return undefined; })
+                : Promise.resolve(undefined)),
+        ];
+        const [loaderData, ...layoutDataList] = await Promise.all(loaderPromises);
+        this.renderRoute(match.route, loaderData, layouts, layoutDataList);
+        // Update document.title and announce route change for screen readers
+        this.updatePageMeta(match.route, loaderData);
+        // Set up SSE subscriptions
+        this.setupSubscriptions(pathname);
+    }
+    setupSubscriptions(pathname) {
+        const match = this.matchRoute(pathname);
+        if (!match)
+            return;
+        const layouts = match.route.layouts || [];
+        // Page subscription
+        if (match.route.hasSubscribe) {
+            const es = connectSubscribe(pathname, match.params);
+            es.onmessage = (e) => {
+                const pageEl = this.findPageElement(match.route.tagName);
+                if (pageEl)
+                    pageEl.liveData = JSON.parse(e.data);
+            };
+            this.subscriptions.push(es);
+        }
+        // Layout subscriptions
         for (const layout of layouts) {
-            if (layout.hasLoader) {
-                try {
-                    const data = await fetchLayoutLoaderData(layout.loaderPath || '');
-                    layoutDataList.push(data);
-                }
-                catch (err) {
-                    console.error('[NkRouter] Layout loader fetch failed:', err);
-                    layoutDataList.push(undefined);
-                }
-            }
-            else {
-                layoutDataList.push(undefined);
+            if (layout.hasSubscribe) {
+                const es = connectLayoutSubscribe(layout.loaderPath || '');
+                es.onmessage = (e) => {
+                    const layoutEl = this.outlet?.querySelector(layout.tagName);
+                    if (layoutEl)
+                        layoutEl.liveData = JSON.parse(e.data);
+                };
+                this.subscriptions.push(es);
             }
         }
-        this.renderRoute(match.route, loaderData, layouts, layoutDataList);
     }
     matchRoute(pathname) {
         for (const route of this.routes) {
@@ -146,6 +231,7 @@ export class NkRouter {
                 }
                 if (layoutDataList && layoutDataList[i] !== undefined) {
                     layoutEl.loaderData = layoutDataList[i];
+                    this.spreadData(layoutEl, layoutDataList[i]);
                 }
                 parentEl = layoutEl;
             }
@@ -170,12 +256,14 @@ export class NkRouter {
         const outerLayout = document.createElement(layouts[0].tagName);
         if (layoutDataList[0] !== undefined) {
             outerLayout.loaderData = layoutDataList[0];
+            this.spreadData(outerLayout, layoutDataList[0]);
         }
         let current = outerLayout;
         for (let i = 1; i < layouts.length; i++) {
             const inner = document.createElement(layouts[i].tagName);
             if (layoutDataList[i] !== undefined) {
                 inner.loaderData = layoutDataList[i];
+                this.spreadData(inner, layoutDataList[i]);
             }
             current.appendChild(inner);
             current = inner;
@@ -184,6 +272,19 @@ export class NkRouter {
         current.appendChild(pageEl);
         return outerLayout;
     }
+    /** Spread loader data as individual properties on an element. */
+    spreadData(el, data) {
+        if (data && typeof data === 'object') {
+            const BLOCKED = new Set(['__proto__', 'constructor', 'prototype',
+                'innerHTML', 'outerHTML', 'textContent',
+                'render', 'connectedCallback', 'disconnectedCallback']);
+            for (const [key, value] of Object.entries(data)) {
+                if (!BLOCKED.has(key)) {
+                    el[key] = value;
+                }
+            }
+        }
+    }
     createPageElement(route, loaderData) {
         const el = document.createElement(route.tagName);
         for (const [key, value] of Object.entries(this.params)) {
@@ -191,9 +292,56 @@ export class NkRouter {
         }
         if (loaderData !== undefined) {
             el.loaderData = loaderData;
+            this.spreadData(el, loaderData);
         }
         return el;
     }
+    findPageElement(tagName) {
+        if (!this.outlet)
+            return null;
+        return this.outlet.querySelector(tagName) ?? this.outlet.querySelector(`${tagName}:last-child`);
+    }
+    /**
+     * Resolve the page title from the route's meta export and update
+     * document.title, the aria-live announcer, and focus.
+     */
+    async updatePageMeta(route, loaderData) {
+        let pageTitle;
+        if (route.hasMeta && route.load) {
+            try {
+                const mod = await route.load();
+                if (mod) {
+                    let meta;
+                    if (typeof mod.meta === 'function') {
+                        meta = mod.meta({ data: loaderData, params: this.params });
+                    }
+                    else if (mod.meta && typeof mod.meta === 'object') {
+                        meta = mod.meta;
+                    }
+                    if (meta?.title) {
+                        pageTitle = `${meta.title} | ${this.siteTitle}`;
+                    }
+                }
+            }
+            catch { /* fall back to site title */ }
+        }
+        const title = pageTitle || this.siteTitle;
+        document.title = title;
+        // Announce route change to screen readers
+        const announcer = document.getElementById('nk-route-announcer');
+        if (announcer) {
+            announcer.textContent = '';
+            // Use a microtask delay so aria-live picks up the change
+            requestAnimationFrame(() => { announcer.textContent = title; });
+        }
+        // Move focus to the router outlet for keyboard/screen reader users
+        if (this.outlet) {
+            if (!this.outlet.hasAttribute('tabindex')) {
+                this.outlet.setAttribute('tabindex', '-1');
+            }
+            this.outlet.focus({ preventScroll: true });
+        }
+    }
     handleLinkClick(event) {
         const path = event.composedPath();
         const anchor = path.find((el) => el instanceof HTMLElement && el.tagName === 'A');
@@ -202,9 +350,27 @@ export class NkRouter {
         const href = anchor.getAttribute('href');
         if (!href || href.startsWith('http') || href.startsWith('#') || anchor.hasAttribute('target'))
             return;
+        // Allow modifier-key clicks to behave normally (Ctrl+Click = new tab, etc.)
+        if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+            return;
         event.preventDefault();
         this.navigate(this.stripLocale(href));
     }
+    async prefetch(fullPath) {
+        const pathname = fullPath.split('?')[0];
+        const match = this.matchRoute(pathname);
+        if (!match)
+            return;
+        const layouts = match.route.layouts || [];
+        await Promise.all([
+            // Preload component JS chunks
+            match.route.load && !customElements.get(match.route.tagName) ? match.route.load() : undefined,
+            ...layouts.map(l => l.load && !customElements.get(l.tagName) ? l.load() : undefined),
+            // Prefetch loader data (cached)
+            match.route.hasLoader ? prefetchLoaderData(pathname, match.params).catch(() => { }) : undefined,
+            ...layouts.map(l => l.hasLoader ? prefetchLayoutLoaderData(l.loaderPath || '').catch(() => { }) : undefined),
+        ]);
+    }
     /** Strip locale prefix from a path for internal route matching. */
     stripLocale(path) {
         const config = getI18nConfig();
@@ -216,3 +382,19 @@ export class NkRouter {
         return config ? buildLocalePath(getLocale(), path) : path;
     }
 }
+/** Navigate via the client-side router. Falls back to full reload for unknown routes. */
+export function navigate(href) {
+    const nav = window.__nk_navigate;
+    if (nav) {
+        nav(href);
+    }
+    else {
+        window.location.href = href;
+    }
+}
+/** Programmatically prefetch a route's JS chunks and loader data. */
+export function prefetch(href) {
+    const pf = window.__nk_prefetch;
+    if (pf)
+        pf(href);
+}

package/dist/runtime/socket-client.d.ts

@@ -0,0 +1,2 @@
+export declare function connectSocket(routePath: string, params: Record<string, string>): Promise<any>;
+export declare function disconnectAllSockets(): void;

package/dist/runtime/socket-client.js

@@ -0,0 +1,30 @@
+import { getI18nConfig, getLocale } from './i18n.js';
+const connections = new Map();
+export async function connectSocket(routePath, params) {
+    const { io } = await import('socket.io-client');
+    const ns = `/nk${routePath === '/' ? '/index' : routePath}`;
+    const query = {};
+    if (Object.keys(params).length > 0) {
+        query.__params = JSON.stringify(params);
+    }
+    try {
+        const config = getI18nConfig();
+        if (config) {
+            query.__locale = getLocale();
+        }
+    }
+    catch { }
+    // Disconnect existing socket for this route to prevent leaks
+    const existing = connections.get(routePath);
+    if (existing)
+        existing.disconnect();
+    const socket = io(ns, { path: '/__nk_socketio/', query });
+    connections.set(routePath, socket);
+    return socket;
+}
+export function disconnectAllSockets() {
+    for (const [, socket] of connections) {
+        socket.disconnect();
+    }
+    connections.clear();
+}

package/dist/runtime/webrtc.d.ts

@@ -0,0 +1,47 @@
+/**
+ * WebRTC peer connection manager.
+ * Wraps RTCPeerConnection and wires to the LumenJS communication SDK signaling.
+ */
+export type CallRole = 'caller' | 'callee';
+export interface WebRTCCallbacks {
+    onRemoteStream: (stream: MediaStream) => void;
+    onLocalStream: (stream: MediaStream) => void;
+    onConnectionStateChange: (state: RTCPeerConnectionState) => void;
+    onIceCandidate: (candidate: RTCIceCandidate) => void;
+    onError: (error: Error) => void;
+}
+export declare class WebRTCManager {
+    private _pc;
+    private _localStream;
+    private _remoteStream;
+    private _callbacks;
+    private _pendingCandidates;
+    private _role;
+    constructor(callbacks: WebRTCCallbacks, iceServers?: RTCIceServer[]);
+    private _createPeerConnection;
+    get localStream(): MediaStream | null;
+    get remoteStream(): MediaStream | null;
+    get role(): CallRole;
+    get connectionState(): RTCPeerConnectionState | null;
+    /** Acquire local media (camera/mic) and add tracks to the peer connection */
+    startLocalMedia(video?: boolean, audio?: boolean): Promise<MediaStream>;
+    /** Create an SDP offer (caller side) */
+    createOffer(): Promise<string>;
+    /** Handle received SDP offer and create answer (callee side) */
+    handleOffer(sdp: string): Promise<string>;
+    /** Handle received SDP answer (caller side) */
+    handleAnswer(sdp: string): Promise<void>;
+    /** Add a received ICE candidate */
+    addIceCandidate(candidate: string, sdpMLineIndex: number | null, sdpMid: string | null): Promise<void>;
+    private _flushPendingCandidates;
+    /** Toggle audio mute */
+    setAudioEnabled(enabled: boolean): void;
+    /** Toggle video */
+    setVideoEnabled(enabled: boolean): void;
+    /** Replace video track with screen share */
+    startScreenShare(): Promise<MediaStream>;
+    /** Revert from screen share back to camera */
+    stopScreenShare(): Promise<void>;
+    /** Clean up everything */
+    destroy(): void;
+}

package/dist/runtime/webrtc.js

@@ -0,0 +1,178 @@
+/**
+ * WebRTC peer connection manager.
+ * Wraps RTCPeerConnection and wires to the LumenJS communication SDK signaling.
+ */
+const ICE_SERVERS = [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'stun:stun1.l.google.com:19302' },
+];
+export class WebRTCManager {
+    constructor(callbacks, iceServers) {
+        this._pc = null;
+        this._localStream = null;
+        this._remoteStream = null;
+        this._pendingCandidates = [];
+        this._role = 'caller';
+        this._callbacks = callbacks;
+        this._createPeerConnection(iceServers || ICE_SERVERS);
+    }
+    _createPeerConnection(iceServers) {
+        this._pc = new RTCPeerConnection({ iceServers });
+        this._pc.onicecandidate = (event) => {
+            if (event.candidate) {
+                this._callbacks.onIceCandidate(event.candidate);
+            }
+        };
+        this._pc.ontrack = (event) => {
+            if (!this._remoteStream) {
+                this._remoteStream = new MediaStream();
+                this._callbacks.onRemoteStream(this._remoteStream);
+            }
+            this._remoteStream.addTrack(event.track);
+        };
+        this._pc.onconnectionstatechange = () => {
+            if (this._pc) {
+                this._callbacks.onConnectionStateChange(this._pc.connectionState);
+            }
+        };
+    }
+    get localStream() { return this._localStream; }
+    get remoteStream() { return this._remoteStream; }
+    get role() { return this._role; }
+    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) {
+        try {
+            this._localStream = await navigator.mediaDevices.getUserMedia({ video, audio });
+            this._callbacks.onLocalStream(this._localStream);
+            for (const track of this._localStream.getTracks()) {
+                this._pc?.addTrack(track, this._localStream);
+            }
+            return this._localStream;
+        }
+        catch (err) {
+            this._callbacks.onError(new Error(`Failed to access media: ${err.message}`));
+            throw err;
+        }
+    }
+    /** Create an SDP offer (caller side) */
+    async createOffer() {
+        this._role = 'caller';
+        if (!this._pc)
+            throw new Error('No peer connection');
+        const offer = await this._pc.createOffer();
+        await this._pc.setLocalDescription(offer);
+        return offer.sdp;
+    }
+    /** Handle received SDP offer and create answer (callee side) */
+    async handleOffer(sdp) {
+        this._role = 'callee';
+        if (!this._pc)
+            throw new Error('No peer connection');
+        await this._pc.setRemoteDescription({ type: 'offer', sdp });
+        // Flush pending ICE candidates
+        await this._flushPendingCandidates();
+        const answer = await this._pc.createAnswer();
+        await this._pc.setLocalDescription(answer);
+        return answer.sdp;
+    }
+    /** Handle received SDP answer (caller side) */
+    async handleAnswer(sdp) {
+        if (!this._pc)
+            throw new Error('No peer connection');
+        await this._pc.setRemoteDescription({ type: 'answer', sdp });
+        await this._flushPendingCandidates();
+    }
+    /** Add a received ICE candidate */
+    async addIceCandidate(candidate, sdpMLineIndex, sdpMid) {
+        const init = {
+            candidate,
+            sdpMLineIndex: sdpMLineIndex ?? undefined,
+            sdpMid: sdpMid ?? undefined,
+        };
+        if (!this._pc?.remoteDescription) {
+            // Queue candidates until remote description is set
+            this._pendingCandidates.push(init);
+            return;
+        }
+        try {
+            await this._pc.addIceCandidate(init);
+        }
+        catch (err) {
+            console.warn('[WebRTC] Failed to add ICE candidate:', err);
+        }
+    }
+    async _flushPendingCandidates() {
+        for (const c of this._pendingCandidates) {
+            try {
+                await this._pc?.addIceCandidate(c);
+            }
+            catch { }
+        }
+        this._pendingCandidates = [];
+    }
+    /** Toggle audio mute */
+    setAudioEnabled(enabled) {
+        if (this._localStream) {
+            for (const track of this._localStream.getAudioTracks()) {
+                track.enabled = enabled;
+            }
+        }
+    }
+    /** Toggle video */
+    setVideoEnabled(enabled) {
+        if (this._localStream) {
+            for (const track of this._localStream.getVideoTracks()) {
+                track.enabled = enabled;
+            }
+        }
+    }
+    /** Replace video track with screen share */
+    async startScreenShare() {
+        const stream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+        const screenTrack = stream.getVideoTracks()[0];
+        if (this._pc && this._localStream) {
+            const sender = this._pc.getSenders().find(s => s.track?.kind === 'video');
+            if (sender) {
+                await sender.replaceTrack(screenTrack);
+            }
+        }
+        // When user stops sharing via browser UI
+        screenTrack.onended = () => {
+            this.stopScreenShare();
+        };
+        return stream;
+    }
+    /** 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);
+                }
+            }
+        }
+    }
+    /** Clean up everything */
+    destroy() {
+        if (this._localStream) {
+            for (const track of this._localStream.getTracks()) {
+                track.stop();
+            }
+            this._localStream = null;
+        }
+        if (this._remoteStream) {
+            for (const track of this._remoteStream.getTracks()) {
+                track.stop();
+            }
+            this._remoteStream = null;
+        }
+        if (this._pc) {
+            this._pc.close();
+            this._pc = null;
+        }
+        this._pendingCandidates = [];
+    }
+}

package/dist/shared/graceful-shutdown.d.ts

@@ -0,0 +1,8 @@
+import type { Server } from 'http';
+export interface ShutdownConfig {
+    /** Max time to wait for connections to drain (ms). Default: 30000. */
+    timeout?: number;
+    /** Extra cleanup functions to run before exit. */
+    onShutdown?: () => Promise<void> | void;
+}
+export declare function setupGracefulShutdown(server: Server, config?: ShutdownConfig): void;

package/dist/shared/graceful-shutdown.js

@@ -0,0 +1,36 @@
+import { logger } from './logger.js';
+export function setupGracefulShutdown(server, config) {
+    const timeout = config?.timeout ?? 30_000;
+    let isShuttingDown = false;
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        logger.info(`Received ${signal}, starting graceful shutdown...`);
+        // Stop accepting new connections
+        server.close(() => {
+            logger.info('All connections drained.');
+        });
+        // Force-close after timeout
+        const forceTimer = setTimeout(() => {
+            logger.warn('Shutdown timeout reached, forcing exit.', { timeout });
+            process.exit(1);
+        }, timeout);
+        forceTimer.unref();
+        // Run custom cleanup
+        if (config?.onShutdown) {
+            try {
+                await config.onShutdown();
+                logger.info('Custom cleanup completed.');
+            }
+            catch (err) {
+                logger.error('Error during custom cleanup.', { error: err?.message });
+            }
+        }
+        // Close idle keep-alive connections
+        server.closeIdleConnections();
+        logger.info('Graceful shutdown complete.');
+    };
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+}

package/dist/shared/health.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+export interface HealthCheckConfig {
+    /** Endpoint path. Default: '/__health'. */
+    path?: string;
+    /** App version string. Default: reads from package.json or 'unknown'. */
+    version?: string;
+}
+export declare function createHealthCheckHandler(config?: HealthCheckConfig): (req: IncomingMessage, res: ServerResponse, next: (err?: any) => void) => void;