fluxion-ts 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -0,0 +1,1571 @@
+import fs, { existsSync } from 'node:fs';
+import cluster from 'node:cluster';
+import os from 'node:os';
+import http from 'node:http';
+import path from 'node:path';
+
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		// 21 isn't widely supported and 22 does the same thing
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29],
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+
+		// Bright color
+		blackBright: [90, 39],
+		gray: [90, 39], // Alias of `blackBright`
+		grey: [90, 39], // Alias of `blackBright`
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39],
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+
+		// Bright color
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49], // Alias of `bgBlackBright`
+		bgGrey: [100, 49], // Alias of `bgBlackBright`
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49],
+	},
+};
+
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+
+function assembleStyles() {
+	const codes = new Map();
+
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`,
+			};
+
+			group[styleName] = styles$1[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false,
+		});
+	}
+
+	Object.defineProperty(styles$1, 'codes', {
+		value: codes,
+		enumerable: false,
+	});
+
+	styles$1.color.close = '\u001B[39m';
+	styles$1.bgColor.close = '\u001B[49m';
+
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16
+					+ (36 * Math.round(red / 255 * 5))
+					+ (6 * Math.round(green / 255 * 5))
+					+ Math.round(blue / 255 * 5);
+			},
+			enumerable: false,
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let [colorString] = matches;
+
+				if (colorString.length === 3) {
+					colorString = [...colorString].map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					/* eslint-disable no-bitwise */
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF,
+					/* eslint-enable no-bitwise */
+				];
+			},
+			enumerable: false,
+		},
+		hexToAnsi256: {
+			value: hex => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false,
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) {
+					return 30 + code;
+				}
+
+				if (code < 16) {
+					return 90 + (code - 8);
+				}
+
+				let red;
+				let green;
+				let blue;
+
+				if (code >= 232) {
+					red = (((code - 232) * 10) + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+
+					const remainder = code % 36;
+
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = (remainder % 6) / 5;
+				}
+
+				const value = Math.max(red, green, blue) * 2;
+
+				if (value === 0) {
+					return 30;
+				}
+
+				// eslint-disable-next-line no-bitwise
+				let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+
+				if (value === 2) {
+					result += 60;
+				}
+
+				return result;
+			},
+			enumerable: false,
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false,
+		},
+		hexToAnsi: {
+			value: hex => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false,
+		},
+	});
+
+	return styles$1;
+}
+
+const ansiStyles = assembleStyles();
+
+/* eslint-env browser */
+
+const level = (() => {
+	if (!('navigator' in globalThis)) {
+		return 0;
+	}
+
+	if (globalThis.navigator.userAgentData) {
+		const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');
+		if (brand && brand.version > 93) {
+			return 3;
+		}
+	}
+
+	if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) {
+		return 1;
+	}
+
+	return 0;
+})();
+
+const colorSupport = level !== 0 && {
+	level};
+
+const supportsColor = {
+	stdout: colorSupport,
+	stderr: colorSupport,
+};
+
+// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+const {stdout: stdoutColor, stderr: stderrColor} = supportsColor;
+
+const GENERATOR = Symbol('GENERATOR');
+const STYLER = Symbol('STYLER');
+const IS_EMPTY = Symbol('IS_EMPTY');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m',
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
+
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+const chalkFactory = options => {
+	const chalk = (...strings) => strings.join(' ');
+	applyOptions(chalk, options);
+
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+
+	return chalk;
+};
+
+function createChalk(options) {
+	return chalkFactory(options);
+}
+
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		},
+	};
+}
+
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this[STYLER], true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	},
+};
+
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === 'rgb') {
+		if (level === 'ansi16m') {
+			return ansiStyles[type].ansi16m(...arguments_);
+		}
+
+		if (level === 'ansi256') {
+			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		}
+
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+
+	if (model === 'hex') {
+		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+	}
+
+	return ansiStyles[type][model](...arguments_);
+};
+
+const usedModels = ['rgb', 'hex', 'ansi256'];
+
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+}
+
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		},
+	},
+});
+
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent,
+	};
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+	// Single argument is hot path, implicit coercion is faster than anything
+	// eslint-disable-next-line no-implicit-coercion
+	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto);
+
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+
+	return builder;
+};
+
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self[IS_EMPTY] ? '' : string;
+	}
+
+	let styler = self[STYLER];
+
+	if (styler === undefined) {
+		return string;
+	}
+
+	const {openAll, closeAll} = styler;
+	if (string.includes('\u001B')) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
+
+			styler = styler.parent;
+		}
+	}
+
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
+
+	return openAll + string + closeAll;
+};
+
+Object.defineProperties(createChalk.prototype, styles);
+
+const chalk = createChalk();
+createChalk({level: stderrColor ? stderrColor.level : 0});
+
+function dtm(dt = new Date()) {
+    const y = dt.getFullYear();
+    const m = String(dt.getMonth() + 1).padStart(2, '0');
+    const d = String(dt.getDate()).padStart(2, '0');
+    const hh = String(dt.getHours()).padStart(2, '0');
+    const mm = String(dt.getMinutes()).padStart(2, '0');
+    const ss = String(dt.getSeconds()).padStart(2, '0');
+    const ms = String(dt.getMilliseconds()).padStart(3, '0');
+    return `${y}.${m}.${d} ${hh}:${mm}:${ss}.${ms}`;
+}
+
+const $stringify = JSON.stringify;
+const $keys = Object.keys;
+
+function loadFunction(injectionConfig) {
+    const m = require(injectionConfig.modulePath);
+    if (typeof m === 'function') {
+        return m;
+    }
+    else if (typeof m.default === 'function') {
+        return m.default;
+    }
+    else if (typeof m.handler === 'function') {
+        return m.handler;
+    }
+    else {
+        throw new Error(`[FluxionTs error] Invalid handler module '${injectionConfig.modulePath}', make sure it has a default export or named export called "handler" which is a function`);
+    }
+}
+
+const safeStringify = (value) => {
+    try {
+        return $stringify(value);
+    }
+    catch {
+        return '[unserializable]';
+    }
+};
+const ColoredLevels = {
+    INFO: chalk.hex('#0386e3')('INFO'),
+    WARN: chalk.hex('#fb923c')('WARN'),
+    ERROR: chalk.hex('#ef4444')('ERROR'),
+    SUCC: chalk.hex('#22c55e')('SUCC'),
+    DEBUG: chalk.hex('#d327e0')('DEBUG'),
+    VERBOSE: chalk.hex('#36ffeb')('SUCC'),
+};
+const TimestampColor = chalk.hex('#166534');
+const oneLineLogger = (entry) => {
+    const { level: rawLevel, timestamp: rawTimestamp, event: rawEvent, message: rawMessage, ...fields } = entry;
+    const timestamp = TimestampColor(`[${rawTimestamp}]`);
+    const level = ColoredLevels[rawLevel] ?? rawLevel;
+    const body = rawMessage ?? rawEvent;
+    const fieldsText = $keys(fields).length > 0 ? ` ${chalk.dim(safeStringify(fields))}` : '';
+    console.log(`${timestamp} ${level} ${body}${fieldsText}`);
+};
+/**
+ * & Logger Options here is checked by normalizeOptions function.
+ */
+function resolveLoggerSink(cx) {
+    const loggerOption = cx.options.logger;
+    if (loggerOption === undefined || loggerOption === 'one-line') {
+        return oneLineLogger;
+    }
+    if (loggerOption === 'json-line') {
+        return (entry) => console.log(safeStringify(entry));
+    }
+    return loadFunction(loggerOption);
+}
+function createLogger(cx) {
+    const sink = resolveLoggerSink(cx);
+    const logger = {
+        write(level, event, fields = {}) {
+            const entry = {
+                ...fields,
+                timestamp: dtm(),
+                level,
+                event,
+            };
+            try {
+                sink(entry);
+            }
+            catch {
+                // Ignore logger sink failures to avoid breaking request handling.
+            }
+        },
+        info(event, fields) {
+            this.write('INFO', event, fields);
+        },
+        warn(event, fields) {
+            this.write('WARN', event, fields);
+        },
+        error(event, fields) {
+            this.write('ERROR', event, fields);
+        },
+        succ(event, fields) {
+            this.write('SUCC', event, fields);
+        },
+        debug(event, fields) {
+            this.write('DEBUG', event, fields);
+        },
+        verbose(event, fields) {
+            this.write('VERBOSE', event, fields);
+        },
+    };
+    return logger;
+}
+/**
+ * ! Error.isError needs Node.js 24
+ */
+const getErrorMessage = (error) => typeof error === 'object' && error !== null ? error.message : String(error);
+
+var whether;
+(function (whether) {
+    whether.isObject = (value) => {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    };
+})(whether || (whether = {}));
+var expect;
+(function (expect) {
+    function isObject(o, message) {
+        if (typeof o !== 'object' || o === null) {
+            $throw(message);
+        }
+    }
+    expect.isObject = isObject;
+    function isString(s, message) {
+        if (typeof s !== 'string') {
+            $throw(message);
+        }
+    }
+    expect.isString = isString;
+    function isNumber(n, message) {
+        if (typeof n !== 'number') {
+            $throw(message);
+        }
+    }
+    expect.isNumber = isNumber;
+    function isPositiveInteger(n, message) {
+        if (typeof n !== 'number' || n <= 0 || !Number.isSafeInteger(n)) {
+            $throw(message);
+        }
+    }
+    expect.isPositiveInteger = isPositiveInteger;
+    function isObjectArray(arr, message) {
+        if (!Array.isArray(arr) || arr.some((item) => typeof item !== 'object' || item === null)) {
+            $throw(message);
+        }
+    }
+    expect.isObjectArray = isObjectArray;
+})(expect || (expect = {}));
+
+/**
+ * Resolves runtime options with framework defaults.
+ */
+function resolveWorkerOptions(options) {
+    return {
+        maxWorkerCount: options.maxWorkerCount ?? 4,
+        requestTimeoutMs: options.requestTimeoutMs ?? 3000,
+        maxInflight: options.maxInflight ?? 64,
+        memorySoftLimitMb: options.memorySoftLimitMb ?? 96,
+        memoryHardLimitMb: options.memoryHardLimitMb ?? 128,
+        memorySampleIntervalMs: options.memorySampleIntervalMs ?? 5000,
+        maxOldGenerationSizeMb: options.maxOldGenerationSizeMb ?? 128,
+        maxYoungGenerationSizeMb: options.maxYoungGenerationSizeMb ?? 32,
+        stackSizeMb: options.stackSizeMb ?? 4,
+        maxResponseBytes: options.maxResponseBytes ?? 2 * 1024 * 1024,
+    };
+}
+function expectLoggerOption(o) {
+    if (o === 'one-line' || o === 'json-line') {
+        return;
+    }
+    if (typeof o === 'object' && o !== null && typeof o.modulePath === 'string' && typeof o.name === 'string') {
+        return;
+    }
+    throw new Error(`[FluxionTs error] Invalid logger option, must be 'one-line', 'json-line' or { modulePath: string; name: string; }`);
+}
+/**
+ * Normalize options and create necessary resources like the dynamic directory and logger.
+ */
+function normalizeOptions(options) {
+    expect.isObject(options, 'FluxionOptions must be an object');
+    let { dir, host, port, metaPort, injections = [], moduleDir = process.cwd(), workerOptions = {}, maxRequestBytes = 8000000, reloadDelay = 300, apiExts = ['.ts'], routerExclude = [], } = options;
+    const logger = options.logger ?? 'one-line';
+    expectLoggerOption(logger);
+    expect.isString(dir, 'FluxionOptions.dir must be a string');
+    expect.isString(moduleDir, 'FluxionOptions.moduleDir must be a string');
+    expect.isString(host, 'FluxionOptions.host must be a string');
+    expect.isPositiveInteger(reloadDelay, 'FluxionOptions.reloadDelay must be a positive integer');
+    if (reloadDelay < 50) {
+        throw new Error('[FluxionTs error] FluxionOptions.reloadDelay must be greater than or equal to 50');
+    }
+    expect.isPositiveInteger(port, 'FluxionOptions.port must be a positive integer');
+    if (port > 65535) {
+        throw new Error('[FluxionTs error] FluxionOptions.port must be less than or equal to 65535');
+    }
+    metaPort ?? (metaPort = port + 1);
+    expect.isPositiveInteger(metaPort, 'FluxionOptions.metaPort must be a positive integer');
+    if (metaPort > 65535) {
+        throw new Error('[FluxionTs error] FluxionOptions.metaPort must be less than or equal to 65535');
+    }
+    if (metaPort === port) {
+        throw new Error('[FluxionTs error] FluxionOptions.metaPort must be different from FluxionOptions.port');
+    }
+    expect.isObjectArray(injections, 'FluxionOptions.injections must be an array of objects');
+    expect.isObject(workerOptions, 'FluxionOptions.workerOptions must be an object');
+    expect.isPositiveInteger(maxRequestBytes, 'FluxionOptions.maxRequestBytes must be a positive integer');
+    if (!existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return {
+        dir,
+        host,
+        port,
+        reloadDelay,
+        metaPort,
+        injections,
+        moduleDir,
+        workerOptions: resolveWorkerOptions(workerOptions),
+        maxRequestBytes,
+        logger,
+        apiExts,
+        routerExclude,
+    };
+}
+
+const INJECTION_KEY = Symbol.for('fluxion.injection');
+const isPrimaryMessage = (v) => [100 /* PrimaryAction.Ping */].includes(v?.type);
+const isWorkerMessage = (v) => [202 /* WorkerAction.Pong */, 200 /* WorkerAction.Created */, 201 /* WorkerAction.Ready */, 203 /* WorkerAction.Stats */].includes(v?.type);
+
+const sendToPrimary = (message) => process.send?.(message);
+const sendToWorker = (worker, message) => worker.send(message);
+
+const DUMMY_BASE_URL = 'http://fluxion.local';
+const META_PREFIX = '/_fluxion';
+const STATIC_CONTENT_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.ico': 'image/x-icon',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.txt': 'text/plain; charset=utf-8',
+    '.webp': 'image/webp',
+};
+
+function sendJson(res, payload, statusCode = 200 /* HttpCode.Ok */) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify(payload));
+}
+function safeSendJson(res, payload, statusCode = 200 /* HttpCode.Ok */) {
+    if (res.writableEnded) {
+        return;
+    }
+    if (res.headersSent) {
+        res.end();
+        return;
+    }
+    sendJson(res, payload, statusCode);
+}
+
+function createPrimaryMetaApiServer(cx, getWorkersSnapshot) {
+    const server = http.createServer((req, res) => {
+        const method = req.method ?? 'GET';
+        let pathname = '/';
+        try {
+            pathname = new URL(req.url ?? '/', 'http://fluxion.local').pathname;
+        }
+        catch {
+            sendJson(res, { message: 'Bad Request: invalid url' }, 400 /* HttpCode.BadRequest */);
+            return;
+        }
+        if (method === 'GET' && pathname === META_PREFIX + '/healthz') {
+            sendJson(res, {
+                ok: true,
+                role: 'primary',
+                pid: process.pid,
+                now: Date.now(),
+                uptimeSeconds: Number(process.uptime().toFixed(3)),
+            });
+            return;
+        }
+        if (method === 'GET' && pathname === META_PREFIX + '/workers') {
+            sendJson(res, {
+                ok: true,
+                now: Date.now(),
+                workers: getWorkersSnapshot(),
+            });
+            return;
+        }
+        sendJson(res, { message: 'Not Found' }, 404 /* HttpCode.NotFound */);
+    });
+    server.on('listening', () => {
+        cx.logger.info('MetaApiStarted', {
+            pid: process.pid,
+            host: cx.options.host,
+            port: cx.options.metaPort,
+            prefix: META_PREFIX,
+        });
+    });
+    server.on('error', (error) => {
+        cx.logger.error('MetaApiError', {
+            host: cx.options.host,
+            port: cx.options.metaPort,
+            error: getErrorMessage(error),
+        });
+        process.exit(1);
+    });
+    server.listen(cx.options.metaPort, cx.options.host);
+    return server;
+}
+
+const bytesToMb = (bytes) => Number((bytes / 1024 / 1024).toFixed(2));
+function initPrimary(cx) {
+    if (!cluster.isPrimary) {
+        throw new Error('[FluxionTs error] createPrimary should only be called in primary process');
+    }
+    const { workerOptions } = cx.options;
+    const cpuCount = Math.max(1, os.cpus().length);
+    const workerCount = Math.max(1, Math.min(workerOptions.maxWorkerCount ?? Math.min(2, cpuCount), cpuCount));
+    cx.logger.info('PrimaryStarted', {
+        pid: process.pid,
+        workers: workerCount,
+        host: cx.options.host,
+        port: cx.options.port,
+        metaPort: cx.options.metaPort,
+    });
+    const workers = new Map();
+    const getWorkersSnapshot = () => {
+        return {
+            primaryPid: process.pid,
+            host: cx.options.host,
+            port: cx.options.port,
+            metaPort: cx.options.metaPort,
+            uptimeSeconds: Number(process.uptime().toFixed(3)),
+            workers: Array.from(workers.entries()).map(([workerId, info]) => {
+                const { instance } = info;
+                const stats = info.lastStats;
+                return {
+                    workerId,
+                    pid: info.pid ?? instance.process.pid ?? null,
+                    state: info.state,
+                    createdAt: info.createdAt,
+                    readyAt: info.readyAt ?? null,
+                    connected: instance.isConnected(),
+                    dead: instance.isDead(),
+                    exitedAfterDisconnect: instance.exitedAfterDisconnect,
+                    lastPongAt: info.lastPongAt ?? null,
+                    lastRttMs: info.lastRttMs ?? null,
+                    stats: stats === undefined
+                        ? null
+                        : {
+                            at: stats.at,
+                            uptimeSeconds: stats.uptimeSeconds,
+                            cpu: stats.cpu,
+                            memory: {
+                                ...stats.memory,
+                                rssMb: bytesToMb(stats.memory.rss),
+                                heapTotalMb: bytesToMb(stats.memory.heapTotal),
+                                heapUsedMb: bytesToMb(stats.memory.heapUsed),
+                                externalMb: bytesToMb(stats.memory.external),
+                                arrayBuffersMb: bytesToMb(stats.memory.arrayBuffers),
+                            },
+                        },
+                };
+            }),
+        };
+    };
+    createPrimaryMetaApiServer(cx, getWorkersSnapshot);
+    const attachWorker = (worker) => {
+        const workerInfo = {
+            state: 'creating',
+            pid: worker.process.pid,
+            createdAt: Date.now(),
+            instance: worker,
+        };
+        workers.set(worker.id, workerInfo);
+        worker.on('message', (raw) => {
+            if (!isWorkerMessage(raw)) {
+                return;
+            }
+            if (raw.type === 202 /* WorkerAction.Pong */) {
+                const rtt = Date.now() - raw.sentAt;
+                workerInfo.pid = raw.pid;
+                workerInfo.lastPongAt = Date.now();
+                workerInfo.lastRttMs = rtt;
+                return;
+            }
+            if (raw.type === 201 /* WorkerAction.Ready */) {
+                workerInfo.state = 'ready';
+                workerInfo.pid = raw.pid;
+                workerInfo.readyAt = Date.now();
+                cx.logger.info('WorkerReady', { workerId: worker.id, pid: raw.pid });
+                return;
+            }
+            if (raw.type === 200 /* WorkerAction.Created */) {
+                workerInfo.state = 'created';
+                workerInfo.pid = raw.pid;
+                cx.logger.info('WorkerCreated', { workerId: worker.id, pid: raw.pid });
+                return;
+            }
+            if (raw.type === 203 /* WorkerAction.Stats */) {
+                workerInfo.pid = raw.pid;
+                workerInfo.lastStats = raw.stats;
+            }
+        });
+        worker.on('exit', (code, signal) => {
+            workers.delete(worker.id);
+            cx.logger.warn('WorkerExited', {
+                workerId: worker.id,
+                pid: worker.process.pid ?? 'unknown',
+                code,
+                signal: signal ?? 'none',
+            });
+        });
+    };
+    for (let i = 0; i < workerCount; i++) {
+        attachWorker(cluster.fork({ WORKER_ID: String(i + 1) }));
+    }
+    const pingTimer = setInterval(() => {
+        const sentAt = Date.now();
+        for (const info of workers.values()) {
+            if (!info.instance.isConnected()) {
+                continue;
+            }
+            try {
+                sendToWorker(info.instance, { type: 100 /* PrimaryAction.Ping */, sentAt });
+            }
+            catch {
+                // Ignore transient IPC errors; worker lifecycle events will reconcile state.
+            }
+        }
+    }, 5000);
+    pingTimer.unref();
+}
+
+/**
+ * For low version of Node.js that does not support `Promise.try`, we can implement it ourselves.
+ *
+ * Only for async functions.
+ */
+function PromiseTry(fn, ...args) {
+    return new Promise((resolve, reject) => {
+        // in case `fn` throws synchronously, we catch it and reject the promise
+        try {
+            fn(...args)
+                .then(resolve)
+                .catch(reject);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+
+function getRealIp(req) {
+    const forwardedFor = req.headersDistinct['x-forwarded-for'];
+    if (forwardedFor) {
+        const firstForwarded = forwardedFor[0]?.split(',')[0]?.trim();
+        if (firstForwarded && firstForwarded.length > 0) {
+            return firstForwarded;
+        }
+    }
+    const realIp = req.headersDistinct['x-real-ip']?.[0].trim();
+    if (realIp !== undefined) {
+        return realIp;
+    }
+    return req.socket.remoteAddress ?? 'unknown';
+}
+function isTextualContentType(contentType) {
+    if (contentType === undefined) {
+        return false;
+    }
+    const normalized = contentType.toLowerCase();
+    return (normalized.startsWith('text/') ||
+        normalized.includes('json') ||
+        normalized.includes('xml') ||
+        normalized.includes('x-www-form-urlencoded') ||
+        normalized.includes('javascript'));
+}
+
+function toURL(rawUrl) {
+    if (rawUrl === undefined) {
+        return undefined;
+    }
+    try {
+        return new URL(rawUrl, DUMMY_BASE_URL);
+    }
+    catch {
+        return undefined;
+    }
+}
+
+function parseQuery(searchParams) {
+    const query = {};
+    for (const [key, value] of searchParams.entries()) {
+        const existing = query[key];
+        if (existing === undefined) {
+            query[key] = value;
+            continue;
+        }
+        if (Array.isArray(existing)) {
+            existing.push(value);
+            continue;
+        }
+        query[key] = [existing, value];
+    }
+    return query;
+}
+
+function createRequestBodyTooLargeError(receivedBytes, maxBytes) {
+    const sizeError = new Error(`request body too large: ${receivedBytes.toString()} bytes exceeds ${maxBytes.toString()} bytes`);
+    sizeError.code = 'REQUEST_BODY_TOO_LARGE';
+    return sizeError;
+}
+function getHeaderValue(headerValue) {
+    return Array.isArray(headerValue) ? headerValue[0] : headerValue;
+}
+function createEmptyPreview() {
+    return {
+        exists: false,
+        bytes: 0,
+        truncated: false,
+    };
+}
+function createPreview(previewBuffer, totalBytes, contentType, truncated) {
+    if (totalBytes === 0) {
+        return createEmptyPreview();
+    }
+    if (isTextualContentType(contentType)) {
+        return {
+            exists: true,
+            value: previewBuffer.toString('utf8'),
+            bytes: totalBytes,
+            truncated,
+        };
+    }
+    return {
+        exists: true,
+        value: `<binary body: ${totalBytes} bytes>`,
+        bytes: totalBytes,
+        truncated,
+    };
+}
+async function readRequestBodyWithPreview(req, method, maxBytes, previewMaxBytes = 8192) {
+    if (method === 'GET' || method === 'HEAD') {
+        return {
+            rawBody: undefined,
+            preview: createEmptyPreview(),
+        };
+    }
+    if (req.readableEnded) {
+        return {
+            rawBody: undefined,
+            preview: createEmptyPreview(),
+        };
+    }
+    const contentLengthRaw = getHeaderValue(req.headers['content-length']);
+    const declaredBytes = contentLengthRaw !== undefined ? Number.parseInt(contentLengthRaw, 10) : NaN;
+    if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
+        throw createRequestBodyTooLargeError(declaredBytes, maxBytes);
+    }
+    return new Promise((resolve, reject) => {
+        const rawBodyChunks = [];
+        const previewChunks = [];
+        let totalBytes = 0;
+        let previewBytes = 0;
+        let previewTruncated = false;
+        let settled = false;
+        const cleanup = () => {
+            req.off('data', onData);
+            req.off('end', onEnd);
+            req.off('error', onError);
+            req.off('aborted', onAborted);
+        };
+        const settle = (action) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            action();
+        };
+        const onData = (chunk) => {
+            const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            totalBytes += bufferChunk.byteLength;
+            if (totalBytes > maxBytes) {
+                cleanup();
+                req.resume();
+                settle(() => {
+                    reject(createRequestBodyTooLargeError(totalBytes, maxBytes));
+                });
+                return;
+            }
+            rawBodyChunks.push(bufferChunk);
+            if (previewBytes < previewMaxBytes) {
+                const remaining = previewMaxBytes - previewBytes;
+                const nextSlice = bufferChunk.subarray(0, remaining);
+                previewChunks.push(nextSlice);
+                previewBytes += nextSlice.length;
+                if (nextSlice.length < bufferChunk.length) {
+                    previewTruncated = true;
+                }
+            }
+            else {
+                previewTruncated = true;
+            }
+        };
+        const onEnd = () => {
+            cleanup();
+            settle(() => {
+                const rawBody = rawBodyChunks.length > 0 ? Buffer.concat(rawBodyChunks) : undefined;
+                const previewBuffer = previewChunks.length > 0 ? Buffer.concat(previewChunks) : Buffer.alloc(0);
+                resolve({
+                    rawBody,
+                    preview: createPreview(previewBuffer, rawBody?.byteLength ?? 0, getHeaderValue(req.headers['content-type']), previewTruncated),
+                });
+            });
+        };
+        const onError = (error) => {
+            cleanup();
+            settle(() => {
+                reject(error);
+            });
+        };
+        const onAborted = () => {
+            cleanup();
+            settle(() => {
+                reject(new Error('request aborted while reading body'));
+            });
+        };
+        req.on('data', onData);
+        req.once('end', onEnd);
+        req.once('error', onError);
+        req.once('aborted', onAborted);
+    });
+}
+async function parseBody(req, method, maxBytes) {
+    const { rawBody, preview } = await readRequestBodyWithPreview(req, method, maxBytes);
+    if (rawBody === undefined || rawBody.byteLength === 0) {
+        return {
+            body: {},
+            preview,
+        };
+    }
+    const contentType = getHeaderValue(req.headers['content-type'])?.toLowerCase() ?? '';
+    if (contentType.includes('json')) {
+        const textBody = rawBody.toString('utf8').trim();
+        if (textBody.length === 0) {
+            return {
+                body: {},
+                preview,
+            };
+        }
+        try {
+            const parsed = JSON.parse(textBody);
+            if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return {
+                    body: parsed,
+                    preview,
+                };
+            }
+            return {
+                body: { value: parsed },
+                preview,
+            };
+        }
+        catch {
+            return {
+                body: { raw: textBody },
+                preview,
+            };
+        }
+    }
+    if (contentType.includes('x-www-form-urlencoded')) {
+        return {
+            body: parseQuery(new URLSearchParams(rawBody.toString('utf8'))),
+            preview,
+        };
+    }
+    if (isTextualContentType(contentType)) {
+        return {
+            body: { raw: rawBody.toString('utf8') },
+            preview,
+        };
+    }
+    return {
+        body: {},
+        preview,
+    };
+}
+
+/**
+ * Parse Cookie header string into an object
+ */
+function parseCookie(cookieHeader) {
+    if (!cookieHeader) {
+        return {};
+    }
+    const cookies = {};
+    const pairs = cookieHeader.split(';');
+    for (const pair of pairs) {
+        const [key, ...valueParts] = pair.split('=');
+        if (!key)
+            continue;
+        const trimmedKey = key.trim();
+        const value = valueParts.join('=').trim();
+        cookies[trimmedKey] = decodeURIComponent(value);
+    }
+    return cookies;
+}
+
+function createWorkerServer(cx) {
+    const server = http.createServer(async (req, res) => {
+        const method = req.method ?? 'GET';
+        const ip = getRealIp(req);
+        const url = toURL(req.url);
+        if (url === undefined) {
+            safeSendJson(res, { message: 'Bad Request: req.url is undefined' }, 400 /* HttpCode.BadRequest */);
+            return;
+        }
+        const normalized = {
+            method,
+            ip,
+            url,
+            query: parseQuery(url.searchParams),
+            body: {},
+            headers: req.headers,
+            cookie: parseCookie(req.headers.cookie),
+        };
+        let bodyPreview = {
+            exists: false,
+            bytes: 0,
+            truncated: false,
+        };
+        cx.logger.info('Req', { method, ip, path: url.pathname });
+        const start = performance.now();
+        res.once('finish', () => {
+            const fields = {
+                workerId: process.env.WORKER_ID ?? '[primary]',
+                method,
+                ip,
+                path: url.pathname,
+                status: res.statusCode,
+                duration: (performance.now() - start).toFixed(4),
+            };
+            if ($keys(normalized.query).length > 0) {
+                fields.query = normalized.query;
+            }
+            if (bodyPreview.exists) {
+                fields.body = bodyPreview.value;
+                fields.bodyBytes = bodyPreview.bytes;
+                fields.bodyTruncated = bodyPreview.truncated;
+            }
+            cx.logger.info('Res', fields);
+        });
+        // * Start request handling
+        try {
+            if (normalized.url.pathname.startsWith(META_PREFIX + '/')) {
+                safeSendJson(res, { message: `Meta APIs are available on port ${cx.options.metaPort}` }, 404 /* HttpCode.NotFound */);
+                return;
+            }
+            const parsed = await parseBody(req, normalized.method, cx.options.maxRequestBytes);
+            normalized.body = parsed.body;
+            bodyPreview = parsed.preview;
+            const handler = await cx.router.getHandler(url);
+            if (!handler) {
+                safeSendJson(res, { message: 'Not Found' }, 404 /* HttpCode.NotFound */);
+                return;
+            }
+            const result = await PromiseTry(handler, normalized, req, res);
+            if (result !== cx.router.StaticHandled) {
+                safeSendJson(res, result);
+            }
+        }
+        catch (error) {
+            cx.logger.error('RequestFailed', {
+                method: normalized.method,
+                ip: normalized.ip,
+                path: normalized.url.pathname,
+                error: getErrorMessage(error),
+            });
+            if (error.code === 'REQUEST_BODY_TOO_LARGE') {
+                safeSendJson(res, { message: getErrorMessage(error) }, 413 /* HttpCode.PayloadTooLarge */);
+            }
+            else {
+                safeSendJson(res, { message: 'Internal Server Error' }, 500 /* HttpCode.InternalServerError */);
+            }
+        }
+    });
+    server.on('close', () => {
+        cx.logger.info('ServerClosed', {
+            host: cx.options.host,
+            port: cx.options.port,
+        });
+    });
+    server.listen(cx.options.port, cx.options.host, () => {
+        cx.logger.info('ServerStarted', {
+            pid: process.pid,
+            host: cx.options.host,
+            port: cx.options.port,
+        });
+        cx.logger.info('DynamicDirectory', { directory: cx.options.dir });
+    });
+    server.on('error', (error) => {
+        cx.logger.error('ServerError', {
+            error: getErrorMessage(error),
+        });
+    });
+    return server;
+}
+
+const inject = async (cx) => {
+    const o = {};
+    Reflect.set(globalThis, INJECTION_KEY, o);
+    for (let i = 0; i < cx.options.injections.length; i++) {
+        const injection = cx.options.injections[i];
+        const factory = loadFunction(injection);
+        const instance = await PromiseTry(factory);
+        o[injection.name] = instance;
+    }
+    cx.logger.info(`[worker ${process.pid}] injections loaded`, Object.keys(o));
+};
+const startStatsReporter = () => {
+    let previousCpuUsage = process.cpuUsage();
+    let previousAt = Date.now();
+    const interval = setInterval(() => {
+        const now = Date.now();
+        const elapsedMicros = Math.max(1, (now - previousAt) * 1000);
+        const cpuDelta = process.cpuUsage(previousCpuUsage);
+        const cpuPercent = Number((((cpuDelta.user + cpuDelta.system) / elapsedMicros) * 100).toFixed(2));
+        previousCpuUsage = process.cpuUsage();
+        previousAt = now;
+        const memoryUsage = process.memoryUsage();
+        sendToPrimary({
+            type: 203 /* WorkerAction.Stats */,
+            pid: process.pid,
+            stats: {
+                at: now,
+                pid: process.pid,
+                uptimeSeconds: Number(process.uptime().toFixed(3)),
+                cpu: {
+                    userMicros: cpuDelta.user,
+                    systemMicros: cpuDelta.system,
+                    percent: cpuPercent,
+                },
+                memory: {
+                    rss: memoryUsage.rss,
+                    heapTotal: memoryUsage.heapTotal,
+                    heapUsed: memoryUsage.heapUsed,
+                    external: memoryUsage.external,
+                    arrayBuffers: memoryUsage.arrayBuffers,
+                },
+            },
+        });
+    }, 2000);
+    interval.unref();
+};
+function initWorker(cx) {
+    if (cluster.isPrimary) {
+        throw new Error('[FluxionTs error] createWorker should only be called in worker process');
+    }
+    process.on('message', (raw) => {
+        if (!isPrimaryMessage(raw)) {
+            return;
+        }
+        if (raw.type === 100 /* PrimaryAction.Ping */) {
+            sendToPrimary({ type: 202 /* WorkerAction.Pong */, pid: process.pid, sentAt: raw.sentAt, receivedAt: Date.now() });
+            return;
+        }
+    });
+    sendToPrimary({ type: 200 /* WorkerAction.Created */, pid: process.pid });
+    startStatsReporter();
+    PromiseTry(async () => {
+        await inject(cx);
+        createWorkerServer(cx);
+        sendToPrimary({ type: 201 /* WorkerAction.Ready */, pid: process.pid });
+    }).catch((error) => {
+        cx.logger.error('WorkerBootstrapFailed', {
+            pid: process.pid,
+            error: getErrorMessage(error),
+        });
+        process.exit(1);
+    });
+}
+
+class FluxionWatcher {
+    constructor(cx) {
+        this.timer = null;
+        this.watcher = null;
+        this.filesChanged = new Set();
+        this.cx = cx;
+    }
+    /**
+     * Recursively register all files in the options directory.
+     */
+    init() {
+        const dirPath = path.join(process.cwd(), this.cx.options.dir);
+        const registerRecursive = (dir, relativePath) => {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryPath = path.join(dir, entry.name);
+                const entryRelativePath = path.join(relativePath, entry.name);
+                if (entry.isDirectory()) {
+                    registerRecursive(entryPath, entryRelativePath);
+                }
+                else if (entry.isFile()) {
+                    try {
+                        this.cx.router.register(entryRelativePath);
+                    }
+                    catch (err) {
+                        this.cx.logger.error(`Error registering [${entryRelativePath}]: ${err.message}`);
+                    }
+                }
+            }
+        };
+        if (fs.existsSync(dirPath)) {
+            registerRecursive(dirPath, '');
+            this.cx.logger.info(`Initial registration complete for directory: ${this.cx.options.dir}`);
+        }
+        else {
+            this.cx.logger.warn(`Directory does not exist: ${this.cx.options.dir}`);
+        }
+        return this;
+    }
+    /**
+     * Since all actions are mapped to `rename` and `change` (WatchEventType).
+     *
+     * We could only record every file and reload them all.
+     */
+    start() {
+        this.init();
+        this.watcher = fs
+            .watch(this.cx.options.dir, { recursive: true }, (_eventType, filename) => {
+            if (!filename) {
+                return;
+            }
+            this.filesChanged.add(filename);
+            if (!this.timer) {
+                this.timer = setTimeout(() => {
+                    this.filesChanged.forEach((p, _, s) => {
+                        try {
+                            this.cx.router.register(p);
+                        }
+                        catch (err) {
+                            this.cx.logger.error(`Error refreshing handlers: ${err.message}`);
+                        }
+                        finally {
+                            s.delete(p);
+                        }
+                    });
+                    this.timer = null;
+                }, this.cx.options.reloadDelay);
+            }
+        })
+            .on('error', (err) => {
+            this.cx.logger.error(`Watcher error: ${err.message}`);
+            this.cx.logger.error(`Restarting watcher...`);
+            this.stop().start();
+        });
+        this.cx.logger.info(`Watcher started on directory: ${this.cx.options.dir}`);
+        return this;
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.filesChanged.clear();
+        return this;
+    }
+}
+
+class FluxionRouter {
+    constructor(cx) {
+        /**
+         * This means the request has been handled by static resource handler, and no more response should be sent.
+         */
+        this.StaticHandled = Symbol.for('fluxion.router.StaticHandled');
+        this.handlers = new Map();
+        this.cx = cx;
+    }
+    makeStaticResource(filepath) {
+        const fullPath = path.join(this.cx.options.dir, filepath);
+        return async (normalized, _req, res) => {
+            if (normalized.method !== 'GET' && normalized.method !== 'HEAD') {
+                res.statusCode = 405;
+                res.setHeader('Allow', 'GET, HEAD');
+                res.end();
+                return;
+            }
+            if (!fs.existsSync(fullPath)) {
+                res.statusCode = 404;
+                res.end('Not Found');
+                return;
+            }
+            const stat = fs.statSync(fullPath);
+            if (!stat.isFile()) {
+                res.statusCode = 404;
+                res.end('Not Found');
+                return;
+            }
+            const extension = path.extname(filepath).toLowerCase();
+            const contentType = STATIC_CONTENT_TYPES[extension] ?? 'application/octet-stream';
+            res.statusCode = 200;
+            res.setHeader('Content-Type', contentType);
+            res.setHeader('Content-Length', String(stat.size));
+            if (normalized.method === 'HEAD') {
+                res.end();
+                return;
+            }
+            return new Promise((resolve, reject) => {
+                const stream = fs.createReadStream(fullPath);
+                stream.on('error', reject);
+                stream.on('end', () => resolve(this.StaticHandled));
+                stream.pipe(res);
+            });
+        };
+    }
+    /**
+     * 1. Check if the path exists, if not, delete the handler;
+     * 2. If the file extension matches `routerExclude`, delete it and return early;
+     * 3. If the file extension matches `apiExts`, register it as an API, otherwise register as static resource;
+     * @param filepath
+     */
+    register(filepath) {
+        const fullpath = path.join(process.cwd(), this.cx.options.dir, filepath);
+        if (!fs.existsSync(fullpath)) {
+            this.handlers.delete(filepath);
+            this.cx.logger.info(`[${filepath}] deleted`);
+            return;
+        }
+        delete require.cache[fullpath];
+        const extension = path.extname(filepath).toLowerCase();
+        // Check if this file should be excluded from registration
+        if (this.cx.options.routerExclude.some((ext) => extension === ext)) {
+            this.handlers.delete(filepath);
+            this.cx.logger.info(`[${filepath}] excluded`);
+            return;
+        }
+        // register as api
+        // ! Files with extensions matching `apiExts` are considered as API handlers.
+        if (this.cx.options.apiExts.some((ext) => extension === ext)) {
+            const handler = loadFunction({ modulePath: fullpath });
+            this.handlers.set(filepath, handler);
+            this.cx.logger.info(`[${filepath}] handler registered`);
+            return;
+        }
+        // register as static resource
+        this.handlers.set(filepath, this.makeStaticResource(filepath));
+        this.cx.logger.info(`[${filepath}] static resource registered`);
+    }
+    getHandler(url) {
+        const relativePath = url.pathname.replace(/^[\/]+/, '').replace(/[\/]+$/, '');
+        return this.handlers.get(relativePath);
+    }
+}
+
+async function fluxion(options) {
+    const context = {
+        options: normalizeOptions(options),
+    };
+    context.logger = createLogger(context);
+    context.router = new FluxionRouter(context);
+    if (cluster.isPrimary) {
+        initPrimary(context);
+    }
+    else {
+        // Only worker creates the watcher
+        context.watcher = new FluxionWatcher(context).start();
+        initWorker(context);
+    }
+}
+
+function defineFluxionHandler(handler) {
+    return handler;
+}
+
+export { defineFluxionHandler, fluxion };
+//# sourceMappingURL=index.mjs.map