od-temp 1.0.5 → 1.0.6

package/dist/index.js

@@ -40,14 +40,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 //#endregion
-const require_document = require('./document-C4T2JLdu.js');
-const require_workers = require('./workers-BmzAqLSu.js');
-const require_HealthCheck = require('./HealthCheck-CFX1wPqE.js');
 let crypto = require("crypto");
 let fs = require("fs");
 fs = __toESM(fs);
 let path = require("path");
 path = __toESM(path);
+let worker_threads = require("worker_threads");
+let os = require("os");
 let react = require("react");
 
 //#region src/audit/AuditLogger.ts
@@ -15754,6 +15753,1961 @@ var init_ConfigExporter = __esmMin((() => {
 	};
 }));
 
+//#endregion
+//#region src/health/HealthCheck.ts
+var HealthCheck_exports = /* @__PURE__ */ __exportAll({
+	HealthChecker: () => HealthChecker,
+	createHealthChecker: () => createHealthChecker,
+	healthCheckMiddleware: () => healthCheckMiddleware
+});
+/**
+* Create health checker for a detector
+*/
+function createHealthChecker(detector) {
+	return new HealthChecker(detector);
+}
+/**
+* Express middleware for health check endpoint
+*/
+function healthCheckMiddleware(detector) {
+	const checker = new HealthChecker(detector);
+	return async (_req, res) => {
+		try {
+			const result = await checker.check({
+				testDetection: true,
+				checkPerformance: true,
+				performanceThreshold: 100,
+				memoryThreshold: 100
+			});
+			const statusCode = result.status === "healthy" ? 200 : result.status === "degraded" ? 200 : 503;
+			res.status(statusCode).json(result);
+		} catch (error) {
+			res.status(503).json({
+				status: "unhealthy",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				error: error.message
+			});
+		}
+	};
+}
+var HealthChecker;
+var init_HealthCheck = __esmMin((() => {
+	HealthChecker = class {
+		constructor(detector) {
+			this.detector = detector;
+			this.initTime = Date.now();
+		}
+		/**
+		* Run complete health check
+		*/
+		async check(options = {}) {
+			const result = {
+				status: "healthy",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				checks: {
+					detector: {
+						status: "pass",
+						message: "Detector initialized"
+					},
+					patterns: {
+						status: "pass",
+						message: "Patterns loaded"
+					},
+					performance: {
+						status: "pass",
+						message: "Performance acceptable"
+					},
+					memory: {
+						status: "pass",
+						message: "Memory usage normal"
+					}
+				},
+				metrics: {
+					totalPatterns: 0,
+					compiledPatterns: 0,
+					cacheEnabled: false,
+					uptime: Date.now() - this.initTime
+				},
+				errors: [],
+				warnings: []
+			};
+			try {
+				result.checks.detector = await this.checkDetector(options);
+				result.checks.patterns = await this.checkPatterns();
+				if (options.checkPerformance !== false) result.checks.performance = await this.checkPerformance(options.performanceThreshold);
+				result.checks.memory = await this.checkMemory(options.memoryThreshold);
+				result.metrics = this.collectMetrics();
+				result.status = this.determineOverallStatus(result.checks);
+				for (const check of Object.values(result.checks)) if (check.status === "fail") result.errors.push(check.message);
+				else if (check.status === "warn") result.warnings.push(check.message);
+			} catch (error) {
+				result.status = "unhealthy";
+				result.errors.push(`Health check failed: ${error.message}`);
+			}
+			return result;
+		}
+		/**
+		* Check detector functionality
+		*/
+		async checkDetector(options) {
+			try {
+				if (options.testDetection !== false) {
+					const result = await this.detector.detect("Test email: test@example.com");
+					if (!result || !result.detections) return {
+						status: "fail",
+						message: "Detector returned invalid result"
+					};
+					if (result.detections.length === 0) return {
+						status: "warn",
+						message: "Test detection found no PII (expected at least 1)"
+					};
+				}
+				return {
+					status: "pass",
+					message: "Detector functioning correctly"
+				};
+			} catch (error) {
+				return {
+					status: "fail",
+					message: `Detector check failed: ${error.message}`
+				};
+			}
+		}
+		/**
+		* Check patterns are loaded
+		*/
+		async checkPatterns() {
+			try {
+				const patterns = this.detector.getPatterns();
+				if (!patterns || patterns.length === 0) return {
+					status: "fail",
+					message: "No patterns loaded",
+					value: 0,
+					threshold: 1
+				};
+				if (patterns.length < 10) return {
+					status: "warn",
+					message: "Very few patterns loaded (expected more)",
+					value: patterns.length,
+					threshold: 10
+				};
+				return {
+					status: "pass",
+					message: `${patterns.length} patterns loaded`,
+					value: patterns.length
+				};
+			} catch (error) {
+				return {
+					status: "fail",
+					message: `Pattern check failed: ${error.message}`
+				};
+			}
+		}
+		/**
+		* Check performance
+		*/
+		async checkPerformance(threshold = 100) {
+			try {
+				const testText = "Test: john@example.com, phone: 555-123-4567, IP: 192.168.1.1";
+				const start = performance.now();
+				await this.detector.detect(testText);
+				const duration = performance.now() - start;
+				if (duration > threshold * 2) return {
+					status: "fail",
+					message: `Performance degraded: ${duration.toFixed(2)}ms`,
+					value: duration,
+					threshold
+				};
+				if (duration > threshold) return {
+					status: "warn",
+					message: `Performance slower than expected: ${duration.toFixed(2)}ms`,
+					value: duration,
+					threshold
+				};
+				return {
+					status: "pass",
+					message: `Performance good: ${duration.toFixed(2)}ms`,
+					value: duration,
+					threshold
+				};
+			} catch (error) {
+				return {
+					status: "fail",
+					message: `Performance check failed: ${error.message}`
+				};
+			}
+		}
+		/**
+		* Check memory usage
+		*/
+		async checkMemory(threshold = 100) {
+			try {
+				if (typeof process === "undefined" || !process.memoryUsage) return {
+					status: "pass",
+					message: "Memory check skipped (not in Node.js)"
+				};
+				const heapUsedMB = process.memoryUsage().heapUsed / 1024 / 1024;
+				if (heapUsedMB > threshold * 2) return {
+					status: "fail",
+					message: `High memory usage: ${heapUsedMB.toFixed(2)}MB`,
+					value: heapUsedMB,
+					threshold
+				};
+				if (heapUsedMB > threshold) return {
+					status: "warn",
+					message: `Elevated memory usage: ${heapUsedMB.toFixed(2)}MB`,
+					value: heapUsedMB,
+					threshold
+				};
+				return {
+					status: "pass",
+					message: `Memory usage normal: ${heapUsedMB.toFixed(2)}MB`,
+					value: heapUsedMB,
+					threshold
+				};
+			} catch (error) {
+				return {
+					status: "warn",
+					message: `Memory check skipped: ${error.message}`
+				};
+			}
+		}
+		/**
+		* Collect metrics
+		*/
+		collectMetrics() {
+			const patterns = this.detector.getPatterns();
+			const cacheStats = this.detector.getCacheStats();
+			return {
+				totalPatterns: patterns.length,
+				compiledPatterns: patterns.length,
+				cacheSize: cacheStats.size,
+				cacheEnabled: cacheStats.enabled,
+				uptime: Date.now() - this.initTime
+			};
+		}
+		/**
+		* Determine overall status
+		*/
+		determineOverallStatus(checks) {
+			const statuses = Object.values(checks).map((c) => c.status);
+			if (statuses.includes("fail")) return "unhealthy";
+			if (statuses.includes("warn")) return "degraded";
+			return "healthy";
+		}
+		/**
+		* Quick health check (minimal overhead)
+		*/
+		async quickCheck() {
+			try {
+				if (this.detector.getPatterns().length === 0) return {
+					status: "unhealthy",
+					message: "No patterns loaded"
+				};
+				return {
+					status: "healthy",
+					message: "OK"
+				};
+			} catch (error) {
+				return {
+					status: "unhealthy",
+					message: `Error: ${error.message}`
+				};
+			}
+		}
+		/**
+		* Get system info for debugging
+		*/
+		getSystemInfo() {
+			const patterns = this.detector.getPatterns();
+			const cacheStats = this.detector.getCacheStats();
+			return {
+				version: "1.0.0",
+				patterns: {
+					total: patterns.length,
+					types: [...new Set(patterns.map((p) => p.type.split("_")[0]))].length
+				},
+				cache: {
+					enabled: cacheStats.enabled,
+					size: cacheStats.size,
+					maxSize: cacheStats.maxSize
+				},
+				uptime: Date.now() - this.initTime,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		}
+	};
+}));
+
+//#endregion
+//#region src/document/OCRProcessor.ts
+/**
+* Create an OCR processor instance
+*/
+function createOCRProcessor() {
+	return new OCRProcessor();
+}
+var OCRProcessor;
+var init_OCRProcessor = __esmMin((() => {
+	OCRProcessor = class {
+		constructor() {
+			try {
+				this.tesseract = require("tesseract.js");
+			} catch {}
+		}
+		/**
+		* Extract text from image buffer using OCR
+		*/
+		async recognizeText(buffer, options) {
+			if (!this.tesseract) throw new Error("[OCRProcessor] OCR support requires tesseract.js. Install with: npm install tesseract.js");
+			const startTime = performance.now();
+			try {
+				const language = Array.isArray(options?.language) ? options.language.join("+") : options?.language || "eng";
+				const worker = await this.tesseract.createWorker(language, options?.oem || 3);
+				if (options?.psm !== void 0) await worker.setParameters({ tessedit_pageseg_mode: options.psm });
+				const result = await worker.recognize(buffer);
+				await worker.terminate();
+				const endTime = performance.now();
+				const processingTime = Math.round((endTime - startTime) * 100) / 100;
+				return {
+					text: result.data.text || "",
+					confidence: result.data.confidence || 0,
+					processingTime
+				};
+			} catch (error) {
+				throw new Error(`[OCRProcessor] OCR recognition failed: ${error.message}`);
+			}
+		}
+		/**
+		* Check if OCR is available (tesseract.js installed)
+		*/
+		isAvailable() {
+			return !!this.tesseract;
+		}
+		/**
+		* Create a scheduler for batch OCR processing
+		* More efficient for processing multiple images
+		*/
+		async createScheduler(workerCount = 4) {
+			if (!this.tesseract) throw new Error("[OCRProcessor] OCR support requires tesseract.js. Install with: npm install tesseract.js");
+			if (this.scheduler) await this.scheduler.terminate();
+			this.scheduler = this.tesseract.createScheduler();
+			const workers = [];
+			for (let i = 0; i < workerCount; i++) {
+				const worker = await this.tesseract.createWorker("eng");
+				this.scheduler.addWorker(worker);
+				workers.push(worker);
+			}
+			return this.scheduler;
+		}
+		/**
+		* Batch process multiple images
+		*/
+		async recognizeBatch(buffers, _options) {
+			if (!this.tesseract) throw new Error("[OCRProcessor] OCR support requires tesseract.js. Install with: npm install tesseract.js");
+			const scheduler = await this.createScheduler();
+			try {
+				const results = await Promise.all(buffers.map(async (buffer) => {
+					const startTime = performance.now();
+					const result = await scheduler.addJob("recognize", buffer);
+					const endTime = performance.now();
+					return {
+						text: result.data.text || "",
+						confidence: result.data.confidence || 0,
+						processingTime: Math.round((endTime - startTime) * 100) / 100
+					};
+				}));
+				await scheduler.terminate();
+				this.scheduler = void 0;
+				return results;
+			} catch (error) {
+				if (scheduler) {
+					await scheduler.terminate();
+					this.scheduler = void 0;
+				}
+				throw new Error(`[OCRProcessor] Batch OCR failed: ${error.message}`);
+			}
+		}
+		/**
+		* Terminate any running scheduler
+		*/
+		async cleanup() {
+			if (this.scheduler) {
+				await this.scheduler.terminate();
+				this.scheduler = void 0;
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region src/document/JsonProcessor.ts
+/**
+* Create a JSON processor instance
+*/
+function createJsonProcessor() {
+	return new JsonProcessor();
+}
+var JsonProcessor;
+var init_JsonProcessor = __esmMin((() => {
+	JsonProcessor = class {
+		constructor() {
+			this.defaultOptions = {
+				maxDepth: 100,
+				scanKeys: false,
+				alwaysRedact: [],
+				skipPaths: [],
+				piiIndicatorKeys: [
+					"email",
+					"e-mail",
+					"mail",
+					"phone",
+					"tel",
+					"telephone",
+					"mobile",
+					"ssn",
+					"social_security",
+					"address",
+					"street",
+					"city",
+					"zip",
+					"postal",
+					"name",
+					"firstname",
+					"lastname",
+					"fullname",
+					"password",
+					"pwd",
+					"secret",
+					"token",
+					"key",
+					"card",
+					"credit_card",
+					"creditcard",
+					"account",
+					"iban",
+					"swift",
+					"passport",
+					"license",
+					"licence"
+				],
+				preserveStructure: true
+			};
+		}
+		/**
+		* Parse JSON from buffer or string
+		*/
+		parse(input) {
+			try {
+				const text = typeof input === "string" ? input : input.toString("utf-8");
+				return JSON.parse(text);
+			} catch (error) {
+				throw new Error(`[JsonProcessor] Invalid JSON: ${error.message}`);
+			}
+		}
+		/**
+		* Detect PII in JSON data
+		*/
+		async detect(data, detector, options) {
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const pathsDetected = [];
+			const matchesByPath = {};
+			const allDetections = [];
+			const promises = [];
+			this.traverse(data, "", opts, (path, value, key) => {
+				promises.push((async () => {
+					if (this.shouldSkip(path, opts.skipPaths)) return;
+					if (this.shouldAlwaysRedact(path, opts.alwaysRedact)) {
+						const detection = {
+							type: "SENSITIVE_FIELD",
+							value: String(value),
+							placeholder: `[SENSITIVE_FIELD]`,
+							position: [0, String(value).length],
+							severity: "high",
+							confidence: 1
+						};
+						matchesByPath[path] = [detection];
+						pathsDetected.push(path);
+						allDetections.push(detection);
+						return;
+					}
+					if (opts.scanKeys && key) {
+						const keyResult = await detector.detect(key);
+						if (keyResult.detections.length > 0) {
+							const keyPath = `${path}.__key__`;
+							matchesByPath[keyPath] = keyResult.detections;
+							pathsDetected.push(keyPath);
+							allDetections.push(...keyResult.detections);
+						}
+					}
+					const valueStr = String(value);
+					const result = await detector.detect(valueStr);
+					if (result.detections.length > 0) {
+						const boostedDetections = this.boostConfidenceFromKey(result.detections, key, opts.piiIndicatorKeys);
+						matchesByPath[path] = boostedDetections;
+						pathsDetected.push(path);
+						allDetections.push(...boostedDetections);
+					}
+				})());
+			});
+			await Promise.all(promises);
+			const original = JSON.stringify(data);
+			const redacted = this.redact(data, {
+				original,
+				redacted: original,
+				detections: allDetections,
+				redactionMap: {},
+				stats: { piiCount: allDetections.length },
+				pathsDetected,
+				matchesByPath
+			}, opts);
+			const redactionMap = {};
+			allDetections.forEach((det) => {
+				redactionMap[det.placeholder] = det.value;
+			});
+			return {
+				original,
+				redacted: typeof redacted === "string" ? redacted : JSON.stringify(redacted),
+				detections: allDetections,
+				redactionMap,
+				stats: { piiCount: allDetections.length },
+				pathsDetected,
+				matchesByPath
+			};
+		}
+		/**
+		* Redact PII in JSON data
+		*/
+		redact(data, detectionResult, options) {
+			if (!{
+				...this.defaultOptions,
+				...options
+			}.preserveStructure) return this.parse(this.redactText(JSON.stringify(data, null, 2), detectionResult));
+			return this.redactPreservingStructure(data, detectionResult.pathsDetected);
+		}
+		/**
+		* Redact specific paths in JSON while preserving structure
+		*/
+		redactPreservingStructure(data, pathsToRedact) {
+			const pathSet = new Set(pathsToRedact);
+			const redactValue = (value, currentPath) => {
+				if (pathSet.has(currentPath)) {
+					if (typeof value === "string") return "[REDACTED]";
+					else if (typeof value === "number") return 0;
+					else if (typeof value === "boolean") return false;
+					else if (value === null) return null;
+					else if (Array.isArray(value)) return [];
+					else if (typeof value === "object") return {};
+					return "[REDACTED]";
+				}
+				if (Array.isArray(value)) return value.map((item, index) => redactValue(item, `${currentPath}[${index}]`));
+				if (value !== null && typeof value === "object") {
+					const result = {};
+					for (const [key, val] of Object.entries(value)) result[key] = redactValue(val, currentPath ? `${currentPath}.${key}` : key);
+					return result;
+				}
+				return value;
+			};
+			return redactValue(data, "");
+		}
+		/**
+		* Simple text-based redaction (fallback)
+		*/
+		redactText(text, detectionResult) {
+			let redacted = text;
+			const sortedDetections = [...detectionResult.detections].sort((a, b) => b.position[0] - a.position[0]);
+			for (const detection of sortedDetections) {
+				const [start, end] = detection.position;
+				redacted = redacted.slice(0, start) + detection.placeholder + redacted.slice(end);
+			}
+			return redacted;
+		}
+		/**
+		* Traverse JSON structure and call callback for each value
+		*/
+		traverse(obj, path, options, callback, depth = 0) {
+			if (depth > options.maxDepth) throw new Error(`[JsonProcessor] Maximum depth (${options.maxDepth}) exceeded`);
+			if (obj === null || obj === void 0) return;
+			if (Array.isArray(obj)) {
+				obj.forEach((item, index) => {
+					const itemPath = path ? `${path}[${index}]` : `[${index}]`;
+					if (this.isPrimitive(item)) callback(itemPath, item);
+					this.traverse(item, itemPath, options, callback, depth + 1);
+				});
+				return;
+			}
+			if (typeof obj === "object") {
+				for (const [key, value] of Object.entries(obj)) {
+					const valuePath = path ? `${path}.${key}` : key;
+					if (this.isPrimitive(value)) callback(valuePath, value, key);
+					this.traverse(value, valuePath, options, callback, depth + 1);
+				}
+				return;
+			}
+			if (this.isPrimitive(obj)) callback(path, obj);
+		}
+		/**
+		* Check if value is primitive (string, number, boolean)
+		*/
+		isPrimitive(value) {
+			return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+		}
+		/**
+		* Check if path should be skipped
+		*/
+		shouldSkip(path, skipPaths) {
+			return skipPaths.some((skipPath) => {
+				if (path === skipPath) return true;
+				return new RegExp("^" + skipPath.replace(/\*/g, "[^.]+") + "$").test(path);
+			});
+		}
+		/**
+		* Check if path should always be redacted
+		*/
+		shouldAlwaysRedact(path, alwaysRedact) {
+			return alwaysRedact.some((redactPath) => {
+				if (path === redactPath) return true;
+				return new RegExp("^" + redactPath.replace(/\*/g, "[^.]+") + "$").test(path);
+			});
+		}
+		/**
+		* Boost confidence if key name indicates PII
+		*/
+		boostConfidenceFromKey(detections, key, piiIndicatorKeys) {
+			if (!key) return detections;
+			const keyLower = key.toLowerCase();
+			if (!piiIndicatorKeys.some((indicator) => keyLower.includes(indicator.toLowerCase()))) return detections;
+			return detections.map((detection) => ({
+				...detection,
+				confidence: Math.min(1, (detection.confidence || .5) * 1.2)
+			}));
+		}
+		/**
+		* Extract all text values from JSON for simple text-based detection
+		*/
+		extractText(data, options) {
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const textParts = [];
+			this.traverse(data, "", opts, (_path, value, key) => {
+				if (opts.scanKeys && key) textParts.push(key);
+				if (typeof value === "string") textParts.push(value);
+			});
+			return textParts.join(" ");
+		}
+		/**
+		* Validate JSON buffer/string
+		*/
+		isValid(input) {
+			try {
+				this.parse(input);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		/**
+		* Get JSON Lines (JSONL) support - split by newlines and parse each line
+		*/
+		parseJsonLines(input) {
+			return (typeof input === "string" ? input : input.toString("utf-8")).split("\n").filter((line) => line.trim().length > 0).map((line, index) => {
+				try {
+					return JSON.parse(line);
+				} catch (error) {
+					throw new Error(`[JsonProcessor] Invalid JSON at line ${index + 1}: ${error.message}`);
+				}
+			});
+		}
+		/**
+		* Detect PII in JSON Lines format
+		*/
+		async detectJsonLines(input, detector, options) {
+			const documents = this.parseJsonLines(input);
+			return Promise.all(documents.map((doc) => this.detect(doc, detector, options)));
+		}
+	};
+}));
+
+//#endregion
+//#region src/document/CsvProcessor.ts
+/**
+* Create a CSV processor instance
+*/
+function createCsvProcessor() {
+	return new CsvProcessor();
+}
+var CsvProcessor;
+var init_CsvProcessor = __esmMin((() => {
+	CsvProcessor = class {
+		constructor() {
+			this.defaultOptions = {
+				quote: "\"",
+				escape: "\"",
+				skipEmptyLines: true,
+				piiIndicatorNames: [
+					"email",
+					"e-mail",
+					"mail",
+					"email_address",
+					"phone",
+					"tel",
+					"telephone",
+					"mobile",
+					"phone_number",
+					"ssn",
+					"social_security",
+					"social_security_number",
+					"address",
+					"street",
+					"street_address",
+					"city",
+					"zip",
+					"zipcode",
+					"postal",
+					"postcode",
+					"name",
+					"firstname",
+					"first_name",
+					"lastname",
+					"last_name",
+					"fullname",
+					"full_name",
+					"password",
+					"pwd",
+					"secret",
+					"token",
+					"api_key",
+					"card",
+					"credit_card",
+					"creditcard",
+					"card_number",
+					"account",
+					"account_number",
+					"iban",
+					"swift",
+					"passport",
+					"passport_number",
+					"license",
+					"licence",
+					"driver_license",
+					"dob",
+					"date_of_birth",
+					"birth_date",
+					"birthdate"
+				],
+				treatFirstRowAsHeader: true
+			};
+		}
+		/**
+		* Parse CSV from buffer or string
+		*/
+		parse(input, options) {
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const text = typeof input === "string" ? input : input.toString("utf-8");
+			const delimiter = opts.delimiter || this.detectDelimiter(text);
+			const lines = text.split(/\r?\n/);
+			const rows = [];
+			let rowIndex = 0;
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i];
+				if (opts.skipEmptyLines && line.trim().length === 0) continue;
+				if (opts.maxRows !== void 0 && rowIndex >= opts.maxRows) break;
+				const values = this.parseRow(line, delimiter, opts.quote, opts.escape);
+				rows.push({
+					index: rowIndex,
+					values
+				});
+				rowIndex++;
+			}
+			return rows;
+		}
+		/**
+		* Detect PII in CSV data
+		*/
+		async detect(input, detector, options) {
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const rows = this.parse(input, options);
+			if (rows.length === 0) {
+				const original = typeof input === "string" ? input : input.toString("utf-8");
+				return {
+					original,
+					redacted: original,
+					detections: [],
+					redactionMap: {},
+					stats: { piiCount: 0 },
+					rowCount: 0,
+					columnCount: 0,
+					columnStats: {},
+					matchesByCell: []
+				};
+			}
+			const hasHeader = opts.hasHeader !== void 0 ? opts.hasHeader : this.detectHeader(rows);
+			const headers = hasHeader && rows.length > 0 ? rows[0].values : void 0;
+			const dataRows = hasHeader ? rows.slice(1) : rows;
+			const columnCount = rows[0].values.length;
+			const columnNameToIndex = /* @__PURE__ */ new Map();
+			if (headers) headers.forEach((header, index) => {
+				columnNameToIndex.set(header.toLowerCase().trim(), index);
+			});
+			const alwaysRedactCols = new Set(opts.alwaysRedactColumns || []);
+			if (opts.alwaysRedactColumnNames && headers) opts.alwaysRedactColumnNames.forEach((name) => {
+				const index = columnNameToIndex.get(name.toLowerCase().trim());
+				if (index !== void 0) alwaysRedactCols.add(index);
+			});
+			const skipCols = new Set(opts.skipColumns || []);
+			const columnStats = {};
+			const matchesByCell = [];
+			const allDetections = [];
+			for (let col = 0; col < columnCount; col++) columnStats[col] = {
+				columnIndex: col,
+				columnName: headers?.[col],
+				piiCount: 0,
+				piiPercentage: 0,
+				piiTypes: []
+			};
+			for (const row of dataRows) for (let col = 0; col < row.values.length; col++) {
+				if (skipCols.has(col)) continue;
+				const cellValue = row.values[col];
+				if (alwaysRedactCols.has(col)) {
+					const detection = {
+						type: "SENSITIVE_COLUMN",
+						value: cellValue,
+						placeholder: `[SENSITIVE_COLUMN_${col}]`,
+						position: [0, cellValue.length],
+						severity: "high",
+						confidence: 1
+					};
+					matchesByCell.push({
+						row: row.index,
+						column: col,
+						columnName: headers?.[col],
+						value: cellValue,
+						matches: [detection]
+					});
+					allDetections.push(detection);
+					columnStats[col].piiCount++;
+					continue;
+				}
+				const result = await detector.detect(cellValue);
+				if (result.detections.length > 0) {
+					const boostedDetections = this.boostConfidenceFromColumnName(result.detections, headers?.[col], opts.piiIndicatorNames || []);
+					matchesByCell.push({
+						row: row.index,
+						column: col,
+						columnName: headers?.[col],
+						value: cellValue,
+						matches: boostedDetections
+					});
+					allDetections.push(...boostedDetections);
+					columnStats[col].piiCount += boostedDetections.length;
+					const columnTypes = new Set(columnStats[col].piiTypes);
+					boostedDetections.forEach((d) => columnTypes.add(d.type));
+					columnStats[col].piiTypes = Array.from(columnTypes);
+				}
+			}
+			for (let col = 0; col < columnCount; col++) {
+				const rowsWithPii = matchesByCell.filter((m) => m.column === col).length;
+				columnStats[col].piiPercentage = dataRows.length > 0 ? rowsWithPii / dataRows.length * 100 : 0;
+			}
+			const original = typeof input === "string" ? input : input.toString("utf-8");
+			const redacted = this.redact(original, {
+				original,
+				redacted: original,
+				detections: allDetections,
+				redactionMap: {},
+				stats: { piiCount: allDetections.length },
+				rowCount: dataRows.length,
+				columnCount,
+				headers,
+				columnStats,
+				matchesByCell
+			}, opts);
+			const redactionMap = {};
+			allDetections.forEach((det) => {
+				redactionMap[det.placeholder] = det.value;
+			});
+			return {
+				original,
+				redacted,
+				detections: allDetections,
+				redactionMap,
+				stats: { piiCount: allDetections.length },
+				rowCount: dataRows.length,
+				columnCount,
+				headers: headers?.filter((h) => h !== void 0),
+				columnStats,
+				matchesByCell
+			};
+		}
+		/**
+		* Redact PII in CSV data
+		*/
+		redact(input, detectionResult, options) {
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const rows = this.parse(input, options);
+			if (rows.length === 0) return "";
+			const delimiter = opts.delimiter || this.detectDelimiter(typeof input === "string" ? input : input.toString("utf-8"));
+			const hasHeader = detectionResult.headers !== void 0;
+			const redactionMap = /* @__PURE__ */ new Map();
+			for (const cellMatch of detectionResult.matchesByCell) {
+				if (!redactionMap.has(cellMatch.row)) redactionMap.set(cellMatch.row, /* @__PURE__ */ new Map());
+				redactionMap.get(cellMatch.row).set(cellMatch.column, "[REDACTED]");
+			}
+			const outputRows = [];
+			for (let i = 0; i < rows.length; i++) {
+				const row = rows[i];
+				if (hasHeader && i === 0) outputRows.push(this.formatRow(row.values, delimiter, opts.quote));
+				else {
+					const rowIndex = hasHeader ? i - 1 : i;
+					const redactedValues = row.values.map((value, colIndex) => {
+						return redactionMap.get(rowIndex)?.get(colIndex) || value;
+					});
+					outputRows.push(this.formatRow(redactedValues, delimiter, opts.quote));
+				}
+			}
+			return outputRows.join("\n");
+		}
+		/**
+		* Parse a single CSV row
+		*/
+		parseRow(line, delimiter, quote, _escape) {
+			const values = [];
+			let current = "";
+			let inQuotes = false;
+			let i = 0;
+			while (i < line.length) {
+				const char = line[i];
+				const nextChar = line[i + 1];
+				if (char === quote) if (inQuotes && nextChar === quote) {
+					current += quote;
+					i += 2;
+				} else {
+					inQuotes = !inQuotes;
+					i++;
+				}
+				else if (char === delimiter && !inQuotes) {
+					values.push(current);
+					current = "";
+					i++;
+				} else {
+					current += char;
+					i++;
+				}
+			}
+			values.push(current);
+			return values;
+		}
+		/**
+		* Format a row as CSV
+		*/
+		formatRow(values, delimiter, quote) {
+			return values.map((value) => {
+				if (value.includes(delimiter) || value.includes(quote) || value.includes("\n")) return `${quote}${value.replace(new RegExp(quote, "g"), quote + quote)}${quote}`;
+				return value;
+			}).join(delimiter);
+		}
+		/**
+		* Auto-detect CSV delimiter
+		*/
+		detectDelimiter(text) {
+			const delimiters = [
+				",",
+				"	",
+				";",
+				"|"
+			];
+			const lines = text.split(/\r?\n/).slice(0, 5);
+			let bestDelimiter = ",";
+			let bestScore = 0;
+			for (const delimiter of delimiters) {
+				const counts = lines.map((line) => {
+					let count = 0;
+					let inQuotes = false;
+					for (const char of line) {
+						if (char === "\"") inQuotes = !inQuotes;
+						if (char === delimiter && !inQuotes) count++;
+					}
+					return count;
+				});
+				if (counts.length > 0 && counts[0] > 0) {
+					const avg = counts.reduce((a, b) => a + b, 0) / counts.length;
+					const score = avg / (counts.reduce((sum, c) => sum + Math.pow(c - avg, 2), 0) / counts.length + 1);
+					if (score > bestScore) {
+						bestScore = score;
+						bestDelimiter = delimiter;
+					}
+				}
+			}
+			return bestDelimiter;
+		}
+		/**
+		* Detect if first row is likely a header
+		*/
+		detectHeader(rows) {
+			if (rows.length < 2) return false;
+			const firstRow = rows[0].values;
+			const secondRow = rows[1].values;
+			if (firstRow.reduce((sum, v) => sum + v.length, 0) / firstRow.length > secondRow.reduce((sum, v) => sum + v.length, 0) / secondRow.length * 1.5) return false;
+			const firstRowNumeric = firstRow.filter((v) => !isNaN(Number(v)) && v.trim() !== "").length;
+			return firstRow.length - firstRowNumeric >= firstRowNumeric;
+		}
+		/**
+		* Boost confidence if column name indicates PII
+		*/
+		boostConfidenceFromColumnName(detections, columnName, piiIndicatorNames) {
+			if (!columnName) return detections;
+			const nameLower = columnName.toLowerCase().trim();
+			if (!piiIndicatorNames.some((indicator) => nameLower.includes(indicator.toLowerCase()))) return detections;
+			return detections.map((detection) => ({
+				...detection,
+				confidence: Math.min(1, (detection.confidence || .5) * 1.2)
+			}));
+		}
+		/**
+		* Extract all cell values as text
+		*/
+		extractText(input, options) {
+			const rows = this.parse(input, options);
+			const textParts = [];
+			for (const row of rows) for (const value of row.values) if (value.trim().length > 0) textParts.push(value);
+			return textParts.join(" ");
+		}
+		/**
+		* Get column statistics without full PII detection
+		*/
+		getColumnInfo(input, options) {
+			const rows = this.parse(input, options);
+			if (rows.length === 0) return {
+				columnCount: 0,
+				rowCount: 0,
+				sampleRows: []
+			};
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const hasHeader = opts.hasHeader !== void 0 ? opts.hasHeader : this.detectHeader(rows);
+			const headers = hasHeader && rows.length > 0 ? rows[0].values : void 0;
+			const dataRows = hasHeader ? rows.slice(1) : rows;
+			const sampleRows = dataRows.slice(0, 5).map((r) => r.values);
+			return {
+				columnCount: rows[0].values.length,
+				rowCount: dataRows.length,
+				headers,
+				sampleRows
+			};
+		}
+	};
+}));
+
+//#endregion
+//#region src/document/XlsxProcessor.ts
+/**
+* Create an XLSX processor instance
+*/
+function createXlsxProcessor() {
+	return new XlsxProcessor();
+}
+var XlsxProcessor;
+var init_XlsxProcessor = __esmMin((() => {
+	XlsxProcessor = class {
+		constructor() {
+			this.defaultOptions = {
+				piiIndicatorNames: [
+					"email",
+					"e-mail",
+					"mail",
+					"email_address",
+					"phone",
+					"tel",
+					"telephone",
+					"mobile",
+					"phone_number",
+					"ssn",
+					"social_security",
+					"social_security_number",
+					"address",
+					"street",
+					"street_address",
+					"city",
+					"zip",
+					"zipcode",
+					"postal",
+					"postcode",
+					"name",
+					"firstname",
+					"first_name",
+					"lastname",
+					"last_name",
+					"fullname",
+					"full_name",
+					"password",
+					"pwd",
+					"secret",
+					"token",
+					"api_key",
+					"card",
+					"credit_card",
+					"creditcard",
+					"card_number",
+					"account",
+					"account_number",
+					"iban",
+					"swift",
+					"passport",
+					"passport_number",
+					"license",
+					"licence",
+					"driver_license",
+					"dob",
+					"date_of_birth",
+					"birth_date",
+					"birthdate"
+				],
+				preserveFormatting: true,
+				preserveFormulas: true
+			};
+			try {
+				this.xlsx = require("xlsx");
+			} catch {}
+		}
+		/**
+		* Check if XLSX support is available
+		*/
+		isAvailable() {
+			return !!this.xlsx;
+		}
+		/**
+		* Parse XLSX from buffer
+		*/
+		parse(buffer) {
+			if (!this.xlsx) throw new Error("[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx");
+			try {
+				return this.xlsx.read(buffer, {
+					type: "buffer",
+					cellFormula: true,
+					cellStyles: true
+				});
+			} catch (error) {
+				throw new Error(`[XlsxProcessor] Failed to parse XLSX: ${error.message}`);
+			}
+		}
+		/**
+		* Detect PII in XLSX data
+		*/
+		async detect(buffer, detector, options) {
+			if (!this.xlsx) throw new Error("[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx");
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const workbook = this.parse(buffer);
+			const sheetNames = this.getSheetNamesToProcess(workbook, opts);
+			const sheetResults = [];
+			const allDetections = [];
+			const allTypes = /* @__PURE__ */ new Set();
+			for (let sheetIndex = 0; sheetIndex < sheetNames.length; sheetIndex++) {
+				const sheetName = sheetNames[sheetIndex];
+				const sheet = workbook.Sheets[sheetName];
+				const sheetResult = await this.detectSheet(sheet, sheetName, sheetIndex, detector, opts);
+				sheetResults.push(sheetResult);
+				allDetections.push(...sheetResult.matchesByCell.flatMap((c) => c.matches));
+				sheetResult.matchesByCell.forEach((cell) => {
+					cell.matches.forEach((det) => allTypes.add(det.type));
+				});
+			}
+			const original = this.extractText(buffer, options);
+			const redactedBuffer = this.redact(buffer, {
+				original,
+				redacted: original,
+				detections: allDetections,
+				redactionMap: {},
+				stats: { piiCount: allDetections.length },
+				sheetResults,
+				sheetCount: sheetResults.length
+			}, options);
+			const redacted = this.extractText(redactedBuffer, options);
+			const redactionMap = {};
+			allDetections.forEach((det) => {
+				redactionMap[det.placeholder] = det.value;
+			});
+			return {
+				original,
+				redacted,
+				detections: allDetections,
+				redactionMap,
+				stats: { piiCount: allDetections.length },
+				sheetResults,
+				sheetCount: sheetResults.length
+			};
+		}
+		/**
+		* Detect PII in a single sheet
+		*/
+		async detectSheet(sheet, sheetName, sheetIndex, detector, options) {
+			const range = this.xlsx.utils.decode_range(sheet["!ref"] || "A1");
+			const startRow = range.s.r;
+			const endRow = options.maxRows !== void 0 ? Math.min(range.e.r, startRow + options.maxRows - 1) : range.e.r;
+			const startCol = range.s.c;
+			const endCol = range.e.c;
+			const columnCount = endCol - startCol + 1;
+			const hasHeader = options.hasHeader !== void 0 ? options.hasHeader : this.detectHeader(sheet, range);
+			const headers = hasHeader ? this.getRowValues(sheet, startRow, startCol, endCol) : void 0;
+			const dataStartRow = hasHeader ? startRow + 1 : startRow;
+			const columnNameToIndex = /* @__PURE__ */ new Map();
+			if (headers) headers.forEach((header, index) => {
+				if (header) columnNameToIndex.set(header.toLowerCase().trim(), index);
+			});
+			const alwaysRedactCols = new Set(options.alwaysRedactColumns || []);
+			if (options.alwaysRedactColumnNames && headers) options.alwaysRedactColumnNames.forEach((name) => {
+				const index = columnNameToIndex.get(name.toLowerCase().trim());
+				if (index !== void 0) alwaysRedactCols.add(index);
+			});
+			const skipCols = new Set(options.skipColumns || []);
+			const columnStats = {};
+			for (let col = 0; col <= endCol - startCol; col++) columnStats[col] = {
+				columnIndex: col,
+				columnLetter: this.columnToLetter(col),
+				columnName: headers?.[col],
+				piiCount: 0,
+				piiPercentage: 0,
+				piiTypes: []
+			};
+			const matchesByCell = [];
+			for (let row = dataStartRow; row <= endRow; row++) for (let col = startCol; col <= endCol; col++) {
+				const colIndex = col - startCol;
+				if (skipCols.has(colIndex)) continue;
+				const cellRef = this.xlsx.utils.encode_cell({
+					r: row,
+					c: col
+				});
+				const cell = sheet[cellRef];
+				if (!cell) continue;
+				const cellValue = this.getCellValue(cell);
+				if (!cellValue) continue;
+				const cellFormula = cell.f;
+				if (alwaysRedactCols.has(colIndex)) {
+					const detection = {
+						type: "SENSITIVE_COLUMN",
+						value: cellValue,
+						placeholder: `[SENSITIVE_COLUMN_${colIndex}]`,
+						position: [0, cellValue.length],
+						severity: "high",
+						confidence: 1
+					};
+					matchesByCell.push({
+						cell: cellRef,
+						row: row + 1,
+						column: colIndex,
+						columnLetter: this.columnToLetter(colIndex),
+						columnName: headers?.[colIndex],
+						value: cellValue,
+						formula: cellFormula,
+						matches: [detection]
+					});
+					columnStats[colIndex].piiCount++;
+					continue;
+				}
+				const result = await detector.detect(cellValue);
+				if (result.detections.length > 0) {
+					const boostedDetections = this.boostConfidenceFromColumnName(result.detections, headers?.[colIndex], options.piiIndicatorNames || []);
+					matchesByCell.push({
+						cell: cellRef,
+						row: row + 1,
+						column: colIndex,
+						columnLetter: this.columnToLetter(colIndex),
+						columnName: headers?.[colIndex],
+						value: cellValue,
+						formula: cellFormula,
+						matches: boostedDetections
+					});
+					columnStats[colIndex].piiCount += boostedDetections.length;
+					const columnTypes = new Set(columnStats[colIndex].piiTypes);
+					boostedDetections.forEach((d) => columnTypes.add(d.type));
+					columnStats[colIndex].piiTypes = Array.from(columnTypes);
+				}
+			}
+			const dataRowCount = endRow - dataStartRow + 1;
+			for (let col = 0; col <= endCol - startCol; col++) {
+				const rowsWithPii = matchesByCell.filter((m) => m.column === col).length;
+				columnStats[col].piiPercentage = dataRowCount > 0 ? rowsWithPii / dataRowCount * 100 : 0;
+			}
+			return {
+				sheetName,
+				sheetIndex,
+				rowCount: dataRowCount,
+				columnCount,
+				headers: headers?.filter((h) => h !== void 0),
+				columnStats,
+				matchesByCell
+			};
+		}
+		/**
+		* Redact PII in XLSX data
+		*/
+		redact(buffer, detectionResult, options) {
+			if (!this.xlsx) throw new Error("[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx");
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const workbook = this.parse(buffer);
+			for (const sheetResult of detectionResult.sheetResults) {
+				const sheet = workbook.Sheets[sheetResult.sheetName];
+				for (const cellMatch of sheetResult.matchesByCell) {
+					const cell = sheet[cellMatch.cell];
+					if (!cell) continue;
+					cell.v = "[REDACTED]";
+					cell.w = "[REDACTED]";
+					if (!opts.preserveFormulas) delete cell.f;
+					cell.t = "s";
+				}
+			}
+			return this.xlsx.write(workbook, {
+				type: "buffer",
+				bookType: "xlsx"
+			});
+		}
+		/**
+		* Get cell value as string
+		*/
+		getCellValue(cell) {
+			if (!cell) return "";
+			if (cell.w !== void 0) return String(cell.w);
+			if (cell.v !== void 0) return String(cell.v);
+			return "";
+		}
+		/**
+		* Get row values
+		*/
+		getRowValues(sheet, row, startCol, endCol) {
+			const values = [];
+			for (let col = startCol; col <= endCol; col++) {
+				const cell = sheet[this.xlsx.utils.encode_cell({
+					r: row,
+					c: col
+				})];
+				values.push(cell ? this.getCellValue(cell) : void 0);
+			}
+			return values;
+		}
+		/**
+		* Detect if first row is likely a header
+		*/
+		detectHeader(sheet, range) {
+			const firstRow = this.getRowValues(sheet, range.s.r, range.s.c, range.e.c);
+			const secondRow = range.s.r + 1 <= range.e.r ? this.getRowValues(sheet, range.s.r + 1, range.s.c, range.e.c) : null;
+			if (!secondRow) return false;
+			const firstRowValues = firstRow.filter((v) => v !== void 0);
+			const secondRowValues = secondRow.filter((v) => v !== void 0);
+			if (firstRowValues.length === 0 || secondRowValues.length === 0) return false;
+			if (firstRowValues.reduce((sum, v) => sum + v.length, 0) / firstRowValues.length > secondRowValues.reduce((sum, v) => sum + v.length, 0) / secondRowValues.length * 1.5) return false;
+			const firstRowNumeric = firstRowValues.filter((v) => !isNaN(Number(v)) && v.trim() !== "").length;
+			return firstRowValues.length - firstRowNumeric >= firstRowNumeric;
+		}
+		/**
+		* Convert column index to letter (0 = A, 25 = Z, 26 = AA)
+		*/
+		columnToLetter(col) {
+			let letter = "";
+			while (col >= 0) {
+				letter = String.fromCharCode(col % 26 + 65) + letter;
+				col = Math.floor(col / 26) - 1;
+			}
+			return letter;
+		}
+		/**
+		* Get sheet names to process based on options
+		*/
+		getSheetNamesToProcess(workbook, options) {
+			const allSheetNames = workbook.SheetNames;
+			if (options.sheets && options.sheets.length > 0) return options.sheets.filter((name) => allSheetNames.includes(name));
+			if (options.sheetIndices && options.sheetIndices.length > 0) return options.sheetIndices.filter((index) => index >= 0 && index < allSheetNames.length).map((index) => allSheetNames[index]);
+			return allSheetNames;
+		}
+		/**
+		* Boost confidence if column name indicates PII
+		*/
+		boostConfidenceFromColumnName(detections, columnName, piiIndicatorNames) {
+			if (!columnName) return detections;
+			const nameLower = columnName.toLowerCase().trim();
+			if (!piiIndicatorNames.some((indicator) => nameLower.includes(indicator.toLowerCase()))) return detections;
+			return detections.map((detection) => ({
+				...detection,
+				confidence: Math.min(1, (detection.confidence || .5) * 1.2)
+			}));
+		}
+		/**
+		* Extract all cell values as text
+		*/
+		extractText(buffer, options) {
+			if (!this.xlsx) throw new Error("[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx");
+			const workbook = this.parse(buffer);
+			const opts = {
+				...this.defaultOptions,
+				...options
+			};
+			const sheetNames = this.getSheetNamesToProcess(workbook, opts);
+			const textParts = [];
+			for (const sheetName of sheetNames) {
+				const sheet = workbook.Sheets[sheetName];
+				const range = this.xlsx.utils.decode_range(sheet["!ref"] || "A1");
+				for (let row = range.s.r; row <= range.e.r; row++) for (let col = range.s.c; col <= range.e.c; col++) {
+					const cell = sheet[this.xlsx.utils.encode_cell({
+						r: row,
+						c: col
+					})];
+					if (cell) {
+						const value = this.getCellValue(cell);
+						if (value.trim().length > 0) textParts.push(value);
+					}
+				}
+			}
+			return textParts.join(" ");
+		}
+		/**
+		* Get workbook metadata
+		*/
+		getMetadata(buffer) {
+			if (!this.xlsx) throw new Error("[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx");
+			const workbook = this.parse(buffer);
+			return {
+				sheetNames: workbook.SheetNames,
+				sheetCount: workbook.SheetNames.length
+			};
+		}
+	};
+}));
+
+//#endregion
+//#region src/document/DocumentProcessor.ts
+/**
+* Create a document processor instance
+*/
+function createDocumentProcessor() {
+	return new DocumentProcessor();
+}
+var DocumentProcessor;
+var init_DocumentProcessor = __esmMin((() => {
+	init_OCRProcessor();
+	init_JsonProcessor();
+	init_CsvProcessor();
+	init_XlsxProcessor();
+	DocumentProcessor = class {
+		constructor() {
+			try {
+				this.pdfParse = require("pdf-parse");
+			} catch {}
+			try {
+				this.mammoth = require("mammoth");
+			} catch {}
+			this.ocrProcessor = new OCRProcessor();
+			this.jsonProcessor = new JsonProcessor();
+			this.csvProcessor = new CsvProcessor();
+			this.xlsxProcessor = new XlsxProcessor();
+		}
+		/**
+		* Extract text from document buffer
+		*/
+		async extractText(buffer, options) {
+			const format = options?.format || this.detectFormat(buffer);
+			if (!format) throw new Error("[DocumentProcessor] Unable to detect document format. Supported: PDF, DOCX, TXT, images (with OCR)");
+			const maxSize = options?.maxSize || 50 * 1024 * 1024;
+			if (buffer.length > maxSize) throw new Error(`[DocumentProcessor] Document size (${buffer.length} bytes) exceeds maximum (${maxSize} bytes)`);
+			switch (format) {
+				case "pdf": return this.extractPdfText(buffer, options);
+				case "docx": return this.extractDocxText(buffer, options);
+				case "txt": return buffer.toString("utf-8");
+				case "image": return this.extractImageText(buffer, options);
+				case "json": return this.extractJsonText(buffer, options);
+				case "csv": return this.extractCsvText(buffer, options);
+				case "xlsx": return this.extractXlsxText(buffer, options);
+				default: throw new Error(`[DocumentProcessor] Unsupported format: ${format}`);
+			}
+		}
+		/**
+		* Get document metadata
+		*/
+		async getMetadata(buffer, options) {
+			const format = options?.format || this.detectFormat(buffer);
+			if (!format) throw new Error("[DocumentProcessor] Unable to detect document format");
+			switch (format) {
+				case "pdf": return this.getPdfMetadata(buffer, options);
+				case "docx": return this.getDocxMetadata(buffer, options);
+				case "txt": return {
+					format: "txt",
+					pages: void 0
+				};
+				case "image": return this.getImageMetadata(buffer, options);
+				case "json": return this.getJsonMetadata(buffer, options);
+				case "csv": return this.getCsvMetadata(buffer, options);
+				case "xlsx": return this.getXlsxMetadata(buffer, options);
+				default: throw new Error(`[DocumentProcessor] Unsupported format: ${format}`);
+			}
+		}
+		/**
+		* Detect document format from buffer
+		*/
+		detectFormat(buffer) {
+			if (buffer.length < 4) return null;
+			if (buffer.toString("utf-8", 0, 4) === "%PDF") return "pdf";
+			if (buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) return "image";
+			if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "image";
+			if (buffer[0] === 73 && buffer[1] === 73 && buffer[2] === 42 && buffer[3] === 0 || buffer[0] === 77 && buffer[1] === 77 && buffer[2] === 0 && buffer[3] === 42) return "image";
+			if (buffer[0] === 66 && buffer[1] === 77) return "image";
+			if (buffer.length >= 12 && buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) return "image";
+			if (buffer[0] === 80 && buffer[1] === 75) {
+				const zipHeader = buffer.toString("utf-8", 0, Math.min(500, buffer.length));
+				if (zipHeader.includes("word/") || zipHeader.includes("[Content_Types].xml")) return "docx";
+				if (zipHeader.includes("xl/")) return "xlsx";
+			}
+			const text = buffer.toString("utf-8");
+			const trimmed = text.trim();
+			if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+				if (this.jsonProcessor.isValid(buffer)) return "json";
+			}
+			const lines = text.split(/\r?\n/).slice(0, 5);
+			if (lines.length >= 2) for (const delimiter of [
+				",",
+				"	",
+				";",
+				"|"
+			]) {
+				const counts = lines.map((line) => (line.match(new RegExp(delimiter, "g")) || []).length);
+				if (counts[0] > 0 && counts.every((c) => c === counts[0])) return "csv";
+			}
+			const sample = buffer.slice(0, Math.min(1e3, buffer.length));
+			if (sample.filter((byte) => byte < 32 && byte !== 9 && byte !== 10 && byte !== 13).length < sample.length * .1) return "txt";
+			return null;
+		}
+		/**
+		* Check if format is supported
+		*/
+		isFormatSupported(format) {
+			switch (format) {
+				case "pdf": return !!this.pdfParse;
+				case "docx": return !!this.mammoth;
+				case "txt": return true;
+				case "image": return this.ocrProcessor.isAvailable();
+				case "json": return true;
+				case "csv": return true;
+				case "xlsx": return this.xlsxProcessor.isAvailable();
+				default: return false;
+			}
+		}
+		/**
+		* Extract text from PDF
+		*/
+		async extractPdfText(buffer, options) {
+			if (!this.pdfParse) throw new Error("[DocumentProcessor] PDF support requires pdf-parse. Install with: npm install pdf-parse");
+			try {
+				const data = await this.pdfParse(buffer, {
+					password: options?.password,
+					max: options?.pages ? Math.max(...options.pages) : void 0
+				});
+				if (options?.pages) return data.text;
+				return data.text || "";
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] PDF extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Extract text from DOCX
+		*/
+		async extractDocxText(buffer, _options) {
+			if (!this.mammoth) throw new Error("[DocumentProcessor] DOCX support requires mammoth. Install with: npm install mammoth");
+			try {
+				return (await this.mammoth.extractRawText({ buffer })).value || "";
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] DOCX extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Get PDF metadata
+		*/
+		async getPdfMetadata(buffer, _options) {
+			if (!this.pdfParse) throw new Error("[DocumentProcessor] PDF support requires pdf-parse. Install with: npm install pdf-parse");
+			try {
+				const data = await this.pdfParse(buffer, { password: _options?.password });
+				return {
+					format: "pdf",
+					pages: data.numpages,
+					title: data.info?.Title,
+					author: data.info?.Author,
+					creationDate: data.info?.CreationDate ? new Date(data.info.CreationDate) : void 0,
+					modifiedDate: data.info?.ModDate ? new Date(data.info.ModDate) : void 0,
+					custom: data.info
+				};
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] PDF metadata extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Get DOCX metadata
+		*/
+		async getDocxMetadata(_buffer, _options) {
+			return {
+				format: "docx",
+				pages: void 0
+			};
+		}
+		/**
+		* Extract text from image using OCR
+		*/
+		async extractImageText(buffer, options) {
+			if (!this.ocrProcessor.isAvailable()) throw new Error("[DocumentProcessor] Image/OCR support requires tesseract.js. Install with: npm install tesseract.js");
+			try {
+				return (await this.ocrProcessor.recognizeText(buffer, options?.ocrOptions)).text;
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] Image text extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Get image metadata
+		*/
+		async getImageMetadata(buffer, options) {
+			if (!this.ocrProcessor.isAvailable()) return {
+				format: "image",
+				pages: void 0,
+				usedOCR: false
+			};
+			try {
+				return {
+					format: "image",
+					pages: void 0,
+					usedOCR: true,
+					ocrConfidence: (await this.ocrProcessor.recognizeText(buffer, options?.ocrOptions)).confidence
+				};
+			} catch {
+				return {
+					format: "image",
+					pages: void 0,
+					usedOCR: false
+				};
+			}
+		}
+		/**
+		* Extract text from JSON
+		*/
+		async extractJsonText(buffer, _options) {
+			try {
+				return this.jsonProcessor.extractText(buffer);
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] JSON extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Extract text from CSV
+		*/
+		async extractCsvText(buffer, _options) {
+			try {
+				return this.csvProcessor.extractText(buffer);
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] CSV extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Extract text from XLSX
+		*/
+		async extractXlsxText(buffer, _options) {
+			if (!this.xlsxProcessor.isAvailable()) throw new Error("[DocumentProcessor] XLSX support requires xlsx package. Install with: npm install xlsx");
+			try {
+				return this.xlsxProcessor.extractText(buffer);
+			} catch (error) {
+				throw new Error(`[DocumentProcessor] XLSX extraction failed: ${error.message}`);
+			}
+		}
+		/**
+		* Get JSON metadata
+		*/
+		async getJsonMetadata(buffer, _options) {
+			try {
+				const data = this.jsonProcessor.parse(buffer);
+				const isArray = Array.isArray(data);
+				return {
+					format: "json",
+					pages: void 0,
+					custom: {
+						isArray,
+						itemCount: isArray ? data.length : Object.keys(data).length
+					}
+				};
+			} catch {
+				return {
+					format: "json",
+					pages: void 0
+				};
+			}
+		}
+		/**
+		* Get CSV metadata
+		*/
+		async getCsvMetadata(buffer, _options) {
+			try {
+				const info = this.csvProcessor.getColumnInfo(buffer);
+				return {
+					format: "csv",
+					pages: void 0,
+					custom: {
+						rowCount: info.rowCount,
+						columnCount: info.columnCount,
+						headers: info.headers
+					}
+				};
+			} catch {
+				return {
+					format: "csv",
+					pages: void 0
+				};
+			}
+		}
+		/**
+		* Get XLSX metadata
+		*/
+		async getXlsxMetadata(buffer, _options) {
+			if (!this.xlsxProcessor.isAvailable()) return {
+				format: "xlsx",
+				pages: void 0
+			};
+			try {
+				const metadata = this.xlsxProcessor.getMetadata(buffer);
+				return {
+					format: "xlsx",
+					pages: void 0,
+					custom: {
+						sheetNames: metadata.sheetNames,
+						sheetCount: metadata.sheetCount
+					}
+				};
+			} catch {
+				return {
+					format: "xlsx",
+					pages: void 0
+				};
+			}
+		}
+		/**
+		* Get OCR processor instance
+		*/
+		getOCRProcessor() {
+			return this.ocrProcessor;
+		}
+		/**
+		* Get JSON processor instance
+		*/
+		getJsonProcessor() {
+			return this.jsonProcessor;
+		}
+		/**
+		* Get CSV processor instance
+		*/
+		getCsvProcessor() {
+			return this.csvProcessor;
+		}
+		/**
+		* Get XLSX processor instance
+		*/
+		getXlsxProcessor() {
+			return this.xlsxProcessor;
+		}
+	};
+}));
+
+//#endregion
+//#region src/document/index.ts
+var document_exports = /* @__PURE__ */ __exportAll({
+	CsvProcessor: () => CsvProcessor,
+	DocumentProcessor: () => DocumentProcessor,
+	JsonProcessor: () => JsonProcessor,
+	OCRProcessor: () => OCRProcessor,
+	XlsxProcessor: () => XlsxProcessor,
+	createCsvProcessor: () => createCsvProcessor,
+	createDocumentProcessor: () => createDocumentProcessor,
+	createJsonProcessor: () => createJsonProcessor,
+	createOCRProcessor: () => createOCRProcessor,
+	createXlsxProcessor: () => createXlsxProcessor
+});
+var init_document = __esmMin((() => {
+	init_DocumentProcessor();
+	init_OCRProcessor();
+	init_JsonProcessor();
+	init_CsvProcessor();
+	init_XlsxProcessor();
+}));
+
+//#endregion
+//#region src/workers/WorkerPool.ts
+/**
+* Worker thread pool for parallel processing
+*/
+/**
+* Create a worker pool instance
+*/
+function createWorkerPool(config) {
+	return new WorkerPool(config);
+}
+var WorkerPool;
+var init_WorkerPool = __esmMin((() => {
+	WorkerPool = class {
+		constructor(config = {}) {
+			this.workers = [];
+			this.availableWorkers = [];
+			this.taskQueue = [];
+			this.totalProcessingTime = 0;
+			this.config = {
+				numWorkers: config.numWorkers || (0, os.cpus)().length,
+				maxQueueSize: config.maxQueueSize || 100,
+				idleTimeout: config.idleTimeout || 3e4
+			};
+			this.stats = {
+				activeWorkers: 0,
+				idleWorkers: 0,
+				queueSize: 0,
+				totalProcessed: 0,
+				totalErrors: 0,
+				avgProcessingTime: 0
+			};
+			this.workerPath = (0, path.join)(__dirname, "worker.js");
+		}
+		/**
+		* Initialize worker pool
+		*/
+		async initialize() {
+			for (let i = 0; i < this.config.numWorkers; i++) await this.createWorker();
+		}
+		/**
+		* Create a new worker
+		*/
+		async createWorker() {
+			const worker = new worker_threads.Worker(this.workerPath);
+			worker.on("message", (result) => {
+				this.handleWorkerResult(worker, result);
+			});
+			worker.on("error", (error) => {
+				console.error("[WorkerPool] Worker error:", error);
+				this.stats.totalErrors++;
+				this.removeWorker(worker);
+				this.createWorker();
+			});
+			worker.on("exit", (code) => {
+				if (code !== 0) console.error(`[WorkerPool] Worker exited with code ${code}`);
+				this.removeWorker(worker);
+			});
+			this.workers.push(worker);
+			this.availableWorkers.push(worker);
+			this.stats.idleWorkers++;
+			return worker;
+		}
+		/**
+		* Execute a task on the worker pool
+		*/
+		async execute(task) {
+			if (this.taskQueue.length >= this.config.maxQueueSize) throw new Error(`[WorkerPool] Queue is full (max: ${this.config.maxQueueSize})`);
+			return new Promise((resolve, reject) => {
+				this.taskQueue.push({
+					task,
+					resolve,
+					reject
+				});
+				this.stats.queueSize = this.taskQueue.length;
+				this.processQueue();
+			});
+		}
+		/**
+		* Process task queue
+		*/
+		processQueue() {
+			while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
+				const worker = this.availableWorkers.shift();
+				const { task, resolve, reject } = this.taskQueue.shift();
+				this.stats.idleWorkers--;
+				this.stats.activeWorkers++;
+				this.stats.queueSize = this.taskQueue.length;
+				worker.__currentTask = {
+					resolve,
+					reject,
+					startTime: Date.now()
+				};
+				worker.postMessage(task);
+			}
+		}
+		/**
+		* Handle worker result
+		*/
+		handleWorkerResult(worker, result) {
+			const currentTask = worker.__currentTask;
+			if (!currentTask) return;
+			this.stats.activeWorkers--;
+			this.stats.idleWorkers++;
+			this.stats.totalProcessed++;
+			this.totalProcessingTime += result.processingTime;
+			this.stats.avgProcessingTime = this.totalProcessingTime / this.stats.totalProcessed;
+			this.availableWorkers.push(worker);
+			delete worker.__currentTask;
+			if (result.error) {
+				this.stats.totalErrors++;
+				currentTask.reject(new Error(result.error));
+			} else currentTask.resolve(result.result);
+			this.processQueue();
+		}
+		/**
+		* Remove worker from pool
+		*/
+		removeWorker(worker) {
+			const index = this.workers.indexOf(worker);
+			if (index !== -1) this.workers.splice(index, 1);
+			const availableIndex = this.availableWorkers.indexOf(worker);
+			if (availableIndex !== -1) {
+				this.availableWorkers.splice(availableIndex, 1);
+				this.stats.idleWorkers--;
+			}
+		}
+		/**
+		* Get pool statistics
+		*/
+		getStats() {
+			return { ...this.stats };
+		}
+		/**
+		* Terminate all workers
+		*/
+		async terminate() {
+			const terminatePromises = this.workers.map((worker) => worker.terminate());
+			await Promise.all(terminatePromises);
+			this.workers = [];
+			this.availableWorkers = [];
+			this.taskQueue = [];
+			this.stats.activeWorkers = 0;
+			this.stats.idleWorkers = 0;
+			this.stats.queueSize = 0;
+		}
+	};
+}));
+
+//#endregion
+//#region src/workers/index.ts
+var workers_exports = /* @__PURE__ */ __exportAll({
+	WorkerPool: () => WorkerPool,
+	createWorkerPool: () => createWorkerPool
+});
+var init_workers = __esmMin((() => {
+	init_WorkerPool();
+}));
+
 //#endregion
 //#region src/detector.ts
 var OpenRedaction = class OpenRedaction {
@@ -16403,14 +18357,14 @@ var OpenRedaction = class OpenRedaction {
 	* Run health check
 	*/
 	async healthCheck(options) {
-		const { HealthChecker } = await Promise.resolve().then(() => require("./HealthCheck-CNRn3PcM.js"));
+		const { HealthChecker } = await Promise.resolve().then(() => (init_HealthCheck(), HealthCheck_exports));
 		return new HealthChecker(this).check(options);
 	}
 	/**
 	* Quick health check (minimal overhead)
 	*/
 	async quickHealthCheck() {
-		const { HealthChecker } = await Promise.resolve().then(() => require("./HealthCheck-CNRn3PcM.js"));
+		const { HealthChecker } = await Promise.resolve().then(() => (init_HealthCheck(), HealthCheck_exports));
 		return new HealthChecker(this).quickCheck();
 	}
 	/**
@@ -16421,7 +18375,7 @@ var OpenRedaction = class OpenRedaction {
 	*/
 	async detectDocument(buffer, options) {
 		if (this.rbacManager && !this.rbacManager.hasPermission("detection:detect")) throw new Error("[OpenRedaction] Permission denied: detection:detect required");
-		const { createDocumentProcessor } = await Promise.resolve().then(() => require("./document-CaOtDvq_.js"));
+		const { createDocumentProcessor } = await Promise.resolve().then(() => (init_document(), document_exports));
 		const processor = createDocumentProcessor();
 		const extractionStart = performance.now();
 		const text = await processor.extractText(buffer, options);
@@ -16450,7 +18404,7 @@ var OpenRedaction = class OpenRedaction {
 	* Significantly faster for processing many texts
 	*/
 	static async detectBatch(texts, options) {
-		const { createWorkerPool } = await Promise.resolve().then(() => require("./workers-B2xx_81m.js"));
+		const { createWorkerPool } = await Promise.resolve().then(() => (init_workers(), workers_exports));
 		const pool = createWorkerPool({ numWorkers: options?.numWorkers });
 		try {
 			await pool.initialize();
@@ -16470,7 +18424,7 @@ var OpenRedaction = class OpenRedaction {
 	* Efficient for processing many documents at once
 	*/
 	static async detectDocumentsBatch(buffers, options) {
-		const { createWorkerPool } = await Promise.resolve().then(() => require("./workers-B2xx_81m.js"));
+		const { createWorkerPool } = await Promise.resolve().then(() => (init_workers(), workers_exports));
 		const pool = createWorkerPool({ numWorkers: options?.numWorkers });
 		try {
 			await pool.initialize();
@@ -16489,6 +18443,7 @@ var OpenRedaction = class OpenRedaction {
 
 //#endregion
 //#region src/streaming/StreamingDetector.ts
+init_document();
 /**
 * Streaming detector for large documents
 */
@@ -16637,6 +18592,7 @@ function createStreamingDetector(detector, options) {
 
 //#endregion
 //#region src/batch/BatchProcessor.ts
+init_workers();
 /**
 * Batch processor for processing multiple documents
 */
@@ -18554,6 +20510,7 @@ function createAPIServer(config) {
 //#endregion
 //#region src/index.ts
 init_ConfigExporter();
+init_HealthCheck();
 
 //#endregion
 exports.ADMIN_ROLE = ADMIN_ROLE;
@@ -18565,21 +20522,21 @@ exports.ConfigExporter = ConfigExporter;
 exports.ConfigLoader = ConfigLoader;
 exports.ConsoleAuditLogger = ConsoleAuditLogger;
 exports.ContextRulesEngine = ContextRulesEngine;
-exports.CsvProcessor = require_document.CsvProcessor;
+exports.CsvProcessor = CsvProcessor;
 exports.DEFAULT_DOMAIN_VOCABULARIES = DEFAULT_DOMAIN_VOCABULARIES;
 exports.DEFAULT_PROXIMITY_RULES = DEFAULT_PROXIMITY_RULES;
 exports.DEFAULT_SEVERITY_MAP = DEFAULT_SEVERITY_MAP;
 exports.DEFAULT_TIER_QUOTAS = DEFAULT_TIER_QUOTAS;
-exports.DocumentProcessor = require_document.DocumentProcessor;
+exports.DocumentProcessor = DocumentProcessor;
 exports.ExplainAPI = ExplainAPI;
 exports.GRAFANA_DASHBOARD_TEMPLATE = GRAFANA_DASHBOARD_TEMPLATE;
-exports.HealthChecker = require_HealthCheck.HealthChecker;
+exports.HealthChecker = HealthChecker;
 exports.InMemoryAuditLogger = InMemoryAuditLogger;
 exports.InMemoryMetricsCollector = InMemoryMetricsCollector;
-exports.JsonProcessor = require_document.JsonProcessor;
+exports.JsonProcessor = JsonProcessor;
 exports.LocalLearningStore = LocalLearningStore;
 exports.NERDetector = NERDetector;
-exports.OCRProcessor = require_document.OCRProcessor;
+exports.OCRProcessor = OCRProcessor;
 exports.OPERATOR_ROLE = OPERATOR_ROLE;
 exports.OpenRedaction = OpenRedaction;
 exports.OpenRedactionError = OpenRedactionError;
@@ -18599,10 +20556,8 @@ exports.TenantQuotaExceededError = TenantQuotaExceededError;
 exports.TenantSuspendedError = TenantSuspendedError;
 exports.VIEWER_ROLE = VIEWER_ROLE;
 exports.WebhookManager = WebhookManager;
-exports.WorkerPool = require_workers.WorkerPool;
-exports.XlsxProcessor = require_document.XlsxProcessor;
-exports.__toCommonJS = __toCommonJS;
-exports.__toESM = __toESM;
+exports.WorkerPool = WorkerPool;
+exports.XlsxProcessor = XlsxProcessor;
 exports.allPatterns = allPatterns;
 exports.analyzeContextFeatures = analyzeContextFeatures;
 exports.analyzeFullContext = analyzeFullContext;
@@ -18620,18 +20575,18 @@ exports.createCacheDisabledError = createCacheDisabledError;
 exports.createConfigLoadError = createConfigLoadError;
 exports.createConfigPreset = createConfigPreset;
 exports.createContextRulesEngine = createContextRulesEngine;
-exports.createCsvProcessor = require_document.createCsvProcessor;
+exports.createCsvProcessor = createCsvProcessor;
 exports.createCustomRole = createCustomRole;
-exports.createDocumentProcessor = require_document.createDocumentProcessor;
+exports.createDocumentProcessor = createDocumentProcessor;
 exports.createExplainAPI = createExplainAPI;
-exports.createHealthChecker = require_HealthCheck.createHealthChecker;
+exports.createHealthChecker = createHealthChecker;
 exports.createHighMemoryError = createHighMemoryError;
 exports.createInvalidPatternError = createInvalidPatternError;
-exports.createJsonProcessor = require_document.createJsonProcessor;
+exports.createJsonProcessor = createJsonProcessor;
 exports.createLearningDisabledError = createLearningDisabledError;
 exports.createMultiPassDisabledError = createMultiPassDisabledError;
 exports.createNERDetector = createNERDetector;
-exports.createOCRProcessor = require_document.createOCRProcessor;
+exports.createOCRProcessor = createOCRProcessor;
 exports.createOptimizationDisabledError = createOptimizationDisabledError;
 exports.createPersistentAuditLogger = createPersistentAuditLogger;
 exports.createPriorityOptimizer = createPriorityOptimizer;
@@ -18644,8 +20599,8 @@ exports.createStreamingDetector = createStreamingDetector;
 exports.createTenantManager = createTenantManager;
 exports.createValidationError = createValidationError;
 exports.createWebhookManager = createWebhookManager;
-exports.createWorkerPool = require_workers.createWorkerPool;
-exports.createXlsxProcessor = require_document.createXlsxProcessor;
+exports.createWorkerPool = createWorkerPool;
+exports.createXlsxProcessor = createXlsxProcessor;
 exports.defaultPasses = defaultPasses;
 exports.detectPII = detectPII;
 exports.detectionsOverlap = detectionsOverlap;
@@ -18664,7 +20619,7 @@ exports.getPreset = getPreset;
 exports.getSeverity = getSeverity;
 exports.governmentPatterns = governmentPatterns;
 exports.groupPatternsByPass = groupPatternsByPass;
-exports.healthCheckMiddleware = require_HealthCheck.healthCheckMiddleware;
+exports.healthCheckMiddleware = healthCheckMiddleware;
 exports.healthcarePreset = healthcarePreset;
 exports.healthcareResearchPreset = healthcareResearchPreset;
 exports.hipaaPreset = hipaaPreset;