web_plsql 1.0.0 → 1.3.0

package/dist/index.mjs

@@ -0,0 +1,3548 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { n as setExecuteCallback } from "./oracledb-mock-Dn8aHtd7.mjs";
+import z$1, { z } from "zod";
+import oracledb from "oracledb";
+import debugModule from "debug";
+import http from "node:http";
+import https from "node:https";
+import express, { Router } from "express";
+import cors from "cors";
+import cookieParser from "cookie-parser";
+import compression from "compression";
+import expressStaticGzip from "express-static-gzip";
+import os from "node:os";
+import url, { URL, fileURLToPath } from "node:url";
+import util from "node:util";
+import stream, { Readable } from "node:stream";
+import fs, { existsSync, promises, readFileSync } from "node:fs";
+import * as rotatingFileStream from "rotating-file-stream";
+import path from "node:path";
+import morgan from "morgan";
+import multer from "multer";
+import readline from "node:readline";
+
+//#region src/common/configStaticSchema.ts
+/**
+* Configuration for serving static files
+*/
+const configStaticSchema = z$1.strictObject({
+	route: z$1.string(),
+	directoryPath: z$1.string(),
+	spaFallback: z$1.boolean().optional()
+});
+
+//#endregion
+//#region src/common/procedureTraceEntry.ts
+const procedureTraceEntrySchema = z.strictObject({
+	id: z.string(),
+	timestamp: z.string(),
+	source: z.string(),
+	url: z.string(),
+	method: z.string(),
+	status: z.string(),
+	duration: z.number(),
+	procedure: z.string().optional(),
+	parameters: z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())]).optional(),
+	uploads: z.array(z.strictObject({
+		originalname: z.string(),
+		mimetype: z.string(),
+		size: z.number()
+	})).optional(),
+	downloads: z.strictObject({
+		fileType: z.string(),
+		fileSize: z.number()
+	}).optional(),
+	html: z.string().optional(),
+	cookies: z.record(z.string(), z.string()).optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	cgi: z.record(z.string(), z.string()).optional(),
+	error: z.string().optional()
+});
+
+//#endregion
+//#region src/common/logEntrySchema.ts
+/**
+* Error log entry schema.
+*/
+const logEntryTypeSchema = z.union([
+	z.literal("error"),
+	z.literal("info"),
+	z.literal("warning")
+]);
+const logEntrySchema = z.strictObject({
+	timestamp: z.string(),
+	type: logEntryTypeSchema,
+	message: z.string(),
+	req: z.strictObject({
+		method: z.string().optional(),
+		url: z.string().optional(),
+		ip: z.string().optional(),
+		userAgent: z.string().optional()
+	}).optional(),
+	details: z.strictObject({
+		fullMessage: z.string().optional(),
+		sql: z.string().optional(),
+		bind: z.unknown().optional(),
+		environment: z.record(z.string(), z.string()).optional()
+	}).optional()
+});
+
+//#endregion
+//#region src/backend/types.ts
+/**
+* Defines the style of error reporting
+* 'basic': standard error messages
+* 'debug': detailed error messages including database context
+*/
+const z$errorStyleType = z$1.enum(["basic", "debug"]);
+/**
+* Defines how transactions are handled after procedure execution
+* 'commit': automatically commit
+* 'rollback': automatically rollback
+* callback: custom function for manual handling
+*/
+const transactionModeSchema = z$1.union([
+	z$1.custom((val) => typeof val === "function", { message: "Invalid transaction callback" }),
+	z$1.literal("commit"),
+	z$1.literal("rollback"),
+	z$1.undefined(),
+	z$1.null()
+]);
+/**
+* Authentication configuration for a PL/SQL route
+*/
+const z$authSchema = z$1.strictObject({
+	type: z$1.literal("basic"),
+	callback: z$1.custom((val) => typeof val === "function", { message: "Invalid auth callback" }),
+	realm: z$1.string().optional()
+});
+/**
+* PL/SQL handler behavior configuration
+*/
+const z$configPlSqlHandlerType = z$1.strictObject({
+	defaultPage: z$1.string(),
+	pathAlias: z$1.string().optional(),
+	pathAliasProcedure: z$1.string().optional(),
+	documentTable: z$1.string(),
+	exclusionList: z$1.array(z$1.string()).optional(),
+	requestValidationFunction: z$1.string().optional(),
+	transactionMode: transactionModeSchema.optional(),
+	errorStyle: z$errorStyleType,
+	cgi: z$1.record(z$1.string(), z$1.string()).optional(),
+	auth: z$authSchema.optional()
+});
+/**
+* Database connection configuration for a PL/SQL route
+*/
+const z$configPlSqlConfigType = z$1.strictObject({
+	route: z$1.string(),
+	user: z$1.string(),
+	password: z$1.string(),
+	connectString: z$1.string()
+});
+const z$configPlSqlType = z$1.strictObject({
+	...z$configPlSqlHandlerType.shape,
+	...z$configPlSqlConfigType.shape
+});
+/**
+* Root application configuration
+*/
+const z$configType = z$1.strictObject({
+	port: z$1.number(),
+	routeStatic: z$1.array(configStaticSchema),
+	routePlSql: z$1.array(z$configPlSqlType),
+	uploadFileSizeLimit: z$1.number().optional(),
+	loggerFilename: z$1.string(),
+	adminRoute: z$1.string().optional(),
+	adminUser: z$1.string().optional(),
+	adminPassword: z$1.string().optional(),
+	devMode: z$1.boolean().optional()
+});
+
+//#endregion
+//#region src/backend/util/oracledb-provider.ts
+var oracledb_provider_exports = /* @__PURE__ */ __exportAll({
+	BIND_IN: () => BIND_IN,
+	BIND_INOUT: () => BIND_INOUT,
+	BIND_OUT: () => BIND_OUT,
+	BLOB: () => BLOB,
+	BUFFER: () => BUFFER,
+	CLOB: () => CLOB,
+	CURSOR: () => CURSOR,
+	DATE: () => DATE,
+	DB_TYPE_CLOB: () => DB_TYPE_CLOB,
+	DB_TYPE_DATE: () => DB_TYPE_DATE,
+	DB_TYPE_NUMBER: () => DB_TYPE_NUMBER,
+	DB_TYPE_VARCHAR: () => DB_TYPE_VARCHAR,
+	NUMBER: () => NUMBER,
+	STRING: () => STRING,
+	createPool: () => createPool,
+	setExecuteCallback: () => setExecuteCallback
+});
+const USE_MOCK = process.env.MOCK_ORACLE === "true";
+/**
+* Create a database pool.
+* @param config - The pool attributes.
+* @returns The pool.
+*/
+async function createPool(config) {
+	if (USE_MOCK) return (await import("./oracledb-mock-Dn8aHtd7.mjs").then((n) => n.t)).createPool(config);
+	return await oracledb.createPool(config);
+}
+const BIND_IN = oracledb.BIND_IN;
+const BIND_OUT = oracledb.BIND_OUT;
+const BIND_INOUT = oracledb.BIND_INOUT;
+const STRING = oracledb.STRING;
+const NUMBER = oracledb.NUMBER;
+const DATE = oracledb.DATE;
+const CURSOR = oracledb.CURSOR;
+const BUFFER = oracledb.BUFFER;
+const CLOB = oracledb.CLOB;
+const BLOB = oracledb.BLOB;
+const DB_TYPE_VARCHAR = oracledb.DB_TYPE_VARCHAR;
+const DB_TYPE_CLOB = oracledb.DB_TYPE_CLOB;
+const DB_TYPE_NUMBER = oracledb.DB_TYPE_NUMBER;
+const DB_TYPE_DATE = oracledb.DB_TYPE_DATE;
+
+//#endregion
+//#region src/backend/version.ts
+if (typeof globalThis.__VERSION__ === "undefined") globalThis.__VERSION__ = "**development**";
+/**
+* Returns the current library version
+* @returns {string} - Version.
+*/
+const getVersion = () => "1.3.0";
+
+//#endregion
+//#region src/backend/server/config.ts
+const paddedLine = (title, value) => {
+	console.log(`${(title + ":").padEnd(30)} ${value}`);
+};
+/**
+* Show configuration.
+* @param config - The config.
+*/
+const showConfig = (config) => {
+	const LINE = "-".repeat(80);
+	console.log(LINE);
+	console.log(`NODE PL/SQL SERVER version ${getVersion()}`);
+	console.log(LINE);
+	paddedLine("Server port", config.port);
+	paddedLine("Admin route", `${config.adminRoute ?? "/admin"}${config.adminUser ? " (authenticated)" : ""}`);
+	paddedLine("Access log", config.loggerFilename.length > 0 ? config.loggerFilename : "-");
+	paddedLine("Upload file size limit", typeof config.uploadFileSizeLimit === "number" ? `${config.uploadFileSizeLimit} bytes` : "-");
+	if (config.routeStatic.length > 0) config.routeStatic.forEach((e) => {
+		paddedLine("Static route", e.route);
+		paddedLine("Directory path", e.directoryPath);
+	});
+	if (config.routePlSql.length > 0) config.routePlSql.forEach((e) => {
+		let transactionMode = "";
+		if (typeof e.transactionMode === "string") transactionMode = e.transactionMode;
+		else if (typeof e.transactionMode === "function") transactionMode = "custom callback";
+		paddedLine("Route", `http://localhost:${config.port}${e.route}`);
+		paddedLine("Oracle user", e.user);
+		paddedLine("Oracle server", e.connectString);
+		paddedLine("Oracle document table", e.documentTable);
+		paddedLine("Default page", e.defaultPage.length > 0 ? e.defaultPage : "-");
+		paddedLine("Path alias", e.pathAlias ?? "-");
+		paddedLine("Path alias procedure", e.pathAliasProcedure ?? "-");
+		paddedLine("Exclution list", e.exclusionList ? e.exclusionList.join(", ") : "-");
+		paddedLine("Validation function", e.requestValidationFunction ?? "-");
+		paddedLine("After request handler", transactionMode.length > 0 ? transactionMode : "-");
+		paddedLine("Error style", e.errorStyle);
+	});
+	console.log(LINE);
+	const baseUrl = `http://localhost:${config.port}`;
+	paddedLine("🏠 Admin Console", `${baseUrl}${config.adminRoute ?? "/admin"}`);
+	if (config.routePlSql.length > 0) {
+		console.log("");
+		console.log("⚙️  PL/SQL Gateways:");
+		config.routePlSql.forEach((e) => {
+			console.log(`  ${e.route.padEnd(28)} ${baseUrl}${e.route}`);
+		});
+	}
+	console.log(LINE);
+};
+
+//#endregion
+//#region src/backend/server/server.ts
+const debug$14 = debugModule("webplsql:server");
+/**
+* Close multiple pools.
+* @param pools - The pools to close.
+*/
+const poolsClose = async (pools) => {
+	await Promise.all(pools.map((pool) => pool.close(0)));
+};
+/**
+* Create HTTPS server.
+* @param app - express application
+* @param ssl - ssl configuration.
+* @returns server
+*/
+const createServer = (app, ssl) => {
+	if (ssl) {
+		const key = readFileSyncUtf8(ssl.keyFilename);
+		const cert = readFileSyncUtf8(ssl.certFilename);
+		return https.createServer({
+			key,
+			cert
+		}, app);
+	} else return http.createServer(app);
+};
+/**
+* Start server.
+* @param config - The config.
+* @param ssl - ssl configuration.
+* @returns Promise resolving to the web server object.
+*/
+const startServer = async (config, ssl) => {
+	debug$14("startServer: BEGIN", config, ssl);
+	const internalConfig = z$configType.parse(config);
+	showConfig(internalConfig);
+	const app = express();
+	if (internalConfig.devMode) app.use(cors({
+		origin: "http://localhost:5173",
+		credentials: true
+	}));
+	app.use(handlerUpload(internalConfig.uploadFileSizeLimit));
+	app.use(express.json({ limit: "50mb" }));
+	app.use(express.urlencoded({
+		limit: "50mb",
+		extended: true
+	}));
+	app.use(cookieParser());
+	app.use(compression());
+	const adminContext = new AdminContext(internalConfig);
+	app.use(handlerAdminConsole({
+		adminRoute: internalConfig.adminRoute,
+		user: internalConfig.adminUser,
+		password: internalConfig.adminPassword,
+		devMode: internalConfig.devMode
+	}, adminContext));
+	for (const i of internalConfig.routePlSql) {
+		const handler = handlerWebPlSql(await createPool({
+			user: i.user,
+			password: i.password,
+			connectString: i.connectString
+		}), i, adminContext);
+		app.use([`${i.route}/:name`, i.route], (req, res, next) => {
+			const start = process.hrtime();
+			res.on("finish", () => {
+				const diff = process.hrtime(start);
+				const duration = diff[0] * 1e3 + diff[1] / 1e6;
+				adminContext.statsManager.recordRequest(duration, res.statusCode >= 400);
+			});
+			handler(req, res, next);
+		});
+	}
+	if (internalConfig.loggerFilename.length > 0) app.use(handlerLogger(internalConfig.loggerFilename));
+	for (const i of internalConfig.routeStatic) {
+		app.use(i.route, expressStaticGzip(i.directoryPath, {
+			enableBrotli: true,
+			orderPreference: ["br"]
+		}));
+		if (i.spaFallback) app.use(i.route, createSpaFallback(i.directoryPath, i.route));
+	}
+	debug$14("startServer: createServer");
+	const server = createServer(app, ssl);
+	const connections = /* @__PURE__ */ new Set();
+	server.on("connection", (socket) => {
+		connections.add(socket);
+		socket.on("close", () => {
+			connections.delete(socket);
+		});
+	});
+	const closeAllConnections = () => {
+		for (const socket of connections) {
+			socket.destroy();
+			connections.delete(socket);
+		}
+	};
+	const shutdown = async () => {
+		debug$14("startServer: onShutdown");
+		adminContext.statsManager.stop();
+		await poolsClose(adminContext.pools);
+		server.close(() => {
+			console.log("Server has closed");
+			process.exit(0);
+		});
+		closeAllConnections();
+	};
+	installShutdown(shutdown);
+	debug$14("startServer: start listener");
+	await new Promise((resolve, reject) => {
+		server.listen(internalConfig.port).on("listening", () => {
+			debug$14("startServer: listener running");
+			resolve();
+		}).on("error", (err) => {
+			if ("code" in err) {
+				if (err.code === "EADDRINUSE") err.message = `Port ${internalConfig.port} is already in use`;
+				else if (err.code === "EACCES") err.message = `Port ${internalConfig.port} requires elevated privileges`;
+			}
+			reject(err);
+		});
+	});
+	debug$14("startServer: END");
+	return {
+		config: internalConfig,
+		connectionPools: adminContext.pools,
+		app,
+		server,
+		adminContext,
+		shutdown
+	};
+};
+/**
+* Load configuration.
+* @param filename - The configuration filename.
+* @returns Promise.
+*/
+const loadConfig = (filename = "config.json") => z$configType.parse(getJsonFile(filename));
+/**
+* Start server from config file.
+* @param filename - The configuration filename.
+* @param ssl - ssl configuration.
+* @returns Promise resolving to the web server object.
+*/
+const startServerConfig = async (filename = "config.json", ssl) => startServer(loadConfig(filename), ssl);
+
+//#endregion
+//#region src/backend/util/shutdown.ts
+const debug$13 = debugModule("webplsql:shutdown");
+/**
+* Install a shutdown handler.
+* @param handler - Shutdown handler
+*/
+const installShutdown = (handler) => {
+	debug$13("installShutdown");
+	let isShuttingDown = false;
+	process.on("unhandledRejection", (reason) => {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+		if (reason instanceof Error) console.error(`\n${reason.message}. Graceful shutdown...`);
+		else console.error("\nUnhandled promise rejection. Graceful shutdown...", reason);
+		handler().catch((err) => {
+			console.error("Error during shutdown:", err);
+			process.exit(1);
+		});
+	});
+	process.on("SIGTERM", function sigterm() {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+		console.log("\nGot SIGTERM (aka docker container stop). Graceful shutdown...");
+		handler().catch((err) => {
+			console.error("Error during shutdown:", err);
+			process.exit(1);
+		});
+	});
+	process.on("SIGINT", function sigint() {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+		console.log("\nGot SIGINT (aka ctrl-c in docker). Graceful shutdown...");
+		handler().catch((err) => {
+			console.error("Error during shutdown:", err);
+			process.exit(1);
+		});
+	});
+};
+/**
+* Force a shutdown.
+*/
+const forceShutdown = () => {
+	debug$13("forceShutdown");
+	process.kill(process.pid, "SIGTERM");
+};
+
+//#endregion
+//#region src/common/constants.ts
+/**
+* Web PL/SQL Gateway - Common Shared Constants
+*
+* This file centralizes all hardcoded numeric and string constants used throughout
+* the application. Constants are organized by functional category.
+*/
+/**
+* DEFAULT_CACHE_MAX_SIZE = 10000
+*
+* Purpose: Maximum number of entries in the generic LFU (Least Frequently Used) cache.
+*
+* Used By:
+*   - procedureNameCache: Caches resolved Oracle procedure names (e.g., "HR.EMPLOYEES")
+*   - argumentCache: Caches procedure argument introspection results from all_arguments view
+*
+* Related Values:
+*   - CACHE_PRUNE_PERCENT (0.1): When cache is full, removes 10% = 1000 entries
+*   - Cache instantiation in src/handler/plsql/handlerPlSql.js creates new Cache() without params
+*
+* Implications:
+*   - Memory footprint: ~1-2MB at max capacity (strings + hitCount metadata)
+*   - Pruning: Removes least-frequently-used entries when full
+*   - Higher values = better cache hit rates but more memory
+*/
+const DEFAULT_CACHE_MAX_SIZE = 1e4;
+/**
+* CACHE_PRUNE_PERCENT = 0.1
+*
+* Purpose: Fraction of cache entries to remove during pruning (10%).
+*
+* Used By: Cache.prune() method only
+*
+* Related Values:
+*   - DEFAULT_CACHE_MAX_SIZE (10000): Applied to this value to calculate removeCount = 1000
+*
+* Implications:
+*   - Balances between removing too few entries (frequent pruning) vs too many (evicting useful data)
+*   - 10% is a common pattern for cache eviction
+*/
+const CACHE_PRUNE_PERCENT = .1;
+/**
+* MAX_PROCEDURE_PARAMETERS = 1000
+*
+* Purpose: Maximum number of procedure arguments that can be introspected from Oracle's
+*          all_arguments view using BULK COLLECT with dbms_utility.name_resolve.
+*
+* Used By:
+*   - src/handler/plsql/procedureNamed.js
+*     bind.names = {maxArraySize: MAX_PARAMETER_NUMBER}
+*     bind.types = {maxArraySize: MAX_PARAMETER_NUMBER}
+*
+* Related Values:
+*   - Procedure introspection SQL: SQL_GET_ARGUMENT block at procedureNamed.js:27-43
+*   - oracledb.BIND_OUT direction for array fetches
+*
+* Implications:
+*   - This is an Oracle driver limitation for array binding, not an arbitrary choice
+*   - Procedures with >1000 arguments will have introspection truncated
+*   - No error handling exists for this edge case
+*   - Practical limit: most procedures have <50 arguments
+*/
+const MAX_PROCEDURE_PARAMETERS = 1e3;
+/**
+* OWA_STREAM_CHUNK_SIZE = 1000
+*
+* Purpose: Number of lines fetched per Oracle OWA call when streaming page content.
+*
+* Used By:
+*   - owaPageStream.js: maxArraySize for :lines bind variable
+*   - owaPageStream.js: :irows INOUT parameter value
+*   - owaPageStream.js: Determines when streaming is complete (lines.length < chunkSize)
+*
+* Related Values:
+*   - OWA_GET_PAGE_SQL: 'BEGIN owa.get_page(thepage=>:lines, irows=>:irows); END;'
+*   - OWAPageStream class constructor at line 20
+*
+* Implications:
+*   - Controls round-trip frequency to Oracle database
+*   - Higher = fewer round-trips but larger memory buffers per fetch
+*   - Lower = more responsive streaming but more database calls
+*   - Each line is a PL/SQL varchar2; total data per chunk depends on htp.htbuf_len (63 chars)
+*   - Estimated max data per chunk: 1000 lines × 63 chars = 63KB
+*/
+const OWA_STREAM_CHUNK_SIZE = 1e3;
+/**
+* OWA_STREAM_BUFFER_SIZE = 16384
+*
+* Purpose: Node.js Readable stream highWaterMark in bytes (16KB).
+*
+* Used By: OWAPageStream class extends Readable stream
+*
+* Related Values:
+*   - OWA_STREAM_CHUNK_SIZE (1000): Lines per fetch
+*   - Default Node.js highWaterMark is 64KB (Readable stream default)
+*   - OWAPageStream.push() converts lines to string buffer
+*
+* Implications:
+*   - Smaller than default (64KB) = more frequent _read() callbacks
+*   - Reduces memory footprint for large responses
+*   - Improves backpressure handling responsiveness
+*   - Trade-off: More CPU for _read() calls vs memory efficiency
+*/
+const OWA_STREAM_BUFFER_SIZE = 16384;
+/**
+* OWA_RESOLVED_NAME_MAX_LEN = 400
+*
+* Purpose: Maximum string length for resolved Oracle procedure canonical names.
+*          Canonical format: SCHEMA.PACKAGE.PROCEDURE or SCHEMA.PROCEDURE.
+*
+* Used By:
+*   - resolveProcedureName() function for dbms_utility.name_resolve output
+*   - Procedure name resolution SQL at procedureSanitize.js:46-76
+*
+* Related Values:
+*   - dbms_utility.name_resolve context = 1 (procedure/function resolution)
+*   - Oracle identifier limits: Schema (128) + Package (128) + Procedure (128) + 2 dots = ~386
+*   - 400 provides comfortable headroom
+*
+* Implications:
+*   - Oracle object names: 30 bytes for most, extended to 128 in some contexts
+*   - Canonical name: schema.package.procedure (max ~128+1+128+1+128 = 386)
+*   - 400 is safe upper bound with margin
+*/
+const OWA_RESOLVED_NAME_MAX_LEN = 400;
+/**
+* STATS_INTERVAL_MS = 5000
+*
+* Purpose: Duration of each statistical bucket in milliseconds.
+*
+* Used By:
+*   - src/util/statsManager.js:165: setInterval(this.rotateBucket, this.config.intervalMs)
+*   - src/handler/handlerAdmin.js:123: Exposed as intervalMs in /api/status response
+*   - src/frontend/main.ts
+*   - src/frontend/charts.ts
+*
+* Related Values:
+*   - MAX_HISTORY_BUCKETS (1000): At 5s per bucket = ~83 minutes of history
+*   - MAX_PERCENTILE_SAMPLES (1000): Samples per bucket for P95/P99
+*
+* Implications:
+*   - Bucket aggregation: request counts, durations, errors, system metrics
+*   - Affects granularity of performance monitoring
+*   - Lower values = more granular but more history entries
+*   - Higher values = smoother averages but less detail
+*/
+const STATS_INTERVAL_MS = 5e3;
+/**
+* MAX_HISTORY_BUCKETS = 1000
+*
+* Purpose: Maximum number of statistical buckets retained in StatsManager ring buffer.
+*
+* Used By:
+*   - src/util/statsManager.js: Ring buffer limit check
+*     if (this.history.length > this.config.maxHistoryPoints) { this.history.shift(); }
+*   - Exposed via /api/stats/history endpoint
+*
+* Related Values:
+*   - STATS_INTERVAL_MS (5000): 5s per bucket = ~83 minutes total history
+*   - Each bucket contains: timestamp, requestCount, errors, durations, system metrics
+*   - Bucket memory estimate: ~100 bytes × 1000 = ~100KB
+*
+* Implications:
+*   - Ring buffer: oldest bucket is removed when new one exceeds limit
+*   - Affects admin console chart history display
+*   - Higher = more historical context but more memory
+*/
+const MAX_HISTORY_BUCKETS = 1e3;
+/**
+* MAX_PERCENTILE_SAMPLES = 1000
+*
+* Purpose: Maximum number of request duration samples collected per bucket
+*          for calculating P95/P99 percentiles.
+*
+* Used By:
+*   - src/util/statsManager.js: Array length check
+*     if (b.durations.length < this.config.percentilePrecision)
+*   - src/util/statsManager.js: P95/P99 calculation
+*
+* Related Values:
+*   - Percentile calculation: floor(length × 0.95) and floor(length × 0.99)
+*   - FIFO replacement: When exceeded, new samples replace oldest
+*
+* Implications:
+*   - With 1000 samples, P95/P99 are statistically meaningful
+*   - Higher = more accurate percentiles but more memory per bucket
+*   - With STATS_INTERVAL_MS = 5000, 1000 samples ≈ 5 req/sec sustained
+*   - Under heavy load, older samples are discarded (FIFO)
+*/
+const MAX_PERCENTILE_SAMPLES = 1e3;
+/**
+* SHUTDOWN_GRACE_DELAY_MS = 100
+*
+* Purpose: Delay between initiating server shutdown and forced termination.
+*
+* Used By: POST /api/server/stop handler only
+*
+* Related Values:
+*   - forceShutdown() at src/util/shutdown.js
+*   - SIGTERM/SIGINT handlers at shutdown.js
+*
+* Implications:
+*   - Allows graceful completion of in-flight requests
+*   - Gives Express middleware time to send final responses
+*   - 100ms is short; may be insufficient under heavy load
+*   - Consider making configurable for high-traffic deployments
+*/
+const SHUTDOWN_GRACE_DELAY_MS = 100;
+/**
+* TRACE_LOG_ROTATION_SIZE = '10M'
+*
+* Purpose: Log file size threshold triggering trace log rotation (10 Megabytes).
+*
+* Used By: rotating-file-stream library for 'trace.log'
+*
+* Related Values:
+*   - TRACE_LOG_ROTATION_INTERVAL ('1d'): Also triggers rotation
+*   - TRACE_LOG_MAX_ROTATED_FILES (10): Maximum retained files
+*
+* Implications:
+*   - When either size OR time threshold is reached, rotation occurs
+*   - Combined with daily rotation: ~10MB/day minimum
+*   - gzip compression reduces rotated file size by ~70-90%
+*/
+const TRACE_LOG_ROTATION_SIZE = "10M";
+/**
+* TRACE_LOG_ROTATION_INTERVAL = '1d'
+*
+* Purpose: Time-based trace log rotation trigger (daily).
+*
+* Used By: rotating-file-stream library for 'trace.log'
+*
+* Implications:
+*   - Guarantees at least one rotation per day
+*   - Midnight-based or 24h from first write
+*/
+const TRACE_LOG_ROTATION_INTERVAL = "1d";
+/**
+* TRACE_LOG_MAX_ROTATED_FILES = 10
+*
+* Purpose: Maximum number of rotated trace log files to retain.
+*
+* Used By: rotating-file-stream library for 'trace.log'
+*
+* Implications:
+*   - When exceeded, oldest rotated file is deleted
+*   - Maximum: ~10 files × 10MB = ~100MB (compressed: ~10-30MB)
+*/
+const TRACE_LOG_MAX_ROTATED_FILES = 10;
+/**
+* JSON_LOG_ROTATION_SIZE = '10M'
+*
+* Purpose: Log file size threshold triggering JSON error log rotation (10 Megabytes).
+*
+* Used By: rotating-file-stream library for 'error.json.log'
+*
+* Related Values:
+*   - JSON_LOG_ROTATION_INTERVAL ('1d'): Also triggers rotation
+*   - JSON_LOG_MAX_ROTATED_FILES (10): Maximum retained files
+*
+* Implications:
+*   - When either size OR time threshold is reached, rotation occurs
+*   - Combined with daily rotation: ~10MB/day minimum
+*   - gzip compression reduces rotated file size by ~70-90%
+*/
+const JSON_LOG_ROTATION_SIZE = "10M";
+/**
+* JSON_LOG_ROTATION_INTERVAL = '1d'
+*
+* Purpose: Time-based JSON error log rotation trigger (daily).
+*
+* Used By: rotating-file-stream library for 'error.json.log'
+*
+* Implications:
+*   - Guarantees at least one rotation per day
+*   - Midnight-based or 24h from first write
+*/
+const JSON_LOG_ROTATION_INTERVAL = "1d";
+/**
+* JSON_LOG_MAX_ROTATED_FILES = 10
+*
+* Purpose: Maximum number of rotated JSON error log files to retain.
+*
+* Used By: rotating-file-stream library for 'error.json.log'
+*
+* Implications:
+*   - When exceeded, oldest rotated file is deleted
+*   - Maximum: ~10 files × 10MB = ~100MB (compressed: ~10-30MB)
+*/
+const JSON_LOG_MAX_ROTATED_FILES = 10;
+
+//#endregion
+//#region src/backend/util/statsManager.ts
+const debug$12 = debugModule("webplsql:statsManager");
+/**
+* Manager for statistical data collection and temporal bucketing.
+*/
+var StatsManager = class {
+	config;
+	startTime;
+	history;
+	lifetime;
+	_currentBucket;
+	_lastCpuTimes;
+	_timer;
+	/**
+	* @param config - Configuration.
+	*/
+	constructor(config = {}) {
+		this.config = {
+			intervalMs: STATS_INTERVAL_MS,
+			maxHistoryPoints: MAX_HISTORY_BUCKETS,
+			sampleSystem: true,
+			samplePools: true,
+			percentilePrecision: MAX_PERCENTILE_SAMPLES,
+			...config
+		};
+		this.startTime = /* @__PURE__ */ new Date();
+		this.history = [];
+		this.lifetime = {
+			totalRequests: 0,
+			totalErrors: 0,
+			minDuration: -1,
+			maxDuration: -1,
+			totalDuration: 0,
+			maxRequestsPerSecond: 0,
+			memory: {
+				heapUsedMax: 0,
+				heapTotalMax: 0,
+				rssMax: 0,
+				externalMax: 0
+			},
+			cpu: {
+				max: 0,
+				userMax: 0,
+				systemMax: 0
+			}
+		};
+		this._currentBucket = {
+			count: 0,
+			errors: 0,
+			durations: [],
+			durationSum: 0,
+			durationMin: -1,
+			durationMax: -1
+		};
+		this._lastCpuTimes = this._getSystemCpuTimes();
+		this._timer = void 0;
+		if (this.config.sampleSystem) {
+			this._timer = setInterval(() => {
+				this.rotateBucket();
+			}, this.config.intervalMs);
+			if (this._timer && typeof this._timer.unref === "function") this._timer.unref();
+		}
+	}
+	/**
+	* Reset the current bucket accumulator.
+	*/
+	_resetBucket() {
+		this._currentBucket = {
+			count: 0,
+			errors: 0,
+			durations: [],
+			durationSum: 0,
+			durationMin: -1,
+			durationMax: -1
+		};
+	}
+	/**
+	* Record a request event.
+	* @param duration - Duration in milliseconds.
+	* @param isError - Whether the request was an error.
+	*/
+	recordRequest(duration, isError = false) {
+		this.lifetime.totalRequests++;
+		if (isError) this.lifetime.totalErrors++;
+		this.lifetime.totalDuration += duration;
+		if (this.lifetime.minDuration < 0 || duration < this.lifetime.minDuration) this.lifetime.minDuration = duration;
+		if (this.lifetime.maxDuration < 0 || duration > this.lifetime.maxDuration) this.lifetime.maxDuration = duration;
+		const b = this._currentBucket;
+		b.count++;
+		if (isError) b.errors++;
+		b.durationSum += duration;
+		if (b.durationMin < 0 || duration < b.durationMin) b.durationMin = duration;
+		if (b.durationMax < 0 || duration > b.durationMax) b.durationMax = duration;
+		if (b.durations.length < this.config.percentilePrecision) b.durations.push(duration);
+	}
+	/**
+	* Get system CPU times.
+	* @returns System CPU times.
+	*/
+	_getSystemCpuTimes() {
+		const cpus = os.cpus();
+		let user = 0;
+		let nice = 0;
+		let sys = 0;
+		let idle = 0;
+		let irq = 0;
+		for (const cpu of cpus) {
+			user += cpu.times.user;
+			nice += cpu.times.nice;
+			sys += cpu.times.sys;
+			idle += cpu.times.idle;
+			irq += cpu.times.irq;
+		}
+		const total = user + nice + sys + idle + irq;
+		return {
+			user,
+			nice,
+			sys,
+			idle,
+			irq,
+			total
+		};
+	}
+	/**
+	* Calculate CPU usage percentage since last call.
+	* @returns CPU usage percentage (0-100).
+	*/
+	_calculateCpuUsage() {
+		const current = this._getSystemCpuTimes();
+		const last = this._lastCpuTimes || {
+			user: 0,
+			nice: 0,
+			sys: 0,
+			idle: 0,
+			irq: 0,
+			total: 0
+		};
+		const deltaTotal = current.total - last.total;
+		const deltaIdle = current.idle - last.idle;
+		this._lastCpuTimes = current;
+		if (deltaTotal <= 0) return 0;
+		const percent = (deltaTotal - deltaIdle) / deltaTotal * 100;
+		return Math.min(100, Math.max(0, percent));
+	}
+	/**
+	* Rotate the current bucket into history and start a new one.
+	* @param poolSnapshots - Optional pool snapshots to include.
+	*/
+	rotateBucket(poolSnapshots = []) {
+		const b = this._currentBucket;
+		const memUsage = process.memoryUsage();
+		const systemMemoryUsed = os.totalmem() - os.freemem();
+		const cpuUsage = process.cpuUsage();
+		const cpu = this._calculateCpuUsage();
+		const reqPerSec = b.count / (this.config.intervalMs / 1e3);
+		this.lifetime.maxRequestsPerSecond = Math.max(this.lifetime.maxRequestsPerSecond, reqPerSec);
+		this.lifetime.memory.heapUsedMax = Math.max(this.lifetime.memory.heapUsedMax, memUsage.heapUsed);
+		this.lifetime.memory.heapTotalMax = Math.max(this.lifetime.memory.heapTotalMax, memUsage.heapTotal);
+		this.lifetime.memory.rssMax = Math.max(this.lifetime.memory.rssMax, systemMemoryUsed);
+		this.lifetime.memory.externalMax = Math.max(this.lifetime.memory.externalMax, memUsage.external);
+		this.lifetime.cpu.max = Math.max(this.lifetime.cpu.max, cpu);
+		this.lifetime.cpu.userMax = Math.max(this.lifetime.cpu.userMax, cpuUsage.user);
+		this.lifetime.cpu.systemMax = Math.max(this.lifetime.cpu.systemMax, cpuUsage.system);
+		let p95 = 0;
+		let p99 = 0;
+		if (b.durations.length > 0) {
+			const sorted = [...b.durations].sort((x, y) => x - y);
+			const p95Idx = Math.floor(sorted.length * .95);
+			const p99Idx = Math.floor(sorted.length * .99);
+			const lastIdx = sorted.length - 1;
+			p95 = sorted[p95Idx] ?? sorted[lastIdx] ?? 0;
+			p99 = sorted[p99Idx] ?? sorted[lastIdx] ?? 0;
+		}
+		const bucket = {
+			timestamp: Date.now(),
+			requests: b.count,
+			errors: b.errors,
+			durationMin: b.durationMin < 0 ? 0 : b.durationMin,
+			durationMax: b.durationMax < 0 ? 0 : b.durationMax,
+			durationAvg: b.count > 0 ? b.durationSum / b.count : 0,
+			durationP95: p95,
+			durationP99: p99,
+			system: {
+				cpu,
+				heapUsed: memUsage.heapUsed,
+				heapTotal: memUsage.heapTotal,
+				rss: systemMemoryUsed,
+				external: memUsage.external
+			},
+			pools: poolSnapshots
+		};
+		this.history.push(bucket);
+		if (this.history.length > this.config.maxHistoryPoints) this.history.shift();
+		this._resetBucket();
+		debug$12("Bucket rotated: %j", bucket);
+	}
+	/**
+	* Stop the background timer.
+	*/
+	stop() {
+		if (this._timer) {
+			clearInterval(this._timer);
+			this._timer = void 0;
+		}
+	}
+	/**
+	* Get lifetime summary.
+	* @returns Summary.
+	*/
+	getSummary() {
+		return {
+			startTime: this.startTime,
+			totalRequests: this.lifetime.totalRequests,
+			totalErrors: this.lifetime.totalErrors,
+			avgResponseTime: this.lifetime.totalRequests > 0 ? this.lifetime.totalDuration / this.lifetime.totalRequests : 0,
+			minResponseTime: this.lifetime.minDuration,
+			maxResponseTime: this.lifetime.maxDuration,
+			maxRequestsPerSecond: this.lifetime.maxRequestsPerSecond,
+			maxMemory: this.lifetime.memory,
+			cpu: this.lifetime.cpu
+		};
+	}
+	/**
+	* Get history buffer.
+	* @returns The history buffer.
+	*/
+	getHistory() {
+		return this.history;
+	}
+};
+
+//#endregion
+//#region src/backend/server/adminContext.ts
+/**
+* Admin Context Class
+*/
+var AdminContext = class {
+	startTime;
+	config;
+	pools;
+	caches;
+	statsManager;
+	_paused;
+	constructor(config) {
+		this.startTime = /* @__PURE__ */ new Date();
+		this.config = config;
+		this.pools = [];
+		this.caches = [];
+		this.statsManager = new StatsManager();
+		this._paused = false;
+	}
+	/**
+	* Register a PL/SQL handler with the admin context.
+	* @param route - The route for the handler.
+	* @param pool - The connection pool.
+	* @param procedureNameCache - The procedure name cache.
+	* @param argumentCache - The argument cache.
+	*/
+	registerHandler(route, pool, procedureNameCache, argumentCache) {
+		this.pools.push(pool);
+		this.caches.push({
+			poolName: route,
+			procedureNameCache,
+			argumentCache
+		});
+	}
+	get paused() {
+		return this._paused;
+	}
+	setPaused(value) {
+		this._paused = value;
+	}
+};
+
+//#endregion
+//#region src/backend/util/file.ts
+/**
+* Read file.
+*
+* @param filePath - File name.
+* @returns The string.
+*/
+const readFileSyncUtf8 = (filePath) => {
+	try {
+		return readFileSync(filePath, "utf8");
+	} catch {
+		throw new Error(`Unable to read file "${filePath}"`);
+	}
+};
+/**
+* Read file.
+*
+* @param filePath - File name.
+* @returns The buffer.
+*/
+const readFile = async (filePath) => {
+	try {
+		return await promises.readFile(filePath);
+	} catch {
+		throw new Error(`Unable to read file "${filePath}"`);
+	}
+};
+/**
+* Remove file.
+*
+* @param filePath - File name.
+*/
+const removeFile = async (filePath) => {
+	try {
+		await promises.unlink(filePath);
+	} catch {
+		throw new Error(`Unable to remove file "${filePath}"`);
+	}
+};
+/**
+* Load a json file.
+*
+* @param filePath - File name.
+* @returns The json object.
+*/
+const getJsonFile = (filePath) => {
+	try {
+		const fileContent = readFileSync(filePath, "utf8");
+		return JSON.parse(fileContent);
+	} catch {
+		throw new Error(`Unable to load file "${filePath}"`);
+	}
+};
+/**
+* Is this a directory.
+* @param directoryPath - Directory name.
+* @returns Return true if it is a directory.
+*/
+const isDirectory = async (directoryPath) => {
+	if (typeof directoryPath !== "string") return false;
+	return (await promises.stat(directoryPath)).isDirectory();
+};
+/**
+* Is this a file.
+* @param filePath - File name.
+* @returns Return true if it is a file.
+*/
+const isFile = async (filePath) => {
+	if (typeof filePath !== "string") return false;
+	try {
+		return (await promises.stat(filePath)).isFile();
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+//#region src/backend/util/html.ts
+/**
+* Escape html string.
+*
+* @param value - The value.
+* @returns The escaped value.
+*/
+const escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+/**
+*	Convert LF and/or CR to <br>
+*	@param text - The text to convert.
+*	@returns The converted text.
+*/
+const convertAsciiToHtml = (text) => {
+	let html = escapeHtml(text);
+	html = html.replace(/(?:\r\n|\r|\n)/g, "<br />");
+	html = html.replace(/\t/g, "&nbsp;&nbsp;&nbsp;");
+	return html;
+};
+/**
+*	get a minimal html page.
+*	@param body - The body.
+*	@returns The html page.
+*/
+const getHtmlPage = (body) => `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>web_plsql error page</title>
+<style type="text/css">
+html {
+	font-family: monospace, sans-serif;
+	font-size: 12px;
+}
+h1 {
+	font-size: 16px;
+	padding: 2px;
+	background-color: #cc0000;
+}
+</style>
+</head>
+<body>
+${body}
+</body>
+</html>
+`;
+
+//#endregion
+//#region src/backend/util/trace.ts
+/**
+* Type guard for BindParameter
+* @param row - The row to check
+* @returns True if row is a BindParameter
+*/
+const isBindParameter = (row) => {
+	if (typeof row !== "object" || row === null) return false;
+	return "dir" in row || "type" in row || "val" in row || "maxSize" in row || "maxArraySize" in row;
+};
+const SEPARATOR_H1 = "=".repeat(100);
+const SEPARATOR_H2 = "-".repeat(30);
+/**
+* Return a string representation of the value.
+*
+* @param value - Any value.
+* @param depth - Specifies the number of times to recurse while formatting object.
+* @returns The string representation.
+*/
+const inspect = (value, depth = null) => {
+	try {
+		return util.inspect(value, {
+			showHidden: false,
+			depth,
+			colors: false
+		});
+	} catch {}
+	try {
+		return JSON.stringify(value);
+	} catch {}
+	return "Unable to convert value to string";
+};
+/**
+* Return a tabular representation of the values.
+*
+* @param head - The header values.
+* @param body - The row values.
+* @returns The output.
+*/
+const toTable = (head, body) => {
+	if (head.length === 0) throw new Error("head cannot be empty");
+	const widths = head.map((h, i) => {
+		const bodyMax = Math.max(0, ...body.map((row) => (row[i] ?? "").length));
+		return Math.max(h.length, bodyMax);
+	});
+	/**
+	*	@param cell - The string
+	*	@param width - The width
+	*	@returns The result
+	*/
+	const padCell = (cell, width) => cell.padEnd(width, " ");
+	/**
+	*	@param i - The index
+	*	@returns The width
+	*/
+	const getWidth = (i) => widths[i] ?? 0;
+	return {
+		text: [
+			head.map((h, i) => padCell(h, getWidth(i))).join(" | "),
+			widths.map((w) => "-".repeat(w ?? 0)).join("-+-"),
+			...body.map((row) => head.map((_, i) => padCell(row[i] ?? "", getWidth(i))).join(" | "))
+		].join("\n"),
+		html: `<table><thead><tr>${head.map((h) => `<th>${escapeHtml(h)}</th>`).join("")}</tr></thead><tbody>${body.map((row) => `<tr>${head.map((_, i) => `<td>${escapeHtml(row[i] ?? "")}</td>`).join("")}</tr>`).join("")}</tbody></table>`
+	};
+};
+/**
+* Log text to the console and to a file.
+*
+* @param text - Text to log.
+*/
+const logToFile = (text) => {
+	const fs = rotatingFileStream.createStream("trace.log", {
+		size: TRACE_LOG_ROTATION_SIZE,
+		interval: TRACE_LOG_ROTATION_INTERVAL,
+		maxFiles: TRACE_LOG_MAX_ROTATED_FILES,
+		compress: "gzip"
+	});
+	fs.write(text);
+	fs.end();
+};
+/**
+* Return a string representation of the request.
+*
+* @param req - express.Request.
+* @returns The string representation.
+*/
+const inspectRequest = (req) => {
+	const requestData = {};
+	Object.keys(req).filter((prop) => [
+		"originalUrl",
+		"params",
+		"query",
+		"url",
+		"method",
+		"body",
+		"files",
+		"secret",
+		"cookies"
+	].includes(prop)).forEach((prop) => {
+		requestData[prop] = req[prop];
+	});
+	return inspect(requestData);
+};
+/**
+*	Return a string representation of the bind parameter.
+*	@param dir - The direction.
+*	@returns The string.
+*/
+const dirToString = (dir) => {
+	switch (dir) {
+		case oracledb.BIND_IN: return "IN";
+		case oracledb.BIND_OUT: return "OUT";
+		case oracledb.BIND_INOUT: return "INOUT";
+		default: return "";
+	}
+};
+/**
+*	Return a string representation of the bind type.
+*	@param type - The type.
+*	@returns The string.
+*/
+const bindTypeToString = (type) => {
+	if (typeof type === "object" && type !== null && "name" in type) return type.name;
+	if (typeof type === "string") return type;
+	if (typeof type === "number") return type.toString();
+	return "";
+};
+/**
+*	Return a string representation of the bind parameter.
+*	@param output - The output.
+*	@param bind - The bind parameters.
+*/
+const inspectBindParameter = (output, bind) => {
+	const rows = Object.entries(bind);
+	if (rows.length === 0) return;
+	const { html, text } = toTable([
+		"id",
+		"dir",
+		"maxArraySize",
+		"maxSize",
+		"bind type",
+		"value",
+		"value type"
+	], rows.map(([id, row]) => {
+		let dir = "";
+		let maxArraySize = "";
+		let maxSize = "";
+		let bindType = "";
+		let value = "";
+		let valueType = "";
+		if (isBindParameter(row)) {
+			dir = dirToString(row.dir);
+			maxArraySize = row.maxArraySize ? row.maxArraySize.toString() : "";
+			maxSize = row.maxSize ? row.maxSize.toString() : "";
+			bindType = bindTypeToString(row.type);
+			value = inspect(row.val);
+			valueType = typeof row.val;
+		} else {
+			value = inspect(row);
+			valueType = typeof row;
+		}
+		return [
+			id,
+			dir,
+			maxArraySize,
+			maxSize,
+			bindType,
+			value,
+			valueType
+		];
+	}));
+	output.html += html;
+	output.text += text;
+};
+/**
+* Add environment
+*	@param output - The output.
+*	@param environment - The environment.
+*/
+const inspectEnvironment = (output, environment) => {
+	const rows = Object.entries(environment);
+	if (rows.length === 0) return;
+	const { html, text } = toTable(["key", "value"], rows);
+	output.html += html;
+	output.text += text;
+};
+/**
+*	Get a block.
+*	@param title - The name.
+*	@param body - The name.
+*	@returns The text.
+*/
+const getBlock = (title, body) => `\n${SEPARATOR_H2}${title.toUpperCase()}${SEPARATOR_H2}\n${body}`;
+/**
+*	Get line html
+*	@param text - The text.
+*	@returns The line.
+*/
+const getLineHtml = (text) => `<p>${convertAsciiToHtml(text)}</p>`;
+/**
+*	Get line text
+*	@param text - The text.
+*	@returns The line.
+*/
+const getLineText = (text) => `${text}\n`;
+/**
+*	Add line
+*	@param output - The output.
+*	@param text - The text to convert.
+*/
+const addLine = (output, text) => {
+	output.html += getLineHtml(text);
+	output.text += getLineText(text);
+};
+/**
+*	Add header
+*	@param output - The output.
+*	@param text - The text to convert.
+*/
+const addHeader = (output, text) => {
+	output.html += `<h2>${text}</h2>`;
+	output.text += `\n${text}\n${"-".repeat(text.length)}\n`;
+};
+/**
+*	Add procedure
+*	@param output - The output.
+*	@param sql - The SQL to execute.
+*	@param bind - The bind parameters.
+*/
+const addProcedure = (output, sql, bind) => {
+	output.html += `${sql}<br><br>`;
+	output.text += `${sql}\n\n`;
+	try {
+		inspectBindParameter(output, bind);
+	} catch (err) {
+		addLine(output, `Unable to inspect bind parameter: ${errorToString(err)}`);
+	}
+	output.html += `<br>`;
+	output.text += `\n`;
+};
+/**
+*	Get a formatted message.
+*	@param para - The req object represents the HTTP request.
+*	@returns The output.
+*/
+const getFormattedMessage = (para) => {
+	const timestamp = para.timestamp ?? /* @__PURE__ */ new Date();
+	const url = typeof para.req?.originalUrl === "string" && para.req.originalUrl.length > 0 ? ` on ${para.req.originalUrl}` : "";
+	const header = `${(para.type ?? "trace").toUpperCase()} at ${timestamp.toUTCString()}${url}`;
+	const output = {
+		html: `<h1>${header}</h1>`,
+		text: `\n\n${SEPARATOR_H1}\n== ${header}\n${SEPARATOR_H1}\n`
+	};
+	addHeader(output, "ERROR");
+	addLine(output, para.message);
+	if (para.req) {
+		addHeader(output, "REQUEST");
+		addLine(output, inspectRequest(para.req));
+	}
+	if (para.sql && para.bind) {
+		addHeader(output, "PROCEDURE");
+		addProcedure(output, para.sql, para.bind);
+	}
+	if (para.environment) {
+		addHeader(output, "ENVIRONMENT");
+		inspectEnvironment(output, para.environment);
+	}
+	return output;
+};
+/**
+*	Log a warning message.
+*	@param para - The req object represents the HTTP request.
+*/
+const warningMessage = (para) => {
+	const { text } = getFormattedMessage(para);
+	logToFile(text);
+	console.warn(text);
+};
+
+//#endregion
+//#region src/backend/util/errorToString.ts
+/**
+* Convert Error to a string.
+*
+* @param error - The error.
+* @returns The string representation.
+*/
+const errorToString = (error) => {
+	if (typeof error === "string") return error;
+	else if (error instanceof Error) {
+		const parts = [error.name];
+		if (typeof error.message === "string" && error.message.length > 0) parts.push(error.message);
+		if (typeof error.stack === "string" && error.stack.length > 0) parts.push(error.stack);
+		return parts.join("\n");
+	} else return inspect(error);
+};
+
+//#endregion
+//#region src/backend/handler/plsql/upload.ts
+const debug$11 = debugModule("webplsql:fileUpload");
+const z$reqFiles = z$1.array(z$1.strictObject({
+	fieldname: z$1.string(),
+	originalname: z$1.string(),
+	encoding: z$1.string(),
+	mimetype: z$1.string(),
+	destination: z$1.string(),
+	filename: z$1.string(),
+	path: z$1.string(),
+	size: z$1.number()
+}));
+/**
+* Get the files
+*
+* @param req - The req object represents the HTTP request.
+* @returns Promise that resolves with an array of files to be uploaded.
+*/
+const getFiles = (req) => {
+	if (!("files" in req)) {
+		debug$11("getFiles: no files");
+		return [];
+	}
+	if (typeof req.files === "object" && req.files !== null && Object.keys(req.files).length === 0) {
+		debug$11("getFiles: no files");
+		return [];
+	}
+	const files = z$reqFiles.parse(req.files);
+	for (const file of files) file.filename += `/${file.originalname}`;
+	debug$11("getFiles", files);
+	return files;
+};
+/**
+* Upload the given file and return a promise.
+*
+* @param file - The file to upload.
+* @param doctable - The file to upload.
+* @param databaseConnection - The file to upload.
+* @returns Promise that resolves when uploaded.
+*/
+const uploadFile = async (file, doctable, databaseConnection) => {
+	debug$11(`uploadFile`, file, doctable);
+	/* v8 ignore next - defensive validation */
+	if (typeof doctable !== "string" || doctable.length === 0) throw new Error(`Unable to upload file "${file.filename}" because the option ""doctable" has not been defined`);
+	let blobContent;
+	try {
+		blobContent = await readFile(file.path);
+	} catch (err) {
+		throw new Error(`Unable to load file "${file.path}".\n${errorToString(err)}`);
+	}
+	const sql = `INSERT INTO ${doctable} (name, mime_type, doc_size, dad_charset, last_updated, content_type, blob_content) VALUES (:name, :mime_type, :doc_size, 'ascii', SYSDATE, 'BLOB', :blob_content)`;
+	const bind = {
+		name: file.filename,
+		mime_type: file.mimetype,
+		doc_size: file.size,
+		blob_content: {
+			val: blobContent,
+			type: BUFFER
+		}
+	};
+	try {
+		await databaseConnection.execute(sql, bind, { autoCommit: true });
+	} catch (err) {
+		throw new Error(`Unable to insert file "${file.filename}".\n${errorToString(err)}`);
+	}
+	try {
+		await removeFile(file.path);
+	} catch (err) {
+		throw new Error(`Unable to remove file "${file.filename}".\n${errorToString(err)}`);
+	}
+};
+
+//#endregion
+//#region src/backend/handler/plsql/procedureVariable.ts
+const debug$10 = debugModule("webplsql:procedureVariable");
+/**
+*	Get the sql statement and bindings for the procedure to execute for a variable number of arguments
+*	@param _req - The req object represents the HTTP request. (only used for debugging)
+*	@param procName - The procedure to execute
+*	@param argObj - The arguments to pass to the procedure
+*	@returns The SQL statement and bindings for the procedure to execute
+*/
+const getProcedureVariable = (_req, procName, argObj) => {
+	/* v8 ignore start */
+	if (debug$10.enabled) debug$10(`getProcedureVariable: ${procName} arguments=`, argObj);
+	/* v8 ignore stop */
+	const names = [];
+	const values = [];
+	for (const key in argObj) {
+		const value = argObj[key];
+		if (typeof value === "string") {
+			names.push(key);
+			values.push(value);
+		} else if (Array.isArray(value)) value.forEach((item) => {
+			names.push(key);
+			values.push(item);
+		});
+	}
+	return {
+		sql: `${procName}(:argnames, :argvalues)`,
+		bind: {
+			argnames: {
+				dir: BIND_IN,
+				type: STRING,
+				val: names
+			},
+			argvalues: {
+				dir: BIND_IN,
+				type: STRING,
+				val: values
+			}
+		}
+	};
+};
+
+//#endregion
+//#region src/backend/handler/plsql/requestError.ts
+var RequestError = class RequestError extends Error {
+	timestamp;
+	/**
+	* @param message - The error message.
+	*/
+	constructor(message) {
+		super(message);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, RequestError);
+		this.timestamp = /* @__PURE__ */ new Date();
+	}
+};
+
+//#endregion
+//#region src/backend/util/util.ts
+/**
+* Convert a string to a number
+*
+* @param value - The string to convert
+* @returns The number or null if the string could not be converted
+*/
+const stringToNumber = (value) => {
+	if (typeof value === "number") return !Number.isNaN(value) && Number.isFinite(value) ? value : null;
+	if (typeof value !== "string" || !/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:E[+-]?\d+)?$/i.test(value)) return null;
+	return Number(value);
+};
+
+//#endregion
+//#region src/backend/handler/plsql/procedureNamed.ts
+const debug$9 = debugModule("webplsql:procedureNamed");
+const SQL_GET_ARGUMENT = [
+	"DECLARE",
+	"	schemaName		VARCHAR2(32767);",
+	"	part1			VARCHAR2(32767);",
+	"	part2			VARCHAR2(32767);",
+	"	dblink			VARCHAR2(32767);",
+	"	objectType		NUMBER;",
+	"	objectID		NUMBER;",
+	"BEGIN",
+	"	dbms_utility.name_resolve(name=>UPPER(:name), context=>1, schema=>schemaName, part1=>part1, part2=>part2, dblink=>dblink, part1_type=>objectType, object_number=>objectID);",
+	"	IF (part1 IS NOT NULL) THEN",
+	"		SELECT argument_name, data_type BULK COLLECT INTO :names, :types FROM all_arguments WHERE owner = schemaName AND package_name = part1 AND object_name = part2 AND argument_name IS NOT NULL ORDER BY overload, sequence;",
+	"	ELSE",
+	"		SELECT argument_name, data_type BULK COLLECT INTO :names, :types FROM all_arguments WHERE owner = schemaName AND package_name IS NULL AND object_name = part2 AND argument_name IS NOT NULL ORDER BY overload, sequence;",
+	"	END IF;",
+	"END;"
+].join("\n");
+const DATA_TYPES = Object.freeze({
+	VARCHAR2: "VARCHAR2",
+	CHAR: "CHAR",
+	BINARY_INTEGER: "BINARY_INTEGER",
+	NUMBER: "NUMBER",
+	DATE: "DATE",
+	CLOB: "CLOB",
+	PL_SQL_TABLE: "PL/SQL TABLE"
+});
+/**
+*	Retrieve the argument types for a given procedure to be executed.
+*	This is important because if the procedure is defined to take a PL/SQL indexed table,
+*	we must provise a table, even if there is only one argument to be submitted.
+*	@param procedure - The procedure
+*	@param databaseConnection - The database connection
+*	@returns The argument types
+*/
+const loadArguments = async (procedure, databaseConnection) => {
+	const bind = {
+		name: {
+			dir: BIND_IN,
+			type: STRING,
+			val: procedure
+		},
+		names: {
+			dir: BIND_OUT,
+			type: STRING,
+			maxSize: 60,
+			maxArraySize: MAX_PROCEDURE_PARAMETERS
+		},
+		types: {
+			dir: BIND_OUT,
+			type: STRING,
+			maxSize: 60,
+			maxArraySize: MAX_PROCEDURE_PARAMETERS
+		}
+	};
+	let result = {};
+	try {
+		result = await databaseConnection.execute(SQL_GET_ARGUMENT, bind);
+	} catch (err) {
+		/* v8 ignore start */
+		debug$9("result", result);
+		throw new RequestError(`Error when retrieving arguments\n${SQL_GET_ARGUMENT}\n${errorToString(err)}`);
+	}
+	let data;
+	try {
+		data = z$1.object({
+			names: z$1.array(z$1.string().nullable()),
+			types: z$1.array(z$1.string().nullable())
+		}).parse(result.outBinds);
+	} catch (err) {
+		/* v8 ignore start */
+		debug$9("result.outBinds", result.outBinds);
+		throw new RequestError(`Error when decoding arguments\n${SQL_GET_ARGUMENT}\n${errorToString(err)}`);
+	}
+	if (data.names.length !== data.types.length) throw new RequestError("Error when decoding arguments. The number of names and types does not match");
+	const argTypes = {};
+	for (let i = 0; i < data.names.length; i++) {
+		const name = data.names[i];
+		const type = data.types[i];
+		if (name && type) argTypes[name.toLowerCase()] = type;
+	}
+	return argTypes;
+};
+/**
+*	Find the argument types for a given procedure to be executed.
+*	As the arguments are cached, we first look up the cache and only if not yet available we load them.
+*	@param procedure - The procedure
+*	@param databaseConnection - The database connection
+*	@param argumentCache - The argument cache.
+*	@returns The argument types
+*/
+const findArguments = async (procedure, databaseConnection, argumentCache) => {
+	const key = procedure.toUpperCase();
+	const cachedArgs = argumentCache.get(key);
+	if (cachedArgs) {
+		/* v8 ignore start */
+		if (debug$9.enabled) debug$9(`findArguments: procedure "${procedure}" found in cache`);
+		/* v8 ignore stop */
+		return cachedArgs;
+	}
+	/* v8 ignore start */
+	if (debug$9.enabled) debug$9(`findArguments: procedure "${procedure}" not found in cache and must be loaded`);
+	/* v8 ignore stop */
+	const args = await loadArguments(procedure, databaseConnection);
+	argumentCache.set(key, args);
+	return args;
+};
+/**
+*	Get the bindling for an argument.
+*	@param argName - The argument name.
+*	@param argValue - The argument value.
+*	@param argType - The argument type.
+*	@returns The binding.
+*/
+const getBinding = (argName, argValue, argType) => {
+	if (argType === DATA_TYPES.VARCHAR2 || argType === DATA_TYPES.CHAR) return {
+		dir: BIND_IN,
+		type: DB_TYPE_VARCHAR,
+		val: argValue
+	};
+	if (argType === DATA_TYPES.CLOB) return {
+		dir: BIND_IN,
+		type: DB_TYPE_CLOB,
+		val: argValue
+	};
+	if (argType === DATA_TYPES.NUMBER || argType === DATA_TYPES.BINARY_INTEGER) {
+		const value = stringToNumber(argValue);
+		if (value === null) throw new Error(`Error in named parameter "${argName}": invalid value "${argValue}" for type "${argType}"`);
+		return {
+			dir: BIND_IN,
+			type: DB_TYPE_NUMBER,
+			val: value
+		};
+	}
+	if (argType === DATA_TYPES.DATE) {
+		if (typeof argValue !== "string") throw new Error(`Error in named parameter "${argName}": invalid value "${argValue}" for type "${argType}"`);
+		const value = new Date(argValue);
+		if (Number.isNaN(value.getTime())) throw new Error(`Error in named parameter "${argName}": invalid value "${argValue}" for type "${argType}"`);
+		return {
+			dir: BIND_IN,
+			type: DB_TYPE_VARCHAR,
+			val: value
+		};
+	}
+	if (argType === DATA_TYPES.PL_SQL_TABLE || Array.isArray(argValue)) return {
+		dir: BIND_IN,
+		type: DB_TYPE_DATE,
+		val: typeof argValue === "string" ? [argValue] : argValue
+	};
+	throw new Error(`Error in named parameter "${argName}": invalid binding type "${argType}"`);
+};
+/**
+*	Get binding table for tracing.
+*	@param argObj - The arguments to pass to the procedure
+*	@param argTypes - The argument types.
+*	@returns The text.
+*/
+const inspectBindings = (argObj, argTypes) => {
+	const { text } = toTable([
+		"id",
+		"value",
+		"value type",
+		"argument type"
+	], Object.entries(argObj).map(([key, value]) => {
+		return [
+			key,
+			value.toString(),
+			typeof value,
+			argTypes[key.toLowerCase()] ?? "unknown"
+		];
+	}));
+	return text;
+};
+/**
+*	Get the sql statement and bindings for the procedure to execute for a fixed number of arguments
+*	@param req - The req object represents the HTTP request. (only used for debugging)
+*	@param procName - The procedure to execute
+*	@param argObj - The arguments to pass to the procedure
+*	@param databaseConnection - The database connection
+*	@param argumentCache - The argument cache.
+*	@returns The SQL statement and bindings for the procedure to execute
+*/
+const getProcedureNamed = async (req, procName, argObj, databaseConnection, argumentCache) => {
+	debug$9(`getProcedureNamed: ${procName} arguments=`, argObj);
+	const argTypes = await findArguments(procName, databaseConnection, argumentCache);
+	const sqlParameter = [];
+	const bindings = {};
+	for (const key in argObj) {
+		const parameterName = `p_${key}`;
+		const argValue = argObj[key];
+		const argType = argTypes[key.toLowerCase()];
+		let bind = {
+			dir: BIND_IN,
+			type: DB_TYPE_VARCHAR,
+			val: argValue
+		};
+		if (argType) bind = getBinding(key, argValue, argType);
+		else warningMessage({
+			type: "warning",
+			message: `Error in named parameter "${key}": invalid binding type "${argType}"\n\n${inspectBindings(argObj, argTypes)}`,
+			req
+		});
+		sqlParameter.push(`${key}=>:${parameterName}`);
+		bindings[parameterName] = bind;
+	}
+	const sql = `${procName}(${sqlParameter.join(", ")})`;
+	/* v8 ignore start */
+	if (debug$9.enabled) {
+		debug$9(sql);
+		debug$9(inspectBindings(argObj, argTypes));
+	}
+	/* v8 ignore stop */
+	return {
+		sql,
+		bind: bindings
+	};
+};
+
+//#endregion
+//#region src/backend/handler/plsql/parsePage.ts
+const debug$8 = debugModule("webplsql:parsePage");
+/**
+*	Parse the header and split it up into the individual components
+*
+* @param text - The text returned from the PL/SQL procedure.
+* @returns The parsed page.
+*/
+const parsePage = (text) => {
+	const page = {
+		body: "",
+		head: {
+			cookies: [],
+			otherHeaders: {}
+		},
+		file: {
+			fileType: null,
+			fileSize: null,
+			fileBlob: null
+		}
+	};
+	let head = "";
+	const headerEndPosition = text.indexOf("\n\n");
+	if (headerEndPosition === -1) head = text;
+	else {
+		head = text.substring(0, headerEndPosition + 2);
+		page.body = text.substring(headerEndPosition + 2);
+	}
+	debug$8("parsing the headers received from PL/SQL");
+	head.split("\n").forEach((line) => {
+		const header = getHeader(line);
+		if (header) switch (header.name.toLowerCase()) {
+			case "set-cookie":
+				{
+					const cookie = parseCookie(header.value);
+					debug$8(`oracle header "set-cookie" with value "${header.value}" was received has been parsed to ${JSON.stringify(cookie)}`);
+					if (cookie !== null) page.head.cookies.push(cookie);
+					else throw new Error(`Unable to parse header "set-cookie" with value "${header.value}" received from PL/SQL`);
+				}
+				break;
+			case "content-type":
+				page.head.contentType = header.value;
+				debug$8(`oracle header "content-type" with value "${page.head.contentType}" was parsed`);
+				break;
+			case "x-db-content-length":
+				{
+					const contentLength = parseInt(header.value, 10);
+					if (!Number.isNaN(contentLength)) {
+						page.head.contentLength = contentLength;
+						debug$8(`oracle header "x-db-content-length" with value "${page.head.contentLength}" was parsed`);
+					} else throw new Error(`Unable to parse header "x-db-content-length" with value "${header.value}" received from PL/SQL`);
+				}
+				break;
+			case "status":
+				{
+					const statusCode = parseInt(header.value, 10);
+					if (!Number.isNaN(statusCode)) {
+						page.head.statusCode = statusCode;
+						debug$8(`oracle header "status" with value "${page.head.statusCode}" was parsed`);
+						const index = header.value.indexOf(" ");
+						if (index !== -1) page.head.statusDescription = header.value.substring(index + 1);
+					} else throw new Error(`Unable to parse header "status" with value "${header.value}" received from PL/SQL`);
+				}
+				break;
+			case "location":
+				page.head.redirectLocation = header.value;
+				debug$8(`oracle header "location" with value "${page.head.statusCode}" was parsed`);
+				break;
+			case "x-oracle-ignore": break;
+			default:
+				page.head.otherHeaders[header.name] = header.value;
+				break;
+		}
+	});
+	return page;
+};
+/**
+*	Get a header line
+*	@param line - The line
+*	@returns The header.
+*/
+const getHeader = (line) => {
+	const index = line.indexOf(":");
+	if (index !== -1) return {
+		name: line.substring(0, index).trim(),
+		value: line.substring(index + 1).trim()
+	};
+	return null;
+};
+/**
+*	Parses a cookie string
+*	@param text - The cookie string.
+*	@returns The parsed cookie.
+*/
+const parseCookie = (text) => {
+	if (typeof text !== "string" || text.trim().length === 0) return null;
+	let cookieElements = text.split(";");
+	cookieElements = cookieElements.map((element) => element.trim());
+	const firstElement = cookieElements[0];
+	if (!firstElement) return null;
+	const index = firstElement.indexOf("=");
+	if (index <= 0) return null;
+	const cookie = {
+		name: firstElement.substring(0, index).trim(),
+		value: firstElement.substring(index + 1).trim(),
+		options: {}
+	};
+	cookieElements.shift();
+	cookieElements.forEach((element) => {
+		if (element.toLowerCase().startsWith("path=")) cookie.options.path = element.substring(5);
+		else if (element.toLowerCase().startsWith("domain=")) cookie.options.domain = element.substring(7);
+		else if (element.toLowerCase().startsWith("secure")) cookie.options.secure = true;
+		else if (element.toLowerCase().startsWith("expires=")) {
+			const date = tryDecodeDate(element.substring(8));
+			if (date) cookie.options.expires = date;
+		} else if (element.toLowerCase().startsWith("httponly")) cookie.options.httpOnly = true;
+	});
+	return cookie;
+};
+/**
+* Try to decode a date
+* @param value - The value to decode.
+* @returns The decoded date or null.
+*/
+const tryDecodeDate = (value) => {
+	const result = new Date(value);
+	if (Number.isNaN(result.getTime())) return null;
+	return result;
+};
+
+//#endregion
+//#region src/backend/handler/plsql/sendResponse.ts
+const debug$7 = debugModule("webplsql:sendResponse");
+/**
+*	Send "default" response to the browser
+*	@param _req - The req object represents the HTTP request.
+*	@param res - The res object represents the HTTP response that an Express app sends when it gets an HTTP request.
+*	@param page - The page to send.
+*/
+const sendResponse = async (_req, res, page) => {
+	const debugText = [];
+	page.head.cookies.forEach((cookie) => {
+		/* v8 ignore start */
+		if (debug$7.enabled) debugText.push(`res.cookie: name="${cookie.name}" value="${cookie.value}" options=${JSON.stringify(cookie.options)}`);
+		/* v8 ignore stop */
+		res.cookie(cookie.name, cookie.value, cookie.options);
+	});
+	if (typeof page.head.redirectLocation === "string" && page.head.redirectLocation.length > 0) {
+		/* v8 ignore start */
+		if (debug$7.enabled) {
+			debugText.push(`res.redirect(302, "${page.head.redirectLocation}")`);
+			debug$7(getBlock("RESPONSE", debugText.join("\n")));
+		}
+		/* v8 ignore stop */
+		res.redirect(302, page.head.redirectLocation);
+		return;
+	}
+	for (const key in page.head.otherHeaders) {
+		/* v8 ignore start */
+		if (debug$7.enabled) debugText.push(`res.set("${key}", "${page.head.otherHeaders[key]}")`);
+		/* v8 ignore stop */
+		res.set(key, page.head.otherHeaders[key]);
+	}
+	if (page.file.fileType === "B" || page.file.fileType === "F") {
+		const headers = {};
+		if (typeof page.head.contentType === "string" && page.head.contentType.length > 0) headers["Content-Type"] = page.head.contentType;
+		if (typeof page.file.fileSize === "number" && page.file.fileSize > 0) headers["Content-Length"] = page.file.fileSize.toString();
+		if (Object.keys(headers).length > 0) {
+			/* v8 ignore start */
+			if (debug$7.enabled) debugText.push(`res.writeHead(200, ${JSON.stringify(headers)})`);
+			/* v8 ignore stop */
+			res.writeHead(200, headers);
+		}
+		if (page.file.fileBlob instanceof stream.Readable) {
+			/* v8 ignore start */
+			if (debug$7.enabled) {
+				debugText.push(`res.pipe("${page.file.fileType ?? ""}") - streaming`);
+				debug$7(getBlock("RESPONSE", debugText.join("\n")));
+			}
+			await new Promise((resolve, reject) => {
+				if (page.file.fileBlob instanceof stream.Readable) {
+					page.file.fileBlob.pipe(res);
+					page.file.fileBlob.on("end", () => resolve());
+					/* v8 ignore next - error handler */
+					page.file.fileBlob.on("error", (err) => reject(err));
+					/* v8 ignore next - error handler */
+					res.on("close", () => resolve());
+				}
+			});
+		} else {
+			/* v8 ignore start */
+			if (debug$7.enabled) {
+				debugText.push(`res.end("${page.file.fileType ?? ""}") - buffer`);
+				debug$7(getBlock("RESPONSE", debugText.join("\n")));
+			}
+			/* v8 ignore stop */
+			res.end(page.file.fileBlob, "binary");
+		}
+		return;
+	}
+	if (typeof page.head.contentType === "string" && page.head.contentType.length > 0) {
+		/* v8 ignore start */
+		if (debug$7.enabled) debugText.push(`res.set("Content-Type", "${page.head.contentType}")`);
+		/* v8 ignore stop */
+		res.set("Content-Type", page.head.contentType);
+	}
+	if (typeof page.head.statusCode === "number") {
+		/* v8 ignore start */
+		if (debug$7.enabled) {
+			debugText.push(`res.status(page.head.statusCode).send("${page.head.statusDescription ?? ""}")`);
+			debug$7(getBlock("RESPONSE", debugText.join("\n")));
+		}
+		/* v8 ignore stop */
+		res.status(page.head.statusCode).send(page.head.statusDescription);
+		return;
+	}
+	/* v8 ignore start */
+	if (debug$7.enabled) {
+		if (page.body instanceof stream.Readable) debugText.push(`${"-".repeat(60)}\n[Stream Body]`);
+		else debugText.push(`${"-".repeat(60)}\n${page.body}`);
+		debug$7(getBlock("RESPONSE", debugText.join("\n")));
+	}
+	/* v8 ignore stop */
+	if (page.body instanceof stream.Readable) await new Promise((resolve, reject) => {
+		if (page.body instanceof stream.Readable) {
+			page.body.pipe(res);
+			page.body.on("end", () => resolve());
+			/* v8 ignore next - error handler */
+			page.body.on("error", (err) => reject(err));
+			/* v8 ignore next - error handler */
+			res.on("close", () => resolve());
+		}
+	});
+	else res.send(page.body);
+};
+
+//#endregion
+//#region src/backend/handler/plsql/procedureError.ts
+var ProcedureError = class ProcedureError extends Error {
+	timestamp;
+	environment;
+	sql;
+	bind;
+	/**
+	* @param message - The error message.
+	* @param environment - The environment.
+	* @param sql - The SQL to execute.
+	* @param bind - The bind parameters.
+	*/
+	constructor(message, environment, sql, bind) {
+		super(message);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ProcedureError);
+		this.timestamp = /* @__PURE__ */ new Date();
+		this.environment = environment;
+		this.sql = sql;
+		this.bind = bind;
+	}
+};
+
+//#endregion
+//#region src/backend/util/cache.ts
+/**
+* Generic Cache class with LFU (Least Frequently Used) eviction policy.
+*/
+var Cache = class {
+	cache;
+	maxSize;
+	hits;
+	misses;
+	/**
+	* @param maxSize - Maximum number of entries in the cache.
+	*/
+	constructor(maxSize = DEFAULT_CACHE_MAX_SIZE) {
+		this.cache = /* @__PURE__ */ new Map();
+		this.maxSize = maxSize;
+		this.hits = 0;
+		this.misses = 0;
+	}
+	/**
+	* Get an entry from the cache.
+	* @param key - The key.
+	* @returns The value or undefined if not found.
+	*/
+	get(key) {
+		const entry = this.cache.get(key);
+		if (entry) {
+			entry.hitCount++;
+			this.hits++;
+			return entry.value;
+		}
+		this.misses++;
+	}
+	/**
+	* Set an entry in the cache.
+	* @param key - The key.
+	* @param value - The value.
+	*/
+	set(key, value) {
+		if (this.cache.size >= this.maxSize && !this.cache.has(key)) this.prune();
+		this.cache.set(key, {
+			hitCount: 0,
+			value
+		});
+	}
+	/**
+	* Delete an entry from the cache.
+	* @param key - The key.
+	*/
+	delete(key) {
+		this.cache.delete(key);
+	}
+	/**
+	* Clear the cache.
+	*/
+	clear() {
+		this.cache.clear();
+		this.hits = 0;
+		this.misses = 0;
+	}
+	/**
+	* Prune the cache by removing the least frequently used entries.
+	* Removes 10% of the cache size.
+	*/
+	prune() {
+		const entries = Array.from(this.cache.entries());
+		entries.sort((a, b) => a[1].hitCount - b[1].hitCount);
+		const removeCount = Math.max(1, Math.floor(this.maxSize * CACHE_PRUNE_PERCENT));
+		const keysToRemove = entries.slice(0, removeCount).map(([key]) => key);
+		for (const key of keysToRemove) this.cache.delete(key);
+	}
+	/**
+	* Get the size of the cache.
+	* @returns The size.
+	*/
+	get size() {
+		return this.cache.size;
+	}
+	/**
+	* Get all keys in the cache.
+	* @returns The keys.
+	*/
+	keys() {
+		return Array.from(this.cache.keys());
+	}
+	/**
+	* Get cache statistics.
+	* @returns The statistics.
+	*/
+	getStats() {
+		return {
+			size: this.cache.size,
+			maxSize: this.maxSize,
+			hits: this.hits,
+			misses: this.misses
+		};
+	}
+};
+
+//#endregion
+//#region src/backend/handler/plsql/procedureSanitize.ts
+const debug$6 = debugModule("webplsql:procedureSanitize");
+const DEFAULT_EXCLUSION_LIST = [
+	"sys.",
+	"dbms_",
+	"utl_",
+	"owa_",
+	"htp.",
+	"htf.",
+	"wpg_docload.",
+	"ctxsys.",
+	"mdsys."
+];
+const validationFunctionCache = new Cache();
+/**
+* Resolve the procedure name using dbms_utility.name_resolve.
+*
+* @param procName - The procedure name to resolve.
+* @param databaseConnection - The database connection.
+* @param procedureNameCache - The procedure name cache.
+* @returns The resolved canonical procedure name (SCHEMA.NAME).
+*/
+const resolveProcedureName = async (procName, databaseConnection, procedureNameCache) => {
+	const cachedName = procedureNameCache.get(procName);
+	if (cachedName) {
+		debug$6(`resolveProcedureName: Cache hit for "${procName}" -> "${cachedName}"`);
+		return cachedName;
+	}
+	debug$6(`resolveProcedureName: Cache miss for "${procName}". Resolving in DB...`);
+	const sql = `
+		DECLARE
+			l_schema VARCHAR2(128);
+			l_part1  VARCHAR2(128);
+			l_part2  VARCHAR2(128);
+			l_dblink VARCHAR2(128);
+			l_part1_type NUMBER;
+			l_object_number NUMBER;
+		BEGIN
+			dbms_utility.name_resolve(
+				name => :name,
+				context => 1,
+				schema => l_schema,
+				part1 => l_part1,
+				part2 => l_part2,
+				dblink => l_dblink,
+				part1_type => l_part1_type,
+				object_number => l_object_number
+			);
+			
+			-- Reconstruct the canonical name
+			-- If it's a package procedure: schema.package.procedure
+			-- If it's a standalone procedure: schema.procedure
+			
+			IF l_part1 IS NOT NULL THEN
+				:resolved := l_schema || '.' || l_part1 || '.' || l_part2;
+			ELSE
+				:resolved := l_schema || '.' || l_part2;
+			END IF;
+		END;
+	`;
+	const bind = {
+		name: {
+			dir: BIND_IN,
+			type: STRING,
+			val: procName
+		},
+		resolved: {
+			dir: BIND_OUT,
+			type: STRING,
+			maxSize: OWA_RESOLVED_NAME_MAX_LEN
+		}
+	};
+	try {
+		const result = await databaseConnection.execute(sql, bind);
+		const { resolved } = z$1.strictObject({ resolved: z$1.string() }).parse(result.outBinds);
+		if (!resolved) throw new RequestError(`Could not resolve procedure name "${procName}"`);
+		debug$6(`resolveProcedureName: Resolved "${procName}" -> "${resolved}"`);
+		procedureNameCache.set(procName, resolved);
+		return resolved;
+	} catch (err) {
+		/* v8 ignore start */
+		debug$6(`resolveProcedureName: Error resolving "${procName}"`, err);
+		/* v8 ignore stop */
+		throw new RequestError(`Procedure "${procName}" not found or not accessible.\n${errorToString(err)}`);
+	}
+};
+/**
+* Sanitize the procedure name.
+*
+* @param procName - The procedure name.
+* @param databaseConnection - The database connection
+* @param options - the options for the middleware.
+* @param procedureNameCache - The procedure name cache.
+* @returns Promise resolving to final procedure name.
+*/
+const sanitizeProcName = async (procName, databaseConnection, options, procedureNameCache) => {
+	debug$6("sanitizeProcName", procName);
+	let finalProcName = procName.toLowerCase().trim();
+	finalProcName = removeSpecialCharacters(finalProcName);
+	for (const i of DEFAULT_EXCLUSION_LIST) if (finalProcName.startsWith(i)) {
+		const error = `Procedure name "${procName}" is in default exclusion list "${DEFAULT_EXCLUSION_LIST.join(",")}"`;
+		/* v8 ignore start */
+		debug$6(error);
+		/* v8 ignore stop */
+		throw new RequestError(error);
+	}
+	if (options.exclusionList && options.exclusionList.length > 0) {
+		for (const i of options.exclusionList) if (finalProcName.startsWith(i)) {
+			const error = `Procedure name "${procName}" is in custom exclusion list "${options.exclusionList.join(",")}"`;
+			/* v8 ignore start */
+			debug$6(error);
+			/* v8 ignore stop */
+			throw new RequestError(error);
+		}
+	}
+	if (options.requestValidationFunction && options.requestValidationFunction.length > 0) {
+		if (!await requestValidationFunction(finalProcName, options.requestValidationFunction, databaseConnection)) {
+			const error = `Procedure name "${procName}" is not valid according to the request validation function "${options.requestValidationFunction}"`;
+			/* v8 ignore start */
+			debug$6(error);
+			/* v8 ignore stop */
+			throw new RequestError(error);
+		}
+	}
+	return await resolveProcedureName(finalProcName, databaseConnection, procedureNameCache);
+};
+/**
+* @param str - string
+* @returns string
+*/
+const removeSpecialCharacters = (str) => {
+	if (str === null || str === void 0) return "";
+	const chars = [];
+	for (const c of str) if (c >= "0" && c <= "9" || c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "." || c === "_" || c === "#" || c === "$") chars.push(c);
+	return chars.join("");
+};
+/**
+* @param procName - The procedure name.
+* @param requestValidationFunction -  The request validation function.
+* @param databaseConnection - The database connection
+* @returns Promise resolving to final procedure name.
+*/
+const loadRequestValid = async (procName, requestValidationFunction, databaseConnection) => {
+	const bind = {
+		proc: {
+			dir: BIND_IN,
+			type: STRING,
+			val: procName
+		},
+		valid: {
+			dir: BIND_OUT,
+			type: NUMBER
+		}
+	};
+	const SQL = [
+		"DECLARE",
+		"   l_valid NUMBER := 0;",
+		"BEGIN",
+		`   IF (${requestValidationFunction}(:proc)) THEN`,
+		"      l_valid := 1;",
+		"   END IF;",
+		"   :valid := l_valid;",
+		"END;"
+	].join("\n");
+	let result = {};
+	try {
+		result = await databaseConnection.execute(SQL, bind);
+	} catch (err) {
+		/* v8 ignore start */
+		debug$6("result", result);
+		throw new RequestError(`Error when validating procedure name "${procName}"\n${SQL}\n${errorToString(err)}`);
+	}
+	try {
+		return z$1.strictObject({ valid: z$1.number() }).parse(result.outBinds).valid === 1;
+	} catch (err) {
+		/* v8 ignore start */
+		debug$6("result", result.outBinds);
+		/* v8 ignore stop */
+		const message = `Internal error when parsing ${String(result.outBinds)}\n${errorToString(err)}`;
+		throw new Error(message);
+	}
+};
+/**
+* Request validation function.
+*
+* @param procName - The procedure name.
+* @param validationFunction -  The request validation function.
+* @param databaseConnection - The database connection
+* @returns Promise resolving to final procedure name.
+*/
+const requestValidationFunction = async (procName, validationFunction, databaseConnection) => {
+	debug$6("requestValidationFunction", procName, validationFunction);
+	const key = procName.toLowerCase();
+	const cacheEntry = validationFunctionCache.get(key);
+	if (cacheEntry !== void 0) {
+		/* v8 ignore start */
+		if (debug$6.enabled) debug$6(`requestValidationFunction: procedure "${procName}" found in cache`);
+		/* v8 ignore stop */
+		return cacheEntry.valid;
+	}
+	/* v8 ignore start */
+	if (debug$6.enabled) debug$6(`requestValidationFunction: procedure "${procName}" not found in cache and must be loaded`);
+	/* v8 ignore stop */
+	const valid = await loadRequestValid(procName, validationFunction, databaseConnection);
+	validationFunctionCache.set(key, { valid });
+	return valid;
+};
+
+//#endregion
+//#region src/backend/handler/plsql/owaPageStream.ts
+const debug$5 = debugModule("webplsql:owaPageStream");
+var OWAPageStream = class extends Readable {
+	databaseConnection;
+	chunkSize;
+	isDone;
+	/**
+	* @param databaseConnection - The database connection.
+	*/
+	constructor(databaseConnection) {
+		super({ highWaterMark: OWA_STREAM_BUFFER_SIZE });
+		this.databaseConnection = databaseConnection;
+		this.chunkSize = OWA_STREAM_CHUNK_SIZE;
+		this.isDone = false;
+	}
+	/**
+	* Fetch a chunk of the page from the database.
+	* @returns The array of lines fetched.
+	*/
+	async fetchChunk() {
+		if (this.isDone) return [];
+		const bindParameter = {
+			lines: {
+				dir: BIND_OUT,
+				type: STRING,
+				maxArraySize: this.chunkSize
+			},
+			irows: {
+				dir: BIND_INOUT,
+				type: NUMBER,
+				val: this.chunkSize
+			}
+		};
+		const sqlStatement = "BEGIN owa.get_page(thepage=>:lines, irows=>:irows); END;";
+		try {
+			const result = await this.databaseConnection.execute(sqlStatement, bindParameter);
+			const { lines, irows } = z$1.strictObject({
+				irows: z$1.number(),
+				lines: z$1.array(z$1.string())
+			}).parse(result.outBinds);
+			debug$5(`fetched ${lines.length} lines (irows=${irows})`);
+			if (lines.length < this.chunkSize) this.isDone = true;
+			return lines;
+		} catch (err) {
+			if (err instanceof ProcedureError) throw err;
+			throw new ProcedureError(`OWAPageStream: error when getting page\n${errorToString(err)}`, {}, sqlStatement, bindParameter);
+		}
+	}
+	/**
+	* @override
+	* @param _size - The size hint (unused).
+	*/
+	_read(_size) {
+		this.fetchChunk().then((lines) => {
+			if (lines.length > 0) this.push(lines.join(""));
+			if (this.isDone) this.push(null);
+		}).catch((err) => {
+			this.destroy(err instanceof Error ? err : new Error(String(err)));
+		});
+	}
+	/**
+	* Add initial body content to the stream.
+	* @param content - The initial content to prepend.
+	*/
+	addBody(content) {
+		if (content && content.length > 0) this.push(content);
+	}
+};
+
+//#endregion
+//#region src/backend/util/traceManager.ts
+var TraceManager = class {
+	enabled;
+	filename;
+	maxEntries;
+	constructor() {
+		this.enabled = false;
+		this.filename = "trace.json.log";
+		this.maxEntries = 1e3;
+	}
+	/**
+	* Toggle tracing
+	* @param enabled - New state
+	*/
+	setEnabled(enabled) {
+		this.enabled = enabled;
+	}
+	/**
+	* Is tracing enabled?
+	* @returns The state
+	*/
+	isEnabled() {
+		return this.enabled;
+	}
+	/**
+	* Add a trace entry
+	* @param entry - The trace entry
+	*/
+	addTrace(entry) {
+		if (!this.enabled) return;
+		try {
+			const line = JSON.stringify(entry) + "\n";
+			fs.appendFileSync(this.filename, line);
+		} catch (err) {
+			console.error("TraceManager: error writing trace", err);
+		}
+	}
+	/**
+	* Clear all traces
+	*/
+	clear() {
+		try {
+			if (fs.existsSync(this.filename)) fs.truncateSync(this.filename, 0);
+		} catch (err) {
+			console.error("TraceManager: error clearing traces", err);
+		}
+	}
+	/**
+	* Get the full path to the trace file
+	* @returns The path
+	*/
+	getFilePath() {
+		return path.resolve(this.filename);
+	}
+};
+const traceManager = new TraceManager();
+
+//#endregion
+//#region src/backend/handler/plsql/procedure.ts
+const debug$4 = debugModule("webplsql:procedure");
+/**
+*	Get the procedure and arguments to execute
+*	@param req - The req object represents the HTTP request. (only used for debugging)
+*	@param procName - The procedure to execute
+*	@param argObj - The arguments to pass to the procedure
+*	@param options - The options for the middleware
+*	@param databaseConnection - The database connection
+*	@param procedureNameCache - The procedure name cache.
+*	@param argumentCache - The argument cache.
+*	@returns The SQL statement and bindings for the procedure to execute
+*/
+const getProcedure = async (req, procName, argObj, options, databaseConnection, procedureNameCache, argumentCache) => {
+	if (options.pathAlias?.toLowerCase() === procName.toLowerCase()) {
+		/* v8 ignore start */
+		debug$4(`getProcedure: path alias "${options.pathAlias}" redirects to "${options.pathAliasProcedure}"`);
+		/* v8 ignore stop */
+		return {
+			sql: `${options.pathAliasProcedure}(p_path=>:p_path)`,
+			bind: { p_path: {
+				dir: BIND_IN,
+				type: STRING,
+				val: procName
+			} }
+		};
+	}
+	const useVariableArguments = procName.startsWith("!");
+	const sanitizedProcName = await sanitizeProcName(useVariableArguments ? procName.substring(1) : procName, databaseConnection, options, procedureNameCache);
+	if (useVariableArguments) return {
+		...getProcedureVariable(req, sanitizedProcName, argObj),
+		resolvedName: sanitizedProcName
+	};
+	else return {
+		...await getProcedureNamed(req, sanitizedProcName, argObj, databaseConnection, argumentCache),
+		resolvedName: sanitizedProcName
+	};
+};
+/**
+* Prepare procedure
+*
+* NOTE:
+* 	1) dbms_session.modify_package_state(dbms_session.reinitialize) is used to ensure a stateless environment by resetting package state (dbms_session.reset_package)
+*
+* @param cgiObj - The cgi of the procedure to invoke.
+* @param databaseConnection - Database connection.
+* @returns Promise resolving to void.
+*/
+const procedurePrepare = async (cgiObj, databaseConnection) => {
+	let sqlStatement = "BEGIN dbms_session.modify_package_state(dbms_session.reinitialize); END;";
+	try {
+		await databaseConnection.execute(sqlStatement);
+	} catch (err) {
+		throw new ProcedureError(`procedurePrepare: error when preparing procedure\n${errorToString(err)}`, cgiObj, sqlStatement, {});
+	}
+	sqlStatement = "BEGIN owa.init_cgi_env(:cgicount, :cginames, :cgivalues); owa.user_id := :remote_user; htp.init; htp.htbuf_len := 63; END;";
+	const bindParameter = {
+		cgicount: {
+			dir: BIND_IN,
+			type: NUMBER,
+			val: Object.keys(cgiObj).length
+		},
+		cginames: {
+			dir: BIND_IN,
+			type: STRING,
+			val: Object.keys(cgiObj)
+		},
+		cgivalues: {
+			dir: BIND_IN,
+			type: STRING,
+			val: Object.values(cgiObj)
+		},
+		remote_user: {
+			dir: BIND_IN,
+			type: STRING,
+			val: (cgiObj.REMOTE_USER ?? "").substring(0, 30)
+		}
+	};
+	try {
+		await databaseConnection.execute(sqlStatement, bindParameter);
+	} catch (err) {
+		throw new ProcedureError(`procedurePrepare: error when preparing procedure\n${errorToString(err)}`, cgiObj, sqlStatement, bindParameter);
+	}
+};
+/**
+* Execute procedure
+*
+* @param para - The statement and binding to use when executing the procedure.
+* @param para.sql - The SQL statement.
+* @param para.bind - The bind parameters.
+* @param databaseConnection - Database connection.
+* @returns Promise resolving to void.
+*/
+const procedureExecute = async (para, databaseConnection) => {
+	const sqlStatement = `BEGIN ${para.sql}; END;`;
+	try {
+		await databaseConnection.execute(sqlStatement, para.bind);
+	} catch (err) {
+		throw new ProcedureError(`procedureExecute: error when executing procedure:\n${sqlStatement}\n${errorToString(err)}`, {}, para.sql, para.bind);
+	}
+};
+/**
+* Download files from procedure
+*
+* @param fileBlob - The blob eventually containing the file.
+* @param databaseConnection - Database connection.
+* @returns Promise resolving to the result.
+*/
+const procedureDownloadFiles = async (fileBlob, databaseConnection) => {
+	const bindParameter = {
+		fileType: {
+			dir: BIND_OUT,
+			type: STRING
+		},
+		fileSize: {
+			dir: BIND_OUT,
+			type: NUMBER
+		},
+		fileBlob: {
+			dir: BIND_INOUT,
+			type: BLOB,
+			val: fileBlob
+		}
+	};
+	const sqlStatement = `
+DECLARE
+	l_file_type		VARCHAR2(32767)	:= '';
+	l_file_size		INTEGER			:= 0;
+BEGIN
+	IF (wpg_docload.is_file_download()) THEN
+		wpg_docload.get_download_file(l_file_type);
+		IF (l_file_type = 'B') THEN
+			wpg_docload.get_download_blob(:fileBlob);
+			l_file_size := dbms_lob.getlength(:fileBlob);
+		END IF;
+	END IF;
+	:fileType := l_file_type;
+	:fileSize := l_file_size;
+END;
+`;
+	let result = null;
+	try {
+		result = await databaseConnection.execute(sqlStatement, bindParameter);
+	} catch (err) {
+		/* v8 ignore start */
+		if (debug$4.enabled) debug$4(getBlock("procedureDownloadFiles: results", inspect(result)));
+		/* v8 ignore stop */
+		throw new ProcedureError(`procedureDownloadFiles: error when downloading files\n${errorToString(err)}`, {}, sqlStatement, bindParameter);
+	}
+	return z$1.object({
+		fileType: z$1.string().nullable().transform((val) => val ?? ""),
+		fileSize: z$1.number().nullable().transform((val) => val ?? 0),
+		fileBlob: z$1.instanceof(stream.Readable).nullable()
+	}).parse(result.outBinds);
+};
+/**
+* Invoke the Oracle procedure and return the page content
+*
+* @param req - The req object represents the HTTP request.
+* @param res - The res object represents the HTTP response that an Express app sends when it gets an HTTP request.
+* @param argObj - - The arguments of the procedure to invoke.
+* @param cgiObj - The cgi of the procedure to invoke.
+* @param filesToUpload - Array of files to be uploaded
+* @param options - the options for the middleware.
+* @param databaseConnection - Database connection.
+* @param procedureNameCache - The procedure name cache.
+* @param argumentCache - The argument cache.
+* @returns Promise resolving to the page content generated by the executed procedure
+*/
+const invokeProcedure = async (req, res, argObj, cgiObj, filesToUpload, options, databaseConnection, procedureNameCache, argumentCache) => {
+	debug$4("invokeProcedure: begin");
+	const startTime = Date.now();
+	let traceData = null;
+	if (traceManager.isEnabled()) traceData = {
+		id: Math.random().toString(36).substring(2, 15),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		source: cgiObj.REMOTE_ADDR ?? "",
+		url: req.originalUrl,
+		method: req.method,
+		status: "pending",
+		duration: 0,
+		cgi: cgiObj,
+		headers: req.headers,
+		cookies: req.cookies,
+		uploads: filesToUpload.map((f) => ({
+			originalname: f.originalname,
+			mimetype: f.mimetype,
+			size: f.size
+		}))
+	};
+	try {
+		debug$4(`invokeProcedure: upload "${filesToUpload.length}" files`);
+		if (filesToUpload.length > 0) if (typeof options.documentTable === "string" && options.documentTable.length > 0) {
+			const { documentTable } = options;
+			await Promise.all(filesToUpload.map((file) => uploadFile(file, documentTable, databaseConnection)));
+		} else console.warn(`Unable to upload "${filesToUpload.length}" files because the option ""doctable" has not been defined`);
+		debug$4("invokeProcedure: get procedure to execute and the arguments");
+		const rawProcName = Array.isArray(req.params.name) ? req.params.name[0] : req.params.name;
+		if (!rawProcName) throw new RequestError("No procedure name provided");
+		const para = await getProcedure(req, rawProcName, argObj, options, databaseConnection, procedureNameCache, argumentCache);
+		if (traceData) {
+			traceData.procedure = para.resolvedName;
+			traceData.parameters = para.bind;
+		}
+		debug$4("invokeProcedure: prepare the session");
+		await procedurePrepare(cgiObj, databaseConnection);
+		debug$4("invokeProcedure: execute the session");
+		try {
+			await procedureExecute(para, databaseConnection);
+		} catch (err) {
+			if (err instanceof ProcedureError) {
+				const errorString = err.toString();
+				if (errorString.includes("ORA-04068") || errorString.includes("ORA-04061") || errorString.includes("ORA-04065") || errorString.includes("ORA-06550")) {
+					debug$4(`invokeProcedure: detected invalidation error (${errorString}). Clearing caches.`);
+					if (rawProcName) procedureNameCache.delete(rawProcName);
+					if (para.resolvedName) argumentCache.delete(para.resolvedName.toUpperCase());
+				}
+			}
+			throw err;
+		}
+		debug$4("invokeProcedure: get the page returned from the procedure");
+		const streamInstance = new OWAPageStream(databaseConnection);
+		const lines = await streamInstance.fetchChunk();
+		/* v8 ignore start */
+		if (debug$4.enabled) debug$4(getBlock("data", lines.join("")));
+		/* v8 ignore stop */
+		debug$4("invokeProcedure: download files");
+		const fileBlob = await databaseConnection.createLob(BLOB);
+		try {
+			const fileDownload = await procedureDownloadFiles(fileBlob, databaseConnection);
+			/* v8 ignore start */
+			if (debug$4.enabled) debug$4(getBlock("fileDownload", inspect({
+				fileType: fileDownload.fileType,
+				fileSize: fileDownload.fileSize
+			})));
+			/* v8 ignore stop */
+			debug$4("invokeProcedure: parse the page");
+			const pageComponents = parsePage(lines.join(""));
+			pageComponents.head.server = cgiObj.SERVER_SOFTWARE ?? "";
+			if (fileDownload.fileType !== "" && fileDownload.fileSize > 0 && fileDownload.fileBlob !== null) {
+				pageComponents.file.fileType = fileDownload.fileType;
+				pageComponents.file.fileSize = fileDownload.fileSize;
+				pageComponents.file.fileBlob = fileDownload.fileBlob;
+				if (traceData) traceData.downloads = {
+					fileType: fileDownload.fileType,
+					fileSize: fileDownload.fileSize
+				};
+			} else {
+				if (typeof pageComponents.body === "string" && pageComponents.body.length > 0) streamInstance.addBody(pageComponents.body);
+				pageComponents.body = streamInstance;
+				if (traceData) {
+					let htmlBuffer = typeof pageComponents.body === "string" ? pageComponents.body : lines.join("");
+					const MAX_HTML_SIZE = 1024 * 1024;
+					const originalPush = streamInstance.push.bind(streamInstance);
+					streamInstance.push = (chunk) => {
+						if (chunk !== null && htmlBuffer.length < MAX_HTML_SIZE) {
+							htmlBuffer += String(chunk);
+							if (htmlBuffer.length > MAX_HTML_SIZE) htmlBuffer = htmlBuffer.substring(0, MAX_HTML_SIZE) + "... [truncated]";
+						}
+						return originalPush(chunk);
+					};
+					const currentTrace = traceData;
+					streamInstance.on("end", () => {
+						currentTrace.html = htmlBuffer;
+						currentTrace.status = "success";
+						currentTrace.duration = Date.now() - startTime;
+						traceManager.addTrace(currentTrace);
+					});
+					streamInstance.on("error", (err) => {
+						currentTrace.status = "fail";
+						currentTrace.error = err instanceof Error ? err.message : String(err);
+						currentTrace.duration = Date.now() - startTime;
+						traceManager.addTrace(currentTrace);
+					});
+				}
+			}
+			debug$4("invokeProcedure: send the page to browser");
+			await sendResponse(req, res, pageComponents);
+			if (traceData?.downloads) {
+				traceData.status = "success";
+				traceData.duration = Date.now() - startTime;
+				traceManager.addTrace(traceData);
+			}
+		} finally {
+			debug$4("invokeProcedure: cleanup");
+			fileBlob.destroy();
+		}
+	} catch (err) {
+		if (traceData) {
+			traceData.status = err instanceof ProcedureError ? "error" : "fail";
+			traceData.error = err instanceof Error ? err.message : String(err);
+			traceData.duration = Date.now() - startTime;
+			traceManager.addTrace(traceData);
+		}
+		throw err;
+	}
+	debug$4("invokeProcedure: end");
+};
+
+//#endregion
+//#region src/backend/handler/plsql/cgi.ts
+const debug$3 = debugModule("webplsql:cgi");
+const DEFAULT_CGI = {
+	PLSQL_GATEWAY: "WebDb",
+	GATEWAY_IVERSION: "2",
+	SERVER_SOFTWARE: "web_plsql",
+	GATEWAY_INTERFACE: "CGI/1.1",
+	SERVER_PORT: "",
+	SERVER_NAME: os.hostname(),
+	REQUEST_METHOD: "",
+	PATH_INFO: "",
+	SCRIPT_NAME: "",
+	REMOTE_ADDR: "",
+	SERVER_PROTOCOL: "",
+	REQUEST_PROTOCOL: "",
+	REMOTE_USER: "",
+	HTTP_COOKIE: "",
+	HTTP_USER_AGENT: "",
+	HTTP_HOST: "",
+	HTTP_ACCEPT: "",
+	HTTP_ACCEPT_ENCODING: "",
+	HTTP_ACCEPT_LANGUAGE: "",
+	HTTP_REFERER: "",
+	HTTP_X_FORWARDED_FOR: "",
+	WEB_AUTHENT_PREFIX: "",
+	DAD_NAME: "",
+	DOC_ACCESS_PATH: "doc",
+	DOCUMENT_TABLE: "",
+	PATH_ALIAS: "",
+	REQUEST_CHARSET: "UTF8",
+	REQUEST_IANA_CHARSET: "UTF-8",
+	SCRIPT_PREFIX: ""
+};
+/**
+* Create the HTTP_COOKIE string
+*
+* @param req - The req object represents the HTTP request.
+* @returns The string representation of the cookies.
+*/
+const getCookieString = (req) => {
+	let cookieString = "";
+	for (const propName in req.cookies) cookieString += `${propName}=${req.cookies[propName]};`;
+	debug$3("getCookieString", req.cookies, cookieString);
+	return cookieString;
+};
+/**
+* Get the script name and DAD name from a URL
+*
+* @param req - The req object represents the HTTP request.
+* @returns The DAD structure.
+*/
+const getPath = (req) => {
+	const pathname = new URL(`${req.protocol}://${os.hostname()}${req.originalUrl}`).pathname;
+	const tmp = trimPath(pathname.substring(0, pathname.lastIndexOf("/") + 1));
+	return {
+		script: `/${tmp}`,
+		prefix: `/${tmp.substring(0, tmp.lastIndexOf("/"))}`,
+		dad: tmp.substring(tmp.indexOf("/") + 1)
+	};
+};
+/**
+* Get a path that is not enclodes in slashes
+*
+* @param value - The value to trim.
+* @returns The trimmed value.
+*/
+const trimPath = (value) => value.replace(/^\/+|\/+$/g, "");
+/**
+* Create a CGI object
+*
+* @param req - The req object represents the HTTP request.
+* @param doctable - The document table.
+* @param cgi - The additional cgi.
+* @param authenticatedUser - The authenticated user.
+* @returns CGI object
+*/
+const getCGI = (req, doctable, cgi, authenticatedUser = null) => {
+	const PROTOCOL = req.protocol ? req.protocol.toUpperCase() : "";
+	const PATH = getPath(req);
+	const CGI = {
+		SERVER_PORT: typeof req.socket.localPort === "number" ? req.socket.localPort.toString() : "",
+		REQUEST_METHOD: req.method,
+		PATH_INFO: Array.isArray(req.params.name) ? req.params.name[0] ?? "" : req.params.name ?? "",
+		SCRIPT_NAME: PATH.script,
+		REMOTE_ADDR: (req.ip ?? "").replace("::ffff:", ""),
+		SERVER_PROTOCOL: `${PROTOCOL}/${req.httpVersion}`,
+		REQUEST_PROTOCOL: PROTOCOL,
+		REMOTE_USER: authenticatedUser ?? "",
+		AUTH_TYPE: authenticatedUser ? "Basic" : "",
+		HTTP_COOKIE: getCookieString(req),
+		HTTP_USER_AGENT: req.get("user-agent") ?? "",
+		HTTP_HOST: req.get("host") ?? "",
+		HTTP_ACCEPT: req.get("accept") ?? "",
+		HTTP_ACCEPT_ENCODING: req.get("accept-encoding") ?? "",
+		HTTP_ACCEPT_LANGUAGE: req.get("accept-language") ?? "",
+		HTTP_REFERER: req.get("referer") ?? "",
+		HTTP_X_FORWARDED_FOR: req.get("x-forwarded-for") ?? "",
+		DAD_NAME: PATH.dad,
+		DOCUMENT_TABLE: doctable,
+		SCRIPT_PREFIX: PATH.prefix
+	};
+	return Object.assign({}, DEFAULT_CGI, CGI, cgi);
+};
+
+//#endregion
+//#region src/backend/util/type.ts
+/**
+*	Is the given value a string or an array of strings
+*	@param value - The value to check.
+*	@returns True if the value is a string or an array of strings
+*/
+const isStringOrArrayOfString = (value) => typeof value === "string" || Array.isArray(value) && value.every((element) => typeof element === "string");
+
+//#endregion
+//#region src/backend/handler/plsql/request.ts
+const debug$2 = debugModule("webplsql:request");
+/**
+*	Normalize the body by making sure that only "simple" parameters and no nested objects are submitted
+*	@param req - The req object represents the HTTP request.
+*	@returns The normalized body.
+*/
+const normalizeBody = (req) => {
+	const args = {};
+	/* v8 ignore else - body validation */
+	if (typeof req.body === "object" && req.body !== null) {
+		const body = req.body;
+		for (const key in body) {
+			const value = body[key];
+			/* v8 ignore else - type validation */
+			if (isStringOrArrayOfString(value)) args[key] = value;
+			else
+ /* v8 ignore next - invalid body type */
+			throw new RequestError(`The element "${key}" in the body is not a string or an array of strings!\n${util.inspect(req.body, {
+				showHidden: false,
+				depth: null,
+				colors: false
+			})}`);
+		}
+	}
+	return args;
+};
+/**
+* Execute the request
+*
+* @param req - The req object represents the HTTP request.
+* @param res - The res object represents the HTTP response that an Express app sends when it gets an HTTP request.
+* @param options - the options for the middleware.
+* @param connectionPool - The connection pool.
+* @param procedureNameCache - The procedure name cache.
+* @param argumentCache - The argument cache.
+* @param authenticatedUser - The authenticated user identity.
+* @returns Promise resolving to th page
+*/
+const processRequest = async (req, res, options, connectionPool, procedureNameCache, argumentCache, authenticatedUser = null) => {
+	debug$2("processRequest: ENTER");
+	if (typeof req.params.name !== "string") console.warn(`processRequest: WARNING: the req.params.name is not a string but an array of string: ${req.params.name}`);
+	const connection = await connectionPool.getConnection();
+	const cgiObj = getCGI(req, options.documentTable, options.cgi ?? {}, authenticatedUser);
+	debug$2("processRequest: cgiObj=", cgiObj);
+	const filesToUpload = getFiles(req);
+	debug$2("processRequest: filesToUpload=", filesToUpload);
+	const argObj = {};
+	Object.assign(argObj, req.query);
+	filesToUpload.reduce((aggregator, file) => {
+		aggregator[file.fieldname] = file.filename;
+		return aggregator;
+	}, argObj);
+	Object.assign(argObj, normalizeBody(req));
+	debug$2("processRequest: argObj=", argObj);
+	await invokeProcedure(req, res, argObj, cgiObj, filesToUpload, options, connection, procedureNameCache, argumentCache);
+	if (options.transactionMode === "rollback") {
+		debug$2("transactionMode: rollback");
+		await connection.rollback();
+	} else if (typeof options.transactionMode === "function") {
+		debug$2("transactionMode: callback");
+		const procName = Array.isArray(req.params.name) ? req.params.name[0] : req.params.name;
+		const result = options.transactionMode(connection, procName ?? "");
+		debug$2("transactionMode: callback restult", result);
+		if (result && typeof result.then === "function") await result;
+	} else {
+		debug$2("transactionMode: commit");
+		await connection.commit();
+	}
+	await connection.release();
+	debug$2("processRequest: EXIT");
+};
+
+//#endregion
+//#region src/backend/util/jsonLogger.ts
+var JsonLogger = class {
+	stream;
+	constructor(filename = "error.json.log") {
+		this.stream = rotatingFileStream.createStream(filename, {
+			size: JSON_LOG_ROTATION_SIZE,
+			interval: JSON_LOG_ROTATION_INTERVAL,
+			maxFiles: JSON_LOG_MAX_ROTATED_FILES,
+			compress: "gzip"
+		});
+	}
+	/**
+	* Log an entry as NDJSON.
+	* @param entry - The entry to log.
+	*/
+	log(entry) {
+		try {
+			entry.timestamp ??= (/* @__PURE__ */ new Date()).toISOString();
+			const line = JSON.stringify(entry);
+			this.stream.write(line + "\n");
+		} catch (err) {
+			console.error("JsonLogger: Failed to write log", err);
+		}
+	}
+	/**
+	* Close the stream.
+	*/
+	close() {
+		this.stream.end();
+	}
+};
+const jsonLogger = new JsonLogger();
+
+//#endregion
+//#region src/backend/handler/plsql/errorPage.ts
+/**
+*	Get error data
+*	@param req - The req object represents the HTTP request.
+*	@param error - The error.
+*	@returns The output.
+*/
+const getErrorData = (req, error) => {
+	let timestamp = /* @__PURE__ */ new Date();
+	let message = "";
+	let environment = null;
+	let sql = null;
+	let bind = null;
+	if (error instanceof ProcedureError) {
+		timestamp = error.timestamp;
+		message = error.stack ?? "";
+		environment = error.environment;
+		sql = error.sql;
+		bind = error.bind;
+	} else if (error instanceof RequestError) {
+		timestamp = error.timestamp;
+		message = error.stack ?? "";
+	} else if (error instanceof Error) message = errorToString(error);
+	else if (typeof error === "string") message = `${error}\n`;
+	return {
+		type: "error",
+		timestamp,
+		message,
+		req,
+		environment,
+		sql,
+		bind
+	};
+};
+/**
+* Show an error page
+*
+* @param req - The req object represents the HTTP request.
+* @param res - The res object represents the HTTP response that an Express app sends when it gets an HTTP request.
+* @param options - The configuration options.
+* @param error - The error.
+*/
+const errorPage = (req, res, options, error) => {
+	const errorData = getErrorData(req, error);
+	const { html, text } = getFormattedMessage(errorData);
+	logToFile(text);
+	const firstLine = errorData.message.split("\n")[0];
+	jsonLogger.log({
+		timestamp: errorData.timestamp?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
+		type: "error",
+		message: firstLine ?? "",
+		req: {
+			method: req.method,
+			url: req.originalUrl,
+			ip: req.ip ?? "",
+			userAgent: req.get("user-agent") ?? ""
+		},
+		details: {
+			fullMessage: errorData.message,
+			sql: errorData.sql ?? "",
+			bind: errorData.bind,
+			environment: errorData.environment ?? {}
+		}
+	});
+	console.error(text);
+	if (options.errorStyle === "basic") res.status(404).send("Page not found");
+	else res.status(404).send(getHtmlPage(html));
+};
+
+//#endregion
+//#region src/backend/handler/plsql/handlerPlSql.ts
+const debug$1 = debugModule("webplsql:handlerPlSql");
+/**
+* express.Request handler
+* @param req - The req object represents the HTTP request.
+* @param res - The res object represents the HTTP response that an Express app sends when it gets an HTTP request.
+* @param _next - The next function.
+* @param connectionPool - The connection pool.
+* @param options - the options for the middleware.
+* @param procedureNameCache - The procedure name cache.
+* @param argumentCache - The argument cache.
+*/
+const requestHandler = async (req, res, _next, connectionPool, options, procedureNameCache, argumentCache) => {
+	try {
+		let authenticatedUser = null;
+		if (options.auth?.type === "basic") {
+			const b64auth = (req.headers.authorization ?? "").split(" ")[1] ?? "";
+			const [login, password] = Buffer.from(b64auth, "base64").toString().split(":");
+			if (login) authenticatedUser = await options.auth.callback(connectionPool, {
+				username: login,
+				password
+			});
+			if (authenticatedUser === null) {
+				const realm = options.auth.realm ?? "PL/SQL Gateway";
+				res.set("WWW-Authenticate", `Basic realm="${realm}"`);
+				res.status(401).send("Authentication required.");
+				return;
+			}
+		}
+		if (typeof req.params.name !== "string" || req.params.name.length === 0) if (typeof options.defaultPage === "string" && options.defaultPage.length > 0) {
+			const newUrl = url.resolve(`${req.originalUrl}/${options.defaultPage}`, "");
+			debug$1(`Redirect to the url "${newUrl}"`);
+			res.redirect(newUrl);
+		} else errorPage(req, res, options, new RequestError("No procedure name given and no default page has been specified"));
+		else await processRequest(req, res, options, connectionPool, procedureNameCache, argumentCache, authenticatedUser);
+	} catch (err) {
+		errorPage(req, res, options, err);
+	}
+};
+/**
+* Express middleware.
+*
+* @param connectionPool - The connection pool.
+* @param config - The configuration options.
+* @param adminContext - Optional admin context for self-registration and stats tracking.
+* @returns The handler.
+*/
+const handlerWebPlSql = (connectionPool, config, adminContext) => {
+	debug$1("options", config);
+	const procedureNameCache = new Cache();
+	const argumentCache = new Cache();
+	if (adminContext) adminContext.registerHandler(config.route, connectionPool, procedureNameCache, argumentCache);
+	/**
+	* @param req - The request.
+	* @param res - The response.
+	* @param next - The next function.
+	*/
+	const handler = ((req, res, next) => {
+		requestHandler(req, res, next, connectionPool, config, procedureNameCache, argumentCache);
+	});
+	handler.procedureNameCache = procedureNameCache;
+	handler.argumentCache = argumentCache;
+	return handler;
+};
+
+//#endregion
+//#region src/backend/handler/handlerLogger.ts
+const debug = debugModule("webplsql:handlerLogger");
+/**
+* Create the upload middleware.
+* @param filename - Output filename.
+* @returns Request handler.
+*/
+const handlerLogger = (filename) => {
+	debug("register");
+	return morgan("combined", { stream: fs.createWriteStream(path.join(process.cwd(), filename), { flags: "a" }) });
+};
+
+//#endregion
+//#region src/backend/handler/handlerUpload.ts
+/**
+* Create the upload middleware.
+* @param uploadFileSizeLimit - Maximum size of each uploaded file in bytes or no limit if omitted.
+* @returns Request handler.
+*/
+const handlerUpload = (uploadFileSizeLimit) => {
+	return multer({
+		storage: multer.diskStorage({}),
+		limits: { fileSize: uploadFileSizeLimit }
+	}).any();
+};
+
+//#endregion
+//#region src/backend/handler/handlerAdmin.ts
+const version = () => getVersion();
+/**
+* Helper to read last N lines of a file
+* @param filePath - Path to file
+* @param n - Number of lines
+* @param filter - Optional filter string
+* @returns The lines
+*/
+const readLastLines = async (filePath, n = 100, filter = "") => {
+	if (!fs.existsSync(filePath)) return [];
+	const fileStream = fs.createReadStream(filePath);
+	const rl = readline.createInterface({
+		input: fileStream,
+		crlfDelay: Infinity
+	});
+	const filterLower = filter.toLowerCase();
+	const lines = [];
+	for await (const line of rl) if (!filter || line.toLowerCase().includes(filterLower)) {
+		lines.push(line);
+		if (lines.length > n) lines.shift();
+	}
+	return lines;
+};
+/**
+* Create admin API router
+* @param adminContext - The admin context
+* @returns Express router
+*/
+const createAdminRouter = (adminContext) => {
+	const router = express.Router();
+	router.get("/api/status", (req, res) => {
+		const uptime = ((/* @__PURE__ */ new Date()).getTime() - adminContext.startTime.getTime()) / 1e3;
+		const includeHistory = req.query.history === "true";
+		const includeConfig = req.query.config === "true";
+		const poolStats = adminContext.pools.map((pool, index) => {
+			const cache = adminContext.caches[index];
+			const name = cache?.poolName ?? `pool-${index}`;
+			const p = pool;
+			const stats = typeof p.getStatistics === "function" ? p.getStatistics() : null;
+			const procStats = cache?.procedureNameCache.getStats();
+			const argStats = cache?.argumentCache.getStats();
+			return {
+				name,
+				stats,
+				connectionsOpen: pool.connectionsOpen,
+				connectionsInUse: pool.connectionsInUse,
+				cache: {
+					procedureName: {
+						size: cache?.procedureNameCache.keys().length ?? 0,
+						hits: procStats?.hits ?? 0,
+						misses: procStats?.misses ?? 0
+					},
+					argument: {
+						size: cache?.argumentCache.keys().length ?? 0,
+						hits: argStats?.hits ?? 0,
+						misses: argStats?.misses ?? 0
+					}
+				}
+			};
+		});
+		const memUsage = process.memoryUsage();
+		const systemMemoryUsed = os.totalmem() - os.freemem();
+		const cpuUsage = process.cpuUsage();
+		const summary = adminContext.statsManager.getSummary();
+		const history = adminContext.statsManager.getHistory();
+		const historyData = includeHistory ? history : history.slice(-1);
+		res.json({
+			version: version(),
+			status: adminContext.paused ? "paused" : "running",
+			uptime,
+			startTime: adminContext.startTime,
+			intervalMs: adminContext.statsManager.config.intervalMs,
+			metrics: {
+				requestCount: summary.totalRequests,
+				errorCount: summary.totalErrors,
+				avgResponseTime: summary.avgResponseTime,
+				minResponseTime: summary.minResponseTime,
+				maxResponseTime: summary.maxResponseTime,
+				maxRequestsPerSecond: summary.maxRequestsPerSecond
+			},
+			history: historyData,
+			pools: poolStats,
+			system: {
+				nodeVersion: process.version,
+				platform: process.platform,
+				arch: process.arch,
+				cpuCores: os.cpus().length,
+				memory: {
+					rss: systemMemoryUsed,
+					heapTotal: memUsage.heapTotal,
+					heapUsed: memUsage.heapUsed,
+					external: memUsage.external,
+					totalMemory: os.totalmem(),
+					...summary.maxMemory
+				},
+				cpu: {
+					user: cpuUsage.user,
+					system: cpuUsage.system,
+					max: summary.cpu.max,
+					userMax: summary.cpu.userMax,
+					systemMax: summary.cpu.systemMax
+				}
+			},
+			config: includeConfig && adminContext.config ? {
+				...adminContext.config,
+				adminPassword: adminContext.config.adminPassword ? "********" : void 0,
+				routePlSql: adminContext.config.routePlSql.map((p) => {
+					const { auth, transactionMode, cgi, ...rest } = p;
+					return {
+						...rest,
+						password: "********",
+						hasAuth: !!auth,
+						hasTransactionMode: !!transactionMode,
+						hasCgi: !!cgi
+					};
+				})
+			} : void 0
+		});
+	});
+	router.get("/api/stats/history", (req, res) => {
+		const limitQuery = req.query.limit;
+		let limit = 100;
+		if (typeof limitQuery === "string") {
+			const parsed = Number(limitQuery);
+			if (!isNaN(parsed)) limit = parsed;
+		}
+		const history = adminContext.statsManager.getHistory();
+		const slice = limit > 0 ? history.slice(-limit) : [...history];
+		res.json(slice.reverse());
+	});
+	router.get("/api/logs/error", async (req, res) => {
+		try {
+			const parsedLines = (await readLastLines("error.json.log", Number(req.query.limit) || 100, typeof req.query.filter === "string" ? req.query.filter : "")).map((line) => {
+				try {
+					return JSON.parse(line);
+				} catch {
+					return null;
+				}
+			}).filter((l) => l !== null);
+			const logs = z.array(logEntrySchema).safeParse(parsedLines);
+			if (!logs.success) throw new Error(`Validation failed: ${logs.error.message}`);
+			return res.json(logs.data.reverse());
+		} catch (err) {
+			return res.status(500).json({ error: String(err) });
+		}
+	});
+	router.get("/api/logs/access", async (req, res) => {
+		try {
+			const limit = Number(req.query.limit) || 100;
+			const filter = typeof req.query.filter === "string" ? req.query.filter : "";
+			const logFile = adminContext.config?.loggerFilename ?? "access.log";
+			if (!adminContext.config?.loggerFilename) {
+				res.json({ message: "Access logging not enabled" });
+				return;
+			}
+			const lines = await readLastLines(logFile, limit, filter);
+			res.json(lines.reverse());
+		} catch (err) {
+			res.status(500).json({ error: String(err) });
+		}
+	});
+	router.post("/api/cache/clear", (req, res) => {
+		const body = req.body;
+		const poolName = typeof body?.poolName === "string" ? body.poolName : void 0;
+		let cleared = 0;
+		adminContext.caches.forEach((c) => {
+			if (!poolName || c.poolName === poolName) {
+				c.procedureNameCache.clear();
+				cleared++;
+				c.argumentCache.clear();
+				cleared++;
+			}
+		});
+		res.json({ message: `Cleared ${cleared} caches` });
+	});
+	router.post("/api/server/:action", (req, res) => {
+		const action = req.params.action;
+		if (action === "stop") {
+			res.json({ message: "Server shutting down..." });
+			setTimeout(() => {
+				forceShutdown();
+			}, SHUTDOWN_GRACE_DELAY_MS);
+		} else if (action === "pause") {
+			adminContext.setPaused(true);
+			res.json({
+				message: "Server paused",
+				status: "paused"
+			});
+		} else if (action === "resume") {
+			adminContext.setPaused(false);
+			res.json({
+				message: "Server resumed",
+				status: "running"
+			});
+		} else res.status(400).json({ error: "Invalid action" });
+	});
+	router.get("/api/trace/status", (_req, res) => {
+		res.json({ enabled: traceManager.isEnabled() });
+	});
+	router.post("/api/trace/toggle", (req, res) => {
+		const body = req.body;
+		const enabled = typeof body?.enabled === "boolean" ? body.enabled : false;
+		traceManager.setEnabled(enabled);
+		res.json({ enabled: traceManager.isEnabled() });
+	});
+	router.get("/api/trace/logs", async (req, res) => {
+		try {
+			const limit = Number(req.query.limit) || 100;
+			const filter = typeof req.query.filter === "string" ? req.query.filter : "";
+			const parsedLines = (await readLastLines(traceManager.getFilePath(), limit, filter)).map((line) => {
+				try {
+					return JSON.parse(line);
+				} catch {
+					return null;
+				}
+			}).filter((l) => l !== null);
+			const logs = z.array(procedureTraceEntrySchema).safeParse(parsedLines);
+			if (!logs.success) throw new Error(`Validation failed: ${logs.error.message}`);
+			return res.json(logs.data.reverse());
+		} catch (err) {
+			return res.status(500).json({ error: String(err) });
+		}
+	});
+	router.post("/api/trace/clear", (_req, res) => {
+		traceManager.clear();
+		res.json({ message: "Traces cleared" });
+	});
+	return router;
+};
+
+//#endregion
+//#region src/backend/handler/handlerAdminConsole.ts
+/**
+* Resolves the admin console static directory by walking up from the current module
+* to find the project root (identified by package.json), then returns dist/frontend path.
+* @returns Path to dist/frontend directory
+* @throws {Error} if project root cannot be found
+*/
+const resolveAdminStaticDir = () => {
+	const __filename = fileURLToPath(import.meta.url);
+	let projectRoot = path.dirname(__filename);
+	while (!existsSync(path.join(projectRoot, "package.json")) && projectRoot !== "/") projectRoot = path.dirname(projectRoot);
+	if (projectRoot === "/") throw new Error("Could not find project root (package.json). Please provide explicit staticDir in AdminConsoleConfig.");
+	return path.join(projectRoot, "dist", "frontend");
+};
+/**
+* Creates the admin console middleware.
+* @param config - The admin console configuration.
+* @param adminContext - The admin context.
+* @returns The express request handler.
+*/
+const handlerAdminConsole = (config, adminContext) => {
+	const adminRoute = config.adminRoute ?? "/admin";
+	const resolvedStaticDir = config.staticDir ?? resolveAdminStaticDir();
+	if (adminRoute && !adminRoute.startsWith("/")) throw new Error("adminRoute must start with /");
+	if (!config.devMode && !existsSync(resolvedStaticDir)) throw new Error(`Admin console not built. Run 'npm run build:frontend' first.\nExpected: ${resolvedStaticDir}`);
+	const originalRotate = adminContext.statsManager.rotateBucket.bind(adminContext.statsManager);
+	adminContext.statsManager.rotateBucket = () => {
+		originalRotate(adminContext.pools.map((pool, index) => {
+			const cache = adminContext.caches[index];
+			const name = cache?.poolName ?? `pool-${index}`;
+			const procStats = cache?.procedureNameCache.getStats();
+			const argStats = cache?.argumentCache.getStats();
+			return {
+				name,
+				connectionsOpen: pool.connectionsOpen,
+				connectionsInUse: pool.connectionsInUse,
+				cache: {
+					procedureName: {
+						size: cache?.procedureNameCache.keys().length ?? 0,
+						hits: procStats?.hits ?? 0,
+						misses: procStats?.misses ?? 0
+					},
+					argument: {
+						size: cache?.argumentCache.keys().length ?? 0,
+						hits: argStats?.hits ?? 0,
+						misses: argStats?.misses ?? 0
+					}
+				}
+			};
+		}));
+	};
+	const router = Router();
+	router.use((req, res, next) => {
+		if (adminContext.paused && !req.path.startsWith(adminRoute)) {
+			res.status(503).send("Server Paused");
+			return;
+		}
+		next();
+	});
+	router.use(adminRoute, (req, res, next) => {
+		const baseUrl = req.baseUrl || "";
+		const [path] = req.originalUrl.split("?");
+		if (path === baseUrl) {
+			const query = req.originalUrl.split("?")[1];
+			return res.redirect(baseUrl + "/" + (query ? "?" + query : ""));
+		}
+		next();
+	});
+	if (config.user && config.password) router.use(adminRoute, (req, res, next) => {
+		const b64auth = (req.headers.authorization ?? "").split(" ")[1] ?? "";
+		const [login, password] = Buffer.from(b64auth, "base64").toString().split(":");
+		if (login !== config.user || password !== config.password) {
+			res.set("WWW-Authenticate", "Basic realm=\"Admin Console\"");
+			res.status(401).send("Authentication required.");
+			return;
+		}
+		next();
+	});
+	router.use(adminRoute, createAdminRouter(adminContext));
+	if (existsSync(resolvedStaticDir)) router.use(adminRoute, expressStaticGzip(resolvedStaticDir, {
+		enableBrotli: true,
+		orderPreference: ["br"]
+	}));
+	return router;
+};
+
+//#endregion
+//#region src/backend/handler/handlerSpaFallback.ts
+/**
+* Creates middleware that serves index.html for SPA routes.
+*
+* Handles React Router (createBrowserRouter), Vue Router, Angular Router, etc.
+*
+* **CRITICAL**: This middleware MUST be mounted AFTER express-static-gzip.
+*
+* Middleware order:
+* 1. express-static-gzip → Serves actual files (CSS, JS, images)
+* 2. handlerSpaFallback → Serves index.html for navigation requests
+*
+* @param directoryPath - Path to the static directory containing index.html
+* @param _route - The route prefix (for debugging)
+* @returns Express request handler
+*
+* @example
+* ```typescript
+* app.use('/app', expressStaticGzip('./build'));
+* app.use('/app', createSpaFallback('./build', '/app'));
+* ```
+*/
+const createSpaFallback = (directoryPath, _route) => {
+	const indexPath = path.join(directoryPath, "index.html");
+	return (req, res, next) => {
+		if (req.method !== "GET" && req.method !== "HEAD") return next();
+		const accept = req.headers.accept ?? "";
+		if (accept && !accept.includes("text/html") && !accept.includes("*/*")) return next();
+		res.sendFile(indexPath, (err) => {
+			if (err) next(err);
+		});
+	};
+};
+
+//#endregion
+export { AdminContext, createAdminRouter, createServer, createSpaFallback, forceShutdown, getJsonFile, getVersion, handlerAdminConsole, handlerLogger, handlerUpload, handlerWebPlSql, installShutdown, isDirectory, isFile, loadConfig, oracledb_provider_exports as oracledb, readFile, readFileSyncUtf8, removeFile, showConfig, startServer, startServerConfig, z$configType };
+//# sourceMappingURL=index.mjs.map