@bouygues-telecom/staticjs 0.1.11 → 0.1.14

package/_build/scripts/build-html.js

@@ -0,0 +1,138 @@
+import fs from "fs/promises";
+import crypto from "node:crypto";
+import path from "path";
+import React from "react";
+import { createPage } from "../helpers/createPage.js";
+import { CONFIG } from "../server/config/index.js";
+import { loadCacheEntries } from "../helpers/cachePages.js";
+import { findClosestLayout } from "../helpers/layoutDiscovery.js";
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+async function loadJson(filePath) {
+    const data = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(data);
+}
+async function main() {
+    loadCacheEntries(CONFIG.PROJECT_ROOT);
+    const excludedJSFiles = await loadJson(path.join(CONFIG.PROJECT_ROOT, CONFIG.BUILD_DIR, "cache/excludedFiles.json"));
+    const files = await loadJson(path.join(CONFIG.PROJECT_ROOT, CONFIG.BUILD_DIR, "cache/pagesCache.json"));
+    const processPage = async (page) => {
+        try {
+            let data;
+            const absolutePath = page.path;
+            const pageModule = await import(absolutePath);
+            const appModule = await import(`${CONFIG.PROJECT_ROOT}/src/app.tsx`);
+            const fileName = path.basename(page.path, path.extname(page.path));
+            // Load page data.json if it exists
+            const pageDir = path.dirname(absolutePath);
+            const dataJsonPath = path.join(pageDir, 'data.json');
+            let pageData = {};
+            try {
+                const dataContent = await fs.readFile(dataJsonPath, 'utf-8');
+                pageData = JSON.parse(dataContent);
+            }
+            catch (error) {
+                // data.json doesn't exist, use empty object
+            }
+            // Discover the closest layout for this page
+            const rootDir = path.resolve(CONFIG.PROJECT_ROOT, "./src");
+            const layoutPath = findClosestLayout(absolutePath, rootDir);
+            if (!layoutPath) {
+                throw new Error(`No layout found for page ${page.pageName}`);
+            }
+            const layoutModule = await import(layoutPath);
+            const LayoutComponent = layoutModule.Layout;
+            if (!LayoutComponent) {
+                throw new Error(`Layout component not found in ${layoutPath}. Make sure it exports 'Layout'.`);
+            }
+            // Create a wrapper App component that uses the discovered layout and passes pageData
+            const AppComponent = ({ Component, props }) => {
+                const LayoutWrapper = ({ children }) => {
+                    return React.createElement(LayoutComponent, { pageData, children });
+                };
+                return React.createElement(LayoutWrapper, {
+                    children: React.createElement(appModule.App, { Component, props, pageData })
+                });
+            };
+            const PageComponent = pageModule.default;
+            const getStaticProps = pageModule?.getStaticProps;
+            const getStaticPaths = pageModule?.getStaticPaths;
+            const injectJS = !excludedJSFiles.includes(page.pageName);
+            const rootId = crypto
+                .createHash("sha256")
+                .update(`app-${absolutePath}`)
+                .digest("hex")
+                .slice(0, 10);
+            const initialDatasId = crypto
+                .createHash("sha256")
+                .update(`initial-data-${absolutePath}`)
+                .digest("hex")
+                .slice(0, 10);
+            if (!PageComponent) {
+                throw new Error(`Failed to import PageComponent from ${page.pageName}.tsx`);
+            }
+            // Handle dynamic routes (pages with both getStaticProps and getStaticPaths)
+            if (getStaticPaths) {
+                const { paths } = await getStaticPaths();
+                if (paths && Array.isArray(paths)) {
+                    for (const param of paths) {
+                        if (param && param.params) {
+                            // Extract parameter name from page name (e.g., "partials/dynamic/[id]" -> "id")
+                            const paramMatch = page.pageName.match(/\[([^\]]+)\]/);
+                            const paramKey = paramMatch ? paramMatch[1] : null;
+                            const slug = paramKey ? param.params[paramKey] : null;
+                            if (slug) {
+                                const { props } = await getStaticProps(param);
+                                const pageName = page.pageName.replace(/\[.*?\]/, slug);
+                                const JSfileName = injectJS && fileName.replace(/\[(.*?)\]/g, "_$1_");
+                                createPage({
+                                    data: props.data,
+                                    AppComponent,
+                                    PageComponent,
+                                    initialDatasId,
+                                    rootId,
+                                    pageName,
+                                    JSfileName: JSfileName,
+                                    pageData,
+                                });
+                                console.log(`✓ ${pageName}.html`);
+                            }
+                        }
+                        else {
+                            console.warn(`Skipping invalid path parameter for ${page.pageName}:`, param);
+                        }
+                    }
+                }
+                else {
+                    console.warn(`No valid paths returned from getStaticPaths for ${page.pageName}`);
+                }
+            }
+            else {
+                // Handle static routes (pages without getStaticPaths)
+                if (getStaticProps) {
+                    const { props } = await getStaticProps();
+                    data = props.data;
+                }
+                createPage({
+                    data,
+                    AppComponent,
+                    PageComponent,
+                    initialDatasId,
+                    rootId,
+                    pageName: page.pageName,
+                    JSfileName: injectJS && fileName,
+                    pageData,
+                });
+                console.log(`✓ ${page.pageName}.html`);
+            }
+        }
+        catch (error) {
+            console.error(`Error processing ${page.pageName}:`, error);
+        }
+    };
+    const pages = Object.entries(files).map(([pageName, path]) => ({
+        pageName: pageName,
+        path: path,
+    }));
+    pages.forEach(processPage);
+}
+main();

package/_build/scripts/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI tool for StaticJS
+ * Provides build, development, and start commands
+ */
+export {};

package/_build/scripts/cli.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * CLI tool for StaticJS
+ * Provides build, development, and start commands
+ */
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { fileURLToPath } from 'node:url';
+const program = new Command();
+// Get the directory where this CLI script is located
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Determine the lib directory path (where the staticjs package is installed)
+const libDir = path.resolve(__dirname, '..');
+// Function to find the nearest package.json to determine project root
+function findProjectRoot() {
+    let currentDir = process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // Fallback to current working directory
+    return process.cwd();
+}
+const projectRoot = findProjectRoot();
+program
+    .name('static')
+    .description('StaticJS CLI tool')
+    .version('1.0.0');
+program
+    .command('build')
+    .description('Build the static site')
+    .action(async () => {
+    try {
+        console.log('🔨 Building static site...');
+        console.log("\n1️⃣ Building static HTML files from TSX...");
+        const buildHtmlScript = path.join(libDir, 'scripts', 'build-html.js');
+        const staticHtmlFilesBuildCommand = `npx tsx "${buildHtmlScript}"`;
+        execSync(staticHtmlFilesBuildCommand, {
+            stdio: 'inherit',
+            cwd: projectRoot
+        });
+        console.log("\n2️⃣ Building assets with Vite...");
+        const viteConfigPath = path.join(libDir, 'server', 'config', 'vite.config.js');
+        const viteBuildCommand = `npx vite build --config "${viteConfigPath}"`;
+        execSync(viteBuildCommand, {
+            stdio: 'inherit',
+            cwd: projectRoot
+        });
+        console.log("\n3️⃣ Cleanup...");
+        const cacheDir = path.join(projectRoot, '_build', 'cache');
+        if (fs.existsSync(cacheDir)) {
+            const cleanupCommand = process.platform === 'win32'
+                ? `rmdir /s /q "${cacheDir}"`
+                : `rm -rf "${cacheDir}"`;
+            execSync(cleanupCommand, {
+                stdio: 'inherit',
+                cwd: projectRoot
+            });
+        }
+        console.log('\n✅ Build completed successfully!');
+    }
+    catch (error) {
+        console.error('\n❌ Build failed:', error);
+        process.exit(1);
+    }
+});
+program
+    .command('dev')
+    .description('Start development server')
+    .action(async () => {
+    try {
+        console.log('🚀 Starting development server...');
+        const serverEntrypoint = path.join(libDir, 'server', 'index.js');
+        const devCommand = `NODE_ENV=development tsx ${serverEntrypoint}`;
+        execSync(devCommand, {
+            stdio: 'inherit',
+            cwd: projectRoot
+        });
+    }
+    catch (error) {
+        console.error('❌ Development server failed:', error);
+        process.exit(1);
+    }
+});
+program
+    .command('start')
+    .description('Start production server to serve built static files')
+    .option('-p, --port <port>', 'Port to serve on', '3456')
+    .option('-h, --host <host>', 'Host to serve on', 'localhost')
+    .action(async (options) => {
+    try {
+        console.log('🌐 Starting production server...');
+        const buildDir = path.join(projectRoot, '_build');
+        // Check if build directory exists
+        if (!fs.existsSync(buildDir)) {
+            console.error('❌ Build directory not found. Please run "static build" first.');
+            process.exit(1);
+        }
+        console.log(`📁 Serving files from: ${buildDir}`);
+        console.log(`🔗 Server running at: http://${options.host}:${options.port}`);
+        // Use http-server to serve the built files
+        const startCommand = `npx http-server "${buildDir}" -p ${options.port} -a ${options.host} -c-1`;
+        execSync(startCommand, {
+            stdio: 'inherit',
+            cwd: projectRoot
+        });
+    }
+    catch (error) {
+        console.error('❌ Production server failed:', error);
+        process.exit(1);
+    }
+});
+program.parse();

package/_build/scripts/create-static-app.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/_build/scripts/generate-test-multiapps.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Generate Test Multi-Apps CLI
+ * Creates multiple test applications for testing purposes
+ */
+export {};

package/_build/scripts/generate-test-multiapps.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Generate Test Multi-Apps CLI
+ * Creates multiple test applications for testing purposes
+ */
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs';
+const program = new Command();
+program
+    .name('generate-test-multiapps')
+    .description('Generate multiple test applications')
+    .version('1.0.0')
+    .argument('<command>', 'Command to execute (generate:test)')
+    .action(async (command) => {
+    try {
+        if (command !== 'generate:test') {
+            console.error(`❌ Unknown command: ${command}`);
+            process.exit(1);
+        }
+        console.log('🧪 Generating test applications...');
+        const testApps = ['test-app-1', 'test-app-2', 'test-app-3'];
+        const baseDir = path.resolve(process.cwd(), 'test-apps');
+        // Create test apps directory
+        if (!fs.existsSync(baseDir)) {
+            fs.mkdirSync(baseDir, { recursive: true });
+        }
+        for (const appName of testApps) {
+            const appPath = path.join(baseDir, appName);
+            // Skip if already exists
+            if (fs.existsSync(appPath)) {
+                console.log(`⏭️  Skipping ${appName} (already exists)`);
+                continue;
+            }
+            console.log(`📁 Creating ${appName}...`);
+            fs.mkdirSync(appPath, { recursive: true });
+            // Create basic structure
+            const srcPath = path.join(appPath, 'src');
+            fs.mkdirSync(srcPath, { recursive: true });
+            // Create package.json
+            const packageJson = {
+                name: appName,
+                version: '1.0.0',
+                type: 'module',
+                scripts: {
+                    dev: 'NODE_ENV=development tsx server.js',
+                    build: 'bt-staticjs build',
+                    start: 'npm run build && NODE_ENV=production tsx server.js'
+                },
+                dependencies: {
+                    '@bouygues-telecom/staticjs': '*',
+                    react: '^19.1.0',
+                    'react-dom': '^19.1.0'
+                }
+            };
+            fs.writeFileSync(path.join(appPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+            // Create basic React component
+            const indexComponent = `import React from 'react';
+
+export default function Index() {
+  return (
+    <div>
+      <h1>Welcome to ${appName}</h1>
+      <p>This is a test application generated for testing purposes.</p>
+    </div>
+  );
+}
+`;
+            fs.writeFileSync(path.join(srcPath, 'index.tsx'), indexComponent);
+        }
+        console.log('✅ Test applications generated successfully!');
+        console.log(`\nGenerated apps in: ${baseDir}`);
+    }
+    catch (error) {
+        console.error('❌ Failed to generate test apps:', error);
+        process.exit(1);
+    }
+});
+program.parse();

package/_build/server/config/index.d.ts

@@ -0,0 +1,20 @@
+export interface ServerConfig {
+    PORT: number;
+    NODE_ENV: string;
+    PROJECT_ROOT: string;
+    BUILD_DIR: string;
+    REQUEST_TIMEOUT: number;
+    BODY_SIZE_LIMIT: string;
+    RATE_LIMIT_WINDOW: number;
+    RATE_LIMIT_MAX: number;
+    REVALIDATE_RATE_LIMIT_MAX: number;
+    CACHE_MAX_AGE: number;
+    HOT_RELOAD_ENABLED: boolean;
+    WEBSOCKET_ENABLED: boolean;
+    FILE_WATCHING_ENABLED: boolean;
+    WEBSOCKET_PATH: string;
+    FILE_WATCH_DEBOUNCE: number;
+}
+export declare const CONFIG: ServerConfig;
+export declare const isDevelopment: boolean;
+export declare const isProduction: boolean;

package/_build/server/config/index.js

@@ -0,0 +1,25 @@
+/**
+ * Server configuration constants
+ * Centralized configuration for the StaticJS React template server
+ */
+import * as path from "node:path";
+export const CONFIG = {
+    PORT: Number(process.env.PORT) || 3456,
+    NODE_ENV: process.env.NODE_ENV || 'development',
+    PROJECT_ROOT: path.resolve(process.cwd()),
+    BUILD_DIR: '_build',
+    REQUEST_TIMEOUT: 30000, // 30 seconds
+    BODY_SIZE_LIMIT: '10mb',
+    RATE_LIMIT_WINDOW: 15 * 60 * 1000, // 15 minutes
+    RATE_LIMIT_MAX: 100, // requests per window
+    REVALIDATE_RATE_LIMIT_MAX: 10, // stricter limit for revalidate endpoint
+    CACHE_MAX_AGE: process.env.NODE_ENV === 'production' ? 86400 : 0, // 1 day in prod, no cache in dev
+    // Hot reload configuration
+    HOT_RELOAD_ENABLED: process.env.NODE_ENV === 'development',
+    WEBSOCKET_ENABLED: process.env.NODE_ENV === 'development',
+    FILE_WATCHING_ENABLED: process.env.NODE_ENV === 'development',
+    WEBSOCKET_PATH: '/ws',
+    FILE_WATCH_DEBOUNCE: 300, // milliseconds
+};
+export const isDevelopment = CONFIG.NODE_ENV === 'development';
+export const isProduction = CONFIG.NODE_ENV === 'production';

package/_build/server/config/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfigFnObject;
+export default _default;

package/_build/server/config/vite.config.js

@@ -0,0 +1,31 @@
+import path from "path";
+import { defineConfig } from "vite";
+import { addHydrationCodePlugin } from "./vite.plugin";
+import { loadCacheEntries } from "../../helpers/cachePages.js";
+import { CONFIG } from "./index";
+// Load cache entries using the refactored helper function
+const entries = loadCacheEntries(CONFIG.PROJECT_ROOT);
+export default defineConfig(({ mode }) => {
+    // Load environment variables from .env files
+    // const env = loadEnv(mode, CONFIG.PROJECT_ROOT, '');
+    // console.log(`[Vite] Loaded environment variables for mode: ${mode}`, env);
+    return {
+        resolve: {
+            alias: {
+                "@": path.resolve(CONFIG.PROJECT_ROOT, "src")
+            },
+        },
+        build: {
+            outDir: path.resolve(CONFIG.PROJECT_ROOT, CONFIG.BUILD_DIR),
+            emptyOutDir: false,
+            rollupOptions: {
+                input: entries,
+                output: {
+                    entryFileNames: "[name].js",
+                    chunkFileNames: "assets/vendor-[hash].js",
+                },
+            },
+        },
+        plugins: [addHydrationCodePlugin(entries)],
+    };
+});

package/_build/server/config/vite.plugin.d.ts

@@ -0,0 +1,11 @@
+export declare const addHydrationCodePlugin: (entries: {
+    [key: string]: string;
+}) => {
+    name: string;
+    configResolved(config: any): void;
+    buildStart(): void;
+    transform(code: string, id: string): {
+        code: string;
+        map: null;
+    } | null;
+};

package/_build/server/config/vite.plugin.js

@@ -0,0 +1,75 @@
+import crypto from "node:crypto";
+import path from "path";
+import { findClosestLayout } from "../../helpers/layoutDiscovery.js";
+const getDefaultExportFunctionName = (code) => {
+    const defaultExportRegex = /export\s+default\s+function\s+(\w+)/;
+    const match = code.match(defaultExportRegex);
+    if (match && match[1])
+        return match[1];
+    const defaultVarExportRegex = /export\s+default\s+(\w+)/;
+    const varMatch = code.match(defaultVarExportRegex);
+    if (varMatch && varMatch[1])
+        return varMatch[1];
+    return null;
+};
+export const addHydrationCodePlugin = (entries) => {
+    return {
+        name: "add-hydration-code",
+        configResolved(config) {
+            // Config resolved
+        },
+        buildStart() {
+            // Build started
+        },
+        transform(code, id) {
+            // Check if this is a page file
+            const isPageFile = Object.values(entries).includes(id);
+            if (!isPageFile) {
+                return null;
+            }
+            const componentName = getDefaultExportFunctionName(code);
+            if (!componentName) {
+                return null;
+            }
+            // Find the closest layout for this page
+            const rootDir = path.resolve(process.cwd(), "src");
+            const layoutPath = findClosestLayout(id, rootDir);
+            if (!layoutPath) {
+                console.warn(`No layout found for page ${id}, falling back to default App`);
+                return null;
+            }
+            // Get relative path for layout import
+            const layoutRelativePath = path.relative(path.dirname(id), layoutPath).replace(/\\/g, '/');
+            const layoutImportPath = layoutRelativePath.startsWith('.') ? layoutRelativePath : `./${layoutRelativePath}`;
+            // Component found, generating hydration code with discovered layout
+            const importReactDOM = `import ReactDOM from 'react-dom/client';`;
+            const importLayout = `import { Layout } from "${layoutImportPath.replace('.tsx', '')}";`;
+            const rootId = crypto
+                .createHash("sha256")
+                .update(`app-${id}`)
+                .digest("hex")
+                .slice(0, 10);
+            const initialDatasId = crypto
+                .createHash("sha256")
+                .update(`initial-data-${id}`)
+                .digest("hex")
+                .slice(0, 10);
+            const additionalCode = `
+export const rootId = 'app-${rootId}';
+export const initialDatasId = 'initial-data-${initialDatasId}';
+
+if (typeof document !== 'undefined') {
+  document.addEventListener('DOMContentLoaded', () => {
+    const initialDataScript = document.getElementById(initialDatasId);
+    const initialData = initialDataScript ? JSON.parse(initialDataScript.textContent || '{}') : {title: ''};
+    ReactDOM.hydrateRoot(document.getElementById(rootId), React.createElement(${componentName}, {data: initialData}));
+  });
+}`;
+            const transformedCode = importReactDOM + "\n" + importLayout + "\n" + code + "\n" + additionalCode;
+            return {
+                code: transformedCode,
+                map: null,
+            };
+        },
+    };
+};

package/_build/server/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Main server entry point for StaticJS React template
+ * Modular Express.js server with enhanced security, performance, and developer experience
+ */
+import { Express } from "express";
+/**
+ * Create and configure Express application
+ * @returns Promise<Express> - Configured Express application
+ */
+export declare const createApp: () => Promise<Express>;
+/**
+ * Initialize and start the server
+ * @returns Promise<Express> - Running Express application
+ */
+export declare const startStaticJSServer: () => Promise<Express>;
+export { isDevelopment } from "./config/index.js";
+export type { ServerConfig } from "./config/index.js";
+export { initializeViteServer } from "./utils/vite.js";
+export { setupProcessHandlers, startServer } from "./utils/startup.js";
+declare let app: Express | undefined;
+export default app;
+export declare const main: () => Promise<Express>;

package/_build/server/index.js

@@ -0,0 +1,124 @@
+/**
+ * Main server entry point for StaticJS React template
+ * Modular Express.js server with enhanced security, performance, and developer experience
+ */
+import express from "express";
+// Import configuration
+import { CONFIG, isDevelopment } from "./config/index.js";
+// Import middleware modules
+import { applySecurity } from "./middleware/security.js";
+import { applyPerformance } from "./middleware/performance.js";
+import { applyRateLimiting } from "./middleware/rateLimiting.js";
+import { applyParsing } from "./middleware/parsing.js";
+import { applyLogging } from "./middleware/logging.js";
+import { applyRuntime } from "./middleware/runtime.js";
+import { applyHotReload } from "./middleware/hotReload.js";
+import { applyStatic } from "./middleware/static.js";
+import { applyErrorHandling } from "./middleware/errorHandling.js";
+// Import route handlers
+import { registerApiRoutes } from "./routes/api.js";
+// Import utilities
+import { initializeViteServer } from "./utils/vite.js";
+import { setupProcessHandlers, startServer } from "./utils/startup.js";
+import { initializeWebSocketServer } from "./utils/websocket.js";
+import { initializeFileWatcher } from "./utils/fileWatcher.js";
+// Singleton pattern to prevent duplicate server initialization
+let serverInstance = null;
+let isServerStarting = false;
+/**
+ * Create and configure Express application
+ * @returns Promise<Express> - Configured Express application
+ */
+export const createApp = async () => {
+    // Creating Express application
+    const app = express();
+    // Apply middleware in the correct order
+    // Applying middleware
+    applySecurity(app);
+    applyPerformance(app);
+    applyRateLimiting(app);
+    applyParsing(app);
+    applyLogging(app);
+    // Hot reload middleware (development mode only) - MUST be before runtime
+    applyHotReload(app);
+    // Initialize Vite server and register JavaScript routes BEFORE runtime middleware
+    if (isDevelopment) {
+        await initializeViteServer(app);
+    }
+    // Runtime rendering middleware (development mode only)
+    // JavaScript routes are now registered before this middleware
+    applyRuntime(app);
+    // Static file serving - comes after runtime to avoid interfering with JS serving
+    applyStatic(app);
+    // API routes
+    registerApiRoutes(app);
+    // Error handling (must be last)
+    applyErrorHandling(app);
+    return app;
+};
+/**
+ * Initialize and start the server
+ * @returns Promise<Express> - Running Express application
+ */
+export const startStaticJSServer = async () => {
+    // Starting StaticJS server
+    // Prevent duplicate initialization
+    if (serverInstance) {
+        // Server already running
+        return serverInstance;
+    }
+    if (isServerStarting) {
+        // Server is already starting, waiting
+        // Wait for the other initialization to complete
+        while (isServerStarting && !serverInstance) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        return serverInstance;
+    }
+    isServerStarting = true;
+    try {
+        // Create Express app
+        const app = await createApp();
+        serverInstance = app;
+        // Start server (Vite is already initialized in createApp)
+        const server = await startServer(app);
+        // Initialize WebSocket server for hot reloading FIRST (development only)
+        if (CONFIG.WEBSOCKET_ENABLED && CONFIG.FILE_WATCHING_ENABLED) {
+            const wsServer = initializeWebSocketServer(server);
+            console.log('[Server] WebSocket server initialized');
+            // Wait a moment to ensure WebSocket server is fully ready
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // Initialize file watcher AFTER WebSocket server (development only)
+            const fileWatcher = initializeFileWatcher();
+            console.log('[Server] File watcher initialized');
+        }
+        // Setup graceful shutdown handlers
+        setupProcessHandlers(server);
+        isServerStarting = false;
+        return app;
+    }
+    catch (error) {
+        console.error('❌ Failed to start server:', error);
+        isServerStarting = false;
+        serverInstance = null;
+        process.exit(1);
+    }
+};
+// Export additional utilities for external use
+export { isDevelopment } from "./config/index.js";
+export { initializeViteServer } from "./utils/vite.js";
+export { setupProcessHandlers, startServer } from "./utils/startup.js";
+// Only start the server when this module is run directly (not when imported)
+let app;
+// Check if this module is being run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    console.log('[Server] Module executed directly, starting server...');
+    app = await startStaticJSServer();
+}
+else {
+    console.log('[Server] Module imported, not starting server automatically');
+}
+// Default export is the app creation function
+export default app;
+// Named export for the main function (for backwards compatibility)
+export const main = startStaticJSServer;