@stati/core 1.13.0 → 1.15.0

package/dist/core/utils/typescript.utils.d.ts

@@ -1,9 +1,11 @@
 /**
  * TypeScript compilation utilities using esbuild.
  * Provides functions for compiling TypeScript files and watching for changes.
+ * Supports multiple bundles with per-page targeting.
  * @module core/utils/typescript
  */
 import * as esbuild from 'esbuild';
+import { type CompiledBundleInfo } from './bundle-matching.utils.js';
 import type { TypeScriptConfig } from '../../types/config.js';
 import type { Logger } from '../../types/logging.js';
 /**
@@ -21,61 +23,69 @@ export interface CompileOptions {
     /** Logger instance for output */
     logger: Logger;
 }
-/**
- * Result of TypeScript compilation.
- */
-export interface CompileResult {
-    /** The generated bundle filename (e.g., 'bundle-a1b2c3d4.js'), or undefined if compilation was skipped */
-    bundleFilename?: string;
-}
 /**
  * Options for TypeScript file watcher.
+ * Note: Watcher is always in development mode (no hash, no minify, with sourcemaps).
  */
-export interface WatchOptions extends CompileOptions {
-    /** Callback invoked when files are recompiled */
-    onRebuild: () => void;
+export interface WatchOptions {
+    /** Root directory of the project */
+    projectRoot: string;
+    /** TypeScript configuration */
+    config: TypeScriptConfig;
+    /** Output directory (defaults to 'dist') */
+    outDir?: string;
+    /** Logger instance for output */
+    logger: Logger;
+    /** Callback invoked when files are recompiled, receives results and compile time in ms */
+    onRebuild: (results: CompiledBundleInfo[], compileTimeMs: number) => void;
 }
 /**
  * Compile TypeScript files using esbuild.
- * Returns the generated bundle filename for template injection.
+ * Supports multiple bundles with parallel compilation.
  *
  * @param options - Compilation options
- * @returns The compilation result with bundle filename
+ * @returns Array of compilation results for each bundle
  *
  * @example
  * ```typescript
- * const result = await compileTypeScript({
+ * const results = await compileTypeScript({
  *   projectRoot: process.cwd(),
- *   config: { enabled: true },
+ *   config: {
+ *     enabled: true,
+ *     bundles: [
+ *       { entryPoint: 'core.ts', bundleName: 'core' },
+ *       { entryPoint: 'docs.ts', bundleName: 'docs', include: ['/docs/**'] }
+ *     ]
+ *   },
  *   mode: 'production',
  *   logger: console,
  * });
- * console.log(result.bundleFilename); // 'bundle-a1b2c3d4.js'
+ * console.log(results[0].bundlePath); // '/_assets/core-a1b2c3d4.js'
  * ```
  */
-export declare function compileTypeScript(options: CompileOptions): Promise<CompileResult>;
+export declare function compileTypeScript(options: CompileOptions): Promise<CompiledBundleInfo[]>;
 /**
  * Create an esbuild watch context for development.
  * Watches for TypeScript file changes and recompiles automatically.
+ * Supports multiple bundles with selective recompilation.
  *
  * @param options - Watch options including rebuild callback
- * @returns The esbuild build context for cleanup
+ * @returns Array of esbuild build contexts for cleanup
  *
  * @example
  * ```typescript
- * const watcher = await createTypeScriptWatcher({
+ * const watchers = await createTypeScriptWatcher({
  *   projectRoot: process.cwd(),
  *   config: { enabled: true },
- *   mode: 'development',
  *   logger: console,
- *   onRebuild: () => console.log('Rebuilt!'),
+ *   onRebuild: (results, compileTimeMs) => console.log(`Rebuilt ${results.length} bundles in ${compileTimeMs}ms`),
  * });
  *
  * // Later, cleanup:
- * await watcher.dispose();
+ * await Promise.all(watchers.map(w => w.dispose()));
  * ```
  */
-export declare function createTypeScriptWatcher(options: WatchOptions): Promise<esbuild.BuildContext>;
+export declare function createTypeScriptWatcher(options: WatchOptions): Promise<esbuild.BuildContext[]>;
 /**
  * Compile stati.config.ts to a temporary JS file for import.
  * Returns the path to the compiled file.
@@ -98,20 +108,32 @@ export declare function compileStatiConfig(configPath: string): Promise<string>;
  */
 export declare function cleanupCompiledConfig(compiledPath: string): Promise<void>;
 /**
- * Auto-inject TypeScript bundle script tag into HTML before </body>.
- * Similar to SEO auto-injection, this adds the script tag automatically
+ * Validates a bundle path for safety against XSS attacks.
+ * Only allows safe ASCII characters: alphanumeric, hyphens, underscores, dots, and forward slashes.
+ * Must start with / and end with .js, no encoded characters or unicode allowed.
+ *
+ * @param bundlePath - The bundle path to validate
+ * @returns true if the path is safe, false otherwise
+ *
+ * @internal
+ */
+export declare function isValidBundlePath(bundlePath: string): boolean;
+/**
+ * Auto-inject TypeScript bundle script tags into HTML before </body>.
+ * Similar to SEO auto-injection, this adds script tags automatically
  * so users don't need to modify their templates.
+ * Supports multiple bundles - injects all matched bundles in order.
  *
  * @param html - Rendered HTML content
- * @param bundlePath - Path to the compiled bundle (e.g., '/_assets/bundle-a1b2c3d4.js')
- * @returns HTML with injected script tag
+ * @param bundlePaths - Array of paths to compiled bundles (e.g., ['/_assets/core.js', '/_assets/docs.js'])
+ * @returns HTML with injected script tags
  *
  * @example
  * ```typescript
  * const html = '<html><body>Content</body></html>';
- * const enhanced = autoInjectBundle(html, '/_assets/bundle.js');
- * // Returns: '<html><body>Content\n  <script type="module" src="/_assets/bundle.js"></script>\n</body></html>'
+ * const enhanced = autoInjectBundles(html, ['/_assets/core.js', '/_assets/docs.js']);
+ * // Returns HTML with both script tags injected before </body>
  * ```
  */
-export declare function autoInjectBundle(html: string, bundlePath: string): string;
+export declare function autoInjectBundles(html: string, bundlePaths: string[]): string;
 //# sourceMappingURL=typescript.utils.d.ts.map

package/dist/core/utils/typescript.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/typescript.utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAInC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAQrD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,0GAA0G;IAC1G,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,iDAAiD;IACjD,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAiCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA8CvF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAiD/B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgB5E;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAgCzE"}
+{"version":3,"file":"typescript.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/typescript.utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAInC,OAAO,EAA6B,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChG,OAAO,KAAK,EAAE,gBAAgB,EAAgB,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAQrD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,0FAA0F;IAC1F,SAAS,EAAE,CAAC,OAAO,EAAE,kBAAkB,EAAE,EAAE,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3E;AAmGD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAuC9F;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAqFjC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgB5E;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/E;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAqC7D;AAiBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,CA8B7E"}

package/dist/core/utils/typescript.utils.js

@@ -1,21 +1,26 @@
 /**
  * TypeScript compilation utilities using esbuild.
  * Provides functions for compiling TypeScript files and watching for changes.
+ * Supports multiple bundles with per-page targeting.
  * @module core/utils/typescript
  */
 import * as esbuild from 'esbuild';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
 import { pathExists } from './fs.utils.js';
-import { DEFAULT_TS_SRC_DIR, DEFAULT_TS_OUT_DIR, DEFAULT_TS_ENTRY_POINT, DEFAULT_TS_BUNDLE_NAME, } from '../../constants.js';
+import { validateUniqueBundleNames } from './bundle-matching.utils.js';
+import { DEFAULT_TS_SRC_DIR, DEFAULT_TS_OUT_DIR, DEFAULT_BUNDLES, DEFAULT_OUT_DIR, } from '../../constants.js';
+/**
+ * Resolves TypeScript config with defaults based on mode.
+ * @internal
+ */
 function resolveConfig(config, mode) {
     const isProduction = mode === 'production';
     return {
         enabled: config.enabled,
         srcDir: config.srcDir ?? DEFAULT_TS_SRC_DIR,
         outDir: config.outDir ?? DEFAULT_TS_OUT_DIR,
-        entryPoint: config.entryPoint ?? DEFAULT_TS_ENTRY_POINT,
-        bundleName: config.bundleName ?? DEFAULT_TS_BUNDLE_NAME,
+        bundles: config.bundles ?? [...DEFAULT_BUNDLES],
         // hash/minify: always false in dev (config ignored), configurable in prod (default true)
         hash: isProduction && (config.hash ?? true),
         minify: isProduction && (config.minify ?? true),
@@ -24,130 +29,196 @@ function resolveConfig(config, mode) {
     };
 }
 /**
- * Compile TypeScript files using esbuild.
- * Returns the generated bundle filename for template injection.
- *
- * @param options - Compilation options
- * @returns The compilation result with bundle filename
- *
- * @example
- * ```typescript
- * const result = await compileTypeScript({
- *   projectRoot: process.cwd(),
- *   config: { enabled: true },
- *   mode: 'production',
- *   logger: console,
- * });
- * console.log(result.bundleFilename); // 'bundle-a1b2c3d4.js'
- * ```
+ * Compile a single bundle using esbuild.
+ * @internal
  */
-export async function compileTypeScript(options) {
-    const { projectRoot, config, mode, logger, outDir: globalOutDir } = options;
-    const resolved = resolveConfig(config, mode);
-    const entryPath = path.join(projectRoot, resolved.srcDir, resolved.entryPoint);
-    // Output to configured build output directory (default: dist)
-    const outDir = path.join(projectRoot, globalOutDir || 'dist', resolved.outDir);
+async function compileSingleBundle(bundleConfig, resolvedConfig, projectRoot, globalOutDir, logger) {
+    const entryPath = path.join(projectRoot, resolvedConfig.srcDir, bundleConfig.entryPoint);
+    const outDir = path.join(projectRoot, globalOutDir, resolvedConfig.outDir);
     // Validate entry point exists
     if (!(await pathExists(entryPath))) {
-        logger.warning(`TypeScript entry point not found: ${entryPath}`);
-        logger.warning('Skipping TypeScript compilation.');
-        return {};
+        logger.warning(`TypeScript entry point not found: ${entryPath} (bundle: ${bundleConfig.bundleName})`);
+        return null;
     }
-    logger.info('Compiling TypeScript...');
     try {
         const result = await esbuild.build({
             entryPoints: [entryPath],
             bundle: true,
             outdir: outDir,
-            entryNames: resolved.hash ? `${resolved.bundleName}-[hash]` : resolved.bundleName,
-            minify: resolved.minify,
-            sourcemap: resolved.sourceMaps,
+            entryNames: resolvedConfig.hash
+                ? `${bundleConfig.bundleName}-[hash]`
+                : bundleConfig.bundleName,
+            minify: resolvedConfig.minify,
+            sourcemap: resolvedConfig.sourceMaps,
             target: 'es2022',
             format: 'esm',
             platform: 'browser',
             logLevel: 'silent',
             metafile: true,
         });
-        // Extract the generated filename for template injection
+        // Extract the generated filename for this bundle
         const outputs = Object.keys(result.metafile?.outputs ?? {});
         const bundleFile = outputs.find((f) => f.endsWith('.js'));
-        const bundleFilename = bundleFile ? path.basename(bundleFile) : `${resolved.bundleName}.js`;
-        logger.success(`TypeScript compiled: ${bundleFilename}`);
-        return { bundleFilename };
+        const bundleFilename = bundleFile ? path.basename(bundleFile) : `${bundleConfig.bundleName}.js`;
+        // Construct the path relative to site root
+        const bundlePath = path.posix.join('/', resolvedConfig.outDir, bundleFilename);
+        return {
+            config: bundleConfig,
+            filename: bundleFilename,
+            path: bundlePath,
+        };
     }
     catch (error) {
         if (error instanceof Error) {
-            logger.error(`TypeScript compilation failed: ${error.message}`);
+            logger.error(`Bundle '${bundleConfig.bundleName}' compilation failed: ${error.message}`);
         }
         throw error;
     }
 }
+/**
+ * Compile TypeScript files using esbuild.
+ * Supports multiple bundles with parallel compilation.
+ *
+ * @param options - Compilation options
+ * @returns Array of compilation results for each bundle
+ *
+ * @example
+ * ```typescript
+ * const results = await compileTypeScript({
+ *   projectRoot: process.cwd(),
+ *   config: {
+ *     enabled: true,
+ *     bundles: [
+ *       { entryPoint: 'core.ts', bundleName: 'core' },
+ *       { entryPoint: 'docs.ts', bundleName: 'docs', include: ['/docs/**'] }
+ *     ]
+ *   },
+ *   mode: 'production',
+ *   logger: console,
+ * });
+ * console.log(results[0].bundlePath); // '/_assets/core-a1b2c3d4.js'
+ * ```
+ */
+export async function compileTypeScript(options) {
+    const { projectRoot, config, mode, logger, outDir: globalOutDir } = options;
+    const resolved = resolveConfig(config, mode);
+    const outputDir = globalOutDir || DEFAULT_OUT_DIR;
+    // Handle empty bundles array
+    if (resolved.bundles.length === 0) {
+        logger.warning('TypeScript is enabled but no bundles are configured. Add bundles to your stati.config.ts or disable TypeScript.');
+        return [];
+    }
+    // Validate unique bundle names early - fail fast with clear error message
+    validateUniqueBundleNames(resolved.bundles);
+    logger.info('');
+    logger.info(`Compiling TypeScript (${resolved.bundles.length} bundle${resolved.bundles.length > 1 ? 's' : ''})...`);
+    // Compile all bundles in parallel
+    const compilationPromises = resolved.bundles.map((bundleConfig) => compileSingleBundle(bundleConfig, resolved, projectRoot, outputDir, logger));
+    const results = await Promise.all(compilationPromises);
+    // Filter out null results (skipped bundles) and collect successful ones
+    const successfulResults = results.filter((r) => r !== null);
+    if (successfulResults.length > 0) {
+        const bundleNames = successfulResults.map((r) => r.filename).join(', ');
+        logger.success(`TypeScript compiled: ${bundleNames}`);
+    }
+    else if (resolved.bundles.length > 0) {
+        logger.warning('No TypeScript bundles were compiled (all entry points missing).');
+    }
+    return successfulResults;
+}
 /**
  * Create an esbuild watch context for development.
  * Watches for TypeScript file changes and recompiles automatically.
+ * Supports multiple bundles with selective recompilation.
  *
  * @param options - Watch options including rebuild callback
- * @returns The esbuild build context for cleanup
+ * @returns Array of esbuild build contexts for cleanup
  *
  * @example
  * ```typescript
- * const watcher = await createTypeScriptWatcher({
+ * const watchers = await createTypeScriptWatcher({
  *   projectRoot: process.cwd(),
  *   config: { enabled: true },
- *   mode: 'development',
  *   logger: console,
- *   onRebuild: () => console.log('Rebuilt!'),
+ *   onRebuild: (results, compileTimeMs) => console.log(`Rebuilt ${results.length} bundles in ${compileTimeMs}ms`),
  * });
  *
  * // Later, cleanup:
- * await watcher.dispose();
+ * await Promise.all(watchers.map(w => w.dispose()));
  * ```
  */
 export async function createTypeScriptWatcher(options) {
-    const { projectRoot, config, mode, logger, onRebuild, outDir: globalOutDir } = options;
-    const resolved = resolveConfig(config, mode);
-    const entryPath = path.join(projectRoot, resolved.srcDir, resolved.entryPoint);
-    // Output to configured build output directory (default: dist)
-    const outDir = path.join(projectRoot, globalOutDir || 'dist', resolved.outDir);
-    // Validate entry point exists
-    if (!(await pathExists(entryPath))) {
-        logger.warning(`TypeScript entry point not found: ${entryPath}`);
-        throw new Error(`Entry point not found: ${entryPath}`);
-    }
-    const context = await esbuild.context({
-        entryPoints: [entryPath],
-        bundle: true,
-        outdir: outDir,
-        entryNames: resolved.bundleName, // Stable filename in dev mode (no hash)
-        minify: resolved.minify,
-        sourcemap: resolved.sourceMaps,
-        target: 'es2022',
-        format: 'esm',
-        platform: 'browser',
-        logLevel: 'silent',
-        plugins: [
-            {
-                name: 'stati-rebuild-notify',
-                setup(build) {
-                    build.onEnd((result) => {
-                        if (result.errors.length > 0) {
-                            result.errors.forEach((err) => {
-                                logger.error(`TypeScript error: ${err.text}`);
-                            });
-                        }
-                        else {
-                            logger.info('TypeScript recompiled.');
-                            onRebuild();
-                        }
-                    });
+    const { projectRoot, config, logger, onRebuild, outDir: globalOutDir } = options;
+    const resolved = resolveConfig(config, 'development');
+    const outputDir = globalOutDir || DEFAULT_OUT_DIR;
+    const outDir = path.join(projectRoot, outputDir, resolved.outDir);
+    const contexts = [];
+    const latestResults = new Map();
+    for (const bundleConfig of resolved.bundles) {
+        const entryPath = path.join(projectRoot, resolved.srcDir, bundleConfig.entryPoint);
+        // Validate entry point exists
+        if (!(await pathExists(entryPath))) {
+            logger.warning(`TypeScript entry point not found: ${entryPath} (bundle: ${bundleConfig.bundleName})`);
+            continue;
+        }
+        const context = await esbuild.context({
+            entryPoints: [entryPath],
+            bundle: true,
+            outdir: outDir,
+            entryNames: bundleConfig.bundleName, // Stable filename in dev mode (no hash)
+            minify: false, // Dev mode: never minify for fast rebuilds
+            sourcemap: true, // Dev mode: always enable for debugging
+            target: 'es2022',
+            format: 'esm',
+            platform: 'browser',
+            logLevel: 'silent',
+            metafile: true,
+            plugins: [
+                {
+                    name: 'stati-rebuild-notify',
+                    setup(build) {
+                        let startTime;
+                        build.onStart(() => {
+                            startTime = Date.now();
+                        });
+                        build.onEnd((result) => {
+                            const compileTime = Date.now() - startTime;
+                            if (result.errors.length > 0) {
+                                result.errors.forEach((err) => {
+                                    logger.error(`TypeScript error in '${bundleConfig.bundleName}': ${err.text}`);
+                                });
+                            }
+                            else {
+                                // Extract the generated filename
+                                const outputs = Object.keys(result.metafile?.outputs ?? {});
+                                const bundleFile = outputs.find((f) => f.endsWith('.js'));
+                                const bundleFilename = bundleFile
+                                    ? path.basename(bundleFile)
+                                    : `${bundleConfig.bundleName}.js`;
+                                const bundlePath = path.posix.join('/', resolved.outDir, bundleFilename);
+                                const bundleResult = {
+                                    config: bundleConfig,
+                                    filename: bundleFilename,
+                                    path: bundlePath,
+                                };
+                                latestResults.set(bundleConfig.bundleName, bundleResult);
+                                logger.info(`TypeScript '${bundleConfig.bundleName}' recompiled.`);
+                                // Notify with all current results and compile time
+                                onRebuild(Array.from(latestResults.values()), compileTime);
+                            }
+                        });
+                    },
                 },
-            },
-        ],
-    });
-    // Start watching
-    await context.watch();
-    logger.info(`Watching TypeScript files in ${resolved.srcDir}/`);
-    return context;
+            ],
+        });
+        // Start watching
+        await context.watch();
+        contexts.push(context);
+    }
+    if (contexts.length > 0) {
+        logger.info(`Watching TypeScript files in ${resolved.srcDir}/ (${contexts.length} bundle${contexts.length > 1 ? 's' : ''})`);
+    }
+    return contexts;
 }
 /**
  * Compile stati.config.ts to a temporary JS file for import.
@@ -192,35 +263,86 @@ export async function cleanupCompiledConfig(compiledPath) {
     }
 }
 /**
- * Auto-inject TypeScript bundle script tag into HTML before </body>.
- * Similar to SEO auto-injection, this adds the script tag automatically
+ * Validates a bundle path for safety against XSS attacks.
+ * Only allows safe ASCII characters: alphanumeric, hyphens, underscores, dots, and forward slashes.
+ * Must start with / and end with .js, no encoded characters or unicode allowed.
+ *
+ * @param bundlePath - The bundle path to validate
+ * @returns true if the path is safe, false otherwise
+ *
+ * @internal
+ */
+export function isValidBundlePath(bundlePath) {
+    // Reject non-string or empty paths
+    if (typeof bundlePath !== 'string' || bundlePath.length === 0) {
+        return false;
+    }
+    // Reject paths with null bytes (can bypass security checks)
+    if (bundlePath.includes('\0')) {
+        return false;
+    }
+    // Reject paths with control characters or non-ASCII characters
+    // Check that all characters are in printable ASCII range (32-126)
+    for (let i = 0; i < bundlePath.length; i++) {
+        const charCode = bundlePath.charCodeAt(i);
+        if (charCode < 32 || charCode > 126) {
+            return false;
+        }
+    }
+    // Reject URL-encoded characters (e.g., %20, %3C) and unicode escapes (e.g., \u003C)
+    if (/%[0-9a-fA-F]{2}/.test(bundlePath) || /\\u[0-9a-fA-F]{4}/.test(bundlePath)) {
+        return false;
+    }
+    // Reject HTML entities (e.g., &lt; &#60; &#x3C;)
+    if (/&#?[a-zA-Z0-9]+;/.test(bundlePath)) {
+        return false;
+    }
+    // Reject path traversal attempts
+    if (bundlePath.includes('..') || bundlePath.includes('//')) {
+        return false;
+    }
+    // Validate against strict safe pattern
+    const safePathPattern = /^\/[a-zA-Z0-9_\-./]+\.js$/;
+    return safePathPattern.test(bundlePath);
+}
+/**
+ * Checks if a bundle script tag is already present in the HTML.
+ *
+ * @param html - The HTML content to check
+ * @param bundlePath - The bundle path to look for
+ * @returns true if the bundle is already included, false otherwise
+ *
+ * @internal
+ */
+function isBundleAlreadyIncluded(html, bundlePath) {
+    const escapedPath = bundlePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const scriptTagPattern = new RegExp(`<script[^>]*\\ssrc=["']${escapedPath}["'][^>]*>`, 'i');
+    return scriptTagPattern.test(html);
+}
+/**
+ * Auto-inject TypeScript bundle script tags into HTML before </body>.
+ * Similar to SEO auto-injection, this adds script tags automatically
  * so users don't need to modify their templates.
+ * Supports multiple bundles - injects all matched bundles in order.
  *
  * @param html - Rendered HTML content
- * @param bundlePath - Path to the compiled bundle (e.g., '/_assets/bundle-a1b2c3d4.js')
- * @returns HTML with injected script tag
+ * @param bundlePaths - Array of paths to compiled bundles (e.g., ['/_assets/core.js', '/_assets/docs.js'])
+ * @returns HTML with injected script tags
  *
  * @example
  * ```typescript
  * const html = '<html><body>Content</body></html>';
- * const enhanced = autoInjectBundle(html, '/_assets/bundle.js');
- * // Returns: '<html><body>Content\n  <script type="module" src="/_assets/bundle.js"></script>\n</body></html>'
+ * const enhanced = autoInjectBundles(html, ['/_assets/core.js', '/_assets/docs.js']);
+ * // Returns HTML with both script tags injected before </body>
  * ```
  */
-export function autoInjectBundle(html, bundlePath) {
-    if (!bundlePath) {
-        return html;
-    }
-    // Sanitize bundlePath to prevent XSS attacks
-    // Only allow safe characters: alphanumeric, hyphens, underscores, dots, and forward slashes
-    // Must start with / and end with .js
-    const safePathPattern = /^\/[\w\-./]+\.js$/;
-    if (!safePathPattern.test(bundlePath)) {
-        // Invalid path format, skip injection to prevent potential XSS
+export function autoInjectBundles(html, bundlePaths) {
+    if (!bundlePaths || bundlePaths.length === 0) {
         return html;
     }
-    // Check if the bundle is already included (avoid duplicate injection)
-    if (html.includes(bundlePath)) {
+    // Filter paths: must be valid and not already included in HTML
+    const validPaths = bundlePaths.filter((bundlePath) => isValidBundlePath(bundlePath) && !isBundleAlreadyIncluded(html, bundlePath));
+    if (validPaths.length === 0) {
         return html;
     }
     // Find </body> tag (case-insensitive)
@@ -231,7 +353,9 @@ export function autoInjectBundle(html, bundlePath) {
     const bodyClosePos = bodyCloseMatch.index;
     const before = html.substring(0, bodyClosePos);
     const after = html.substring(bodyClosePos);
-    // Inject script tag before </body> with proper indentation
-    const scriptTag = `  <script type="module" src="${bundlePath}"></script>\n`;
-    return `${before}${scriptTag}${after}`;
+    // Inject all script tags before </body>
+    const scriptTags = validPaths
+        .map((bundlePath) => `<script type="module" src="${bundlePath}"></script>`)
+        .join('\n');
+    return `${before}${scriptTags}\n${after}`;
 }

package/dist/index.d.ts

@@ -19,7 +19,7 @@
  * await build({ clean: true });
  * ```
  */
-export type { StatiConfig, PageModel, FrontMatter, BuildContext, PageContext, BuildHooks, NavNode, ISGConfig, AgingRule, BuildStats, } from './types/index.js';
+export type { StatiConfig, PageModel, FrontMatter, BuildContext, PageContext, BuildHooks, NavNode, ISGConfig, AgingRule, BuildStats, BundleConfig, } from './types/index.js';
 export type { SEOMetadata, SEOConfig, SEOContext, SEOValidationResult, SEOTagType, RobotsConfig, OpenGraphConfig, OpenGraphImage, OpenGraphArticle, TwitterCardConfig, AuthorConfig, } from './types/index.js';
 export type { SitemapConfig, SitemapEntry, SitemapGenerationResult, ChangeFrequency, } from './types/index.js';
 export type { RSSConfig, RSSFeedConfig, RSSGenerationResult } from './types/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,aAAa,EACb,YAAY,EACZ,uBAAuB,EACvB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtF,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG1F,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAG1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,EACV,YAAY,GACb,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,aAAa,EACb,YAAY,EACZ,uBAAuB,EACvB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtF,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG1F,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAG1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}