@nuraly/lumenjs 0.1.3 → 0.2.0

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,91 @@
+/**
+ * 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;
+    private _screenStream;
+    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;
+}
+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

@@ -0,0 +1,428 @@
+/**
+ * WebRTC peer connection manager.
+ * Wraps RTCPeerConnection and wires to the LumenJS communication SDK signaling.
+ */
+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;
+        this._localStream = null;
+        this._remoteStream = null;
+        this._pendingCandidates = [];
+        this._role = 'caller';
+        this._screenStream = null;
+        this._callbacks = callbacks;
+        this._createPeerConnection(getIceServers(iceServers));
+    }
+    _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) {
+        if (!navigator.mediaDevices?.getUserMedia) {
+            const err = new Error('Media devices unavailable — HTTPS is required for calls');
+            this._callbacks.onError(err);
+            throw err;
+        }
+        try {
+            // 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);
+            }
+            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() {
+        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) {
+            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();
+        };
+        return stream;
+    }
+    /** Revert from screen share back to camera */
+    async stopScreenShare() {
+        // 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();
+            }
+            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 = [];
+    }
+}
+// ── 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/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;

package/dist/shared/health.js

@@ -0,0 +1,25 @@
+const startTime = Date.now();
+export function createHealthCheckHandler(config) {
+    const healthPath = config?.path || '/__health';
+    const version = config?.version || process.env.npm_package_version || 'unknown';
+    return (req, res, next) => {
+        if (req.url?.split('?')[0] !== healthPath)
+            return next();
+        const uptime = Math.floor((Date.now() - startTime) / 1000);
+        const body = JSON.stringify({
+            status: 'ok',
+            uptime,
+            version,
+            timestamp: new Date().toISOString(),
+            memory: {
+                rss: Math.round(process.memoryUsage().rss / 1024 / 1024),
+                heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+            },
+        });
+        res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+        });
+        res.end(body);
+    };
+}

package/dist/shared/llms-txt.d.ts

@@ -0,0 +1,31 @@
+interface LlmsTxtPage {
+    path: string;
+    hasLoader: boolean;
+    hasSubscribe: boolean;
+    hasSocket: boolean;
+}
+interface LlmsTxtApiRoute {
+    path: string;
+    methods: string[];
+}
+interface LlmsTxtConfig {
+    title: string;
+    integrations: string[];
+    i18n?: {
+        locales: string[];
+        defaultLocale: string;
+    };
+}
+/**
+ * Generate the /llms.txt content for a LumenJS project.
+ */
+export declare function generateLlmsTxt(options: {
+    pages: LlmsTxtPage[];
+    apiRoutes: LlmsTxtApiRoute[];
+    config: LlmsTxtConfig;
+}): string;
+/**
+ * Detect exported HTTP methods from an API route file.
+ */
+export declare function detectApiMethods(filePath: string): string[];
+export {};