@harperfast/harper-pro 5.0.30 → 5.1.0-beta.2

package/core/server/static.ts

@@ -1,5 +1,5 @@
 import { realpathSync, existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { Scope } from '../components/Scope';
 import send from 'send';
 
@@ -53,9 +53,10 @@ export function handleApplication(scope: Scope) {
 				// If the file is an index.html, also store it in the index entries
 				if (entry.urlPath.endsWith('index.html')) {
 					// Without trailing slash; null -> 301 redirect to trailing slash
-					indexEntries.set(dirname(entry.urlPath), null);
+					let lastSlashIndex = entry.urlPath.lastIndexOf('/');
+					indexEntries.set(entry.urlPath.slice(0, lastSlashIndex), null);
 					// With trailing slash; serves the index.html file
-					indexEntries.set(join(dirname(entry.urlPath), '/'), entry.absolutePath);
+					indexEntries.set(entry.urlPath.slice(0, lastSlashIndex + 1), entry.absolutePath);
 				}
 				break;
 			case 'unlink':
@@ -63,7 +64,9 @@ export function handleApplication(scope: Scope) {
 				staticFiles.delete(entry.urlPath);
 				// If the file is an index.html, remove it from the index entries as well
 				if (entry.urlPath.endsWith('index.html')) {
-					indexEntries.delete(dirname(entry.urlPath));
+					let lastSlashIndex = entry.urlPath.lastIndexOf('/');
+					indexEntries.delete(entry.urlPath.slice(0, lastSlashIndex));
+					indexEntries.delete(entry.urlPath.slice(0, lastSlashIndex + 1));
 				}
 				break;
 		}
@@ -101,7 +104,7 @@ export function handleApplication(scope: Scope) {
 						return {
 							status: 301,
 							headers: {
-								Location: join(req.pathname, '/'),
+								Location: req.pathname + '/',
 							},
 						};
 					}
@@ -162,7 +165,7 @@ export function handleApplication(scope: Scope) {
 				body: send(req, realpathSync(notFoundPath)),
 			};
 		},
-		{ runFirst: true }
+		{ before: (scope.options.get(['before']) as string) ?? 'authentication' }
 	);
 }
 

package/core/server/status/index.ts

@@ -1,5 +1,5 @@
 import { table } from '../../resources/databases.ts';
-import { handleHDBError, hdbErrors } from '../../utility/errors/hdbError.js';
+import { handleHDBError, hdbErrors } from '../../utility/errors/hdbError.ts';
 import { loggerWithTag } from '../../utility/logging/logger.ts';
 import { validateStatus } from '../../validation/statusValidator.ts';
 import { type StatusId, type StatusValueMap, type StatusRecord, DEFAULT_STATUS_ID } from './definitions.ts';
@@ -28,7 +28,7 @@ type StatusWriteRequestBody<T extends StatusId = StatusId> = {
 // Lazy-initialize the Status table to avoid initialization issues during module import
 let _statusTable: ReturnType<typeof table>;
 
-function getStatusTable() {
+function getStatusTable(): any {
 	if (!_statusTable) {
 		_statusTable = table({
 			database: 'system',

package/core/server/storageReclamation.ts

@@ -1,10 +1,13 @@
+import { readFile } from 'node:fs/promises';
 import { statfs } from 'node:fs/promises';
+import { join } from 'node:path';
 import { getWorkerIndex, getWorkerCount } from '../server/threads/manageThreads.js';
 import { logger } from '../utility/logging/logger.ts';
 import { CONFIG_PARAMS } from '../utility/hdbTerms.ts';
-import envMgr from '../utility/environment/environmentManager.js';
-import { convertToMS } from '../utility/common_utils.js';
+import * as envMgr from '../utility/environment/environmentManager.ts';
+import { convertToMS } from '../utility/common_utils.ts';
 envMgr.initSync();
+
 const reclamationHandlers = new Map<
 	string,
 	{ priority: number; handler: (priority: number) => Promise<void> | void }[]
@@ -12,6 +15,33 @@ const reclamationHandlers = new Map<
 
 const RECLAMATION_THRESHOLD = envMgr.get(CONFIG_PARAMS.STORAGE_RECLAMATION_THRESHOLD) ?? 0.4; // 40% remaining free space is the default
 const RECLAMATION_INTERVAL = convertToMS(envMgr.get(CONFIG_PARAMS.STORAGE_RECLAMATION_INTERVAL)) || 3600000; // 1 hour is the default
+
+// Written by host-manager every ~90s alongside the instance's hdb root
+const QUOTA_STATUS_FILE = 'quota-status.json';
+// Use statfs fallback if the file is older than this (host-manager outage, container start race, etc.)
+const QUOTA_STATUS_MAX_AGE_MS = 5 * 60 * 1000;
+
+export type QuotaStatusData = {
+	usedBytes: number;
+	quotaBytes?: number;
+	updatedAt: number;
+};
+
+/**
+ * Reads the quota-status.json file written by host-manager.
+ * Returns undefined if the file is absent or malformed; does not apply age filtering.
+ */
+export async function getQuotaStatus(): Promise<QuotaStatusData | undefined> {
+	const rootPath = envMgr.get(CONFIG_PARAMS.ROOTPATH);
+	if (!rootPath) return undefined;
+	try {
+		const raw = await readFile(join(rootPath, QUOTA_STATUS_FILE), 'utf8');
+		return JSON.parse(raw) as QuotaStatusData;
+	} catch {
+		return undefined;
+	}
+}
+
 /**
  * Register a handler to be called when storage free space is low and reclamation is needed. The callback is called
  * with the priority of the reclamation, which is the ratio of the threshold to the available space ratio. If space is
@@ -39,7 +69,14 @@ export function onStorageReclamation(
 	}
 }
 let reclamationTimer: NodeJS.Timeout;
+
+// If a fresh quota-status.json exists (written by host-manager every ~90s), use quota-based ratio.
+// Otherwise fall back to statfs for the registered path.
 const defaultGetAvailableSpaceRatio = async (path: string): Promise<number> => {
+	const status = await getQuotaStatus();
+	if (status?.quotaBytes && Date.now() - status.updatedAt < QUOTA_STATUS_MAX_AGE_MS) {
+		return Math.max(0, status.quotaBytes - status.usedBytes) / status.quotaBytes;
+	}
 	const fsStats = await statfs(path);
 	return fsStats.bavail / fsStats.blocks;
 };

package/core/server/threads/itc.js

@@ -1,9 +1,9 @@
 'use strict';
 
-const hdbUtils = require('../../utility/common_utils.js');
+const hdbUtils = require('../../utility/common_utils.ts');
 const hdbTerms = require('../../utility/hdbTerms.ts');
-const { ITC_ERRORS } = require('../../utility/errors/commonErrors.js');
-const { threadId, isMainThread } = require('worker_threads');
+const { ITC_ERRORS } = require('../../utility/errors/commonErrors.ts');
+const { threadId } = require('worker_threads');
 const { onMessageFromWorkers, broadcastWithAcknowledgement } = require('./manageThreads.js');
 
 module.exports = {
@@ -31,7 +31,10 @@ onMessageFromWorkers(async (event, sender) => {
  * @param event
  */
 function sendItcEvent(event) {
-	if (!isMainThread && event.message) event.message.originator = threadId;
+	// Always stamp originator so handlers can send direct responses back.
+	// The main thread's threadId is 0 (worker_threads convention); parentPort.threadId
+	// is set to 0 in workers, so sendToThread(0, ...) routes back to main.
+	if (event.message) event.message.originator = threadId;
 	return broadcastWithAcknowledgement(event);
 }
 

package/core/server/threads/manageThreads.js

@@ -1,17 +1,23 @@
 'use strict';
 
+// Must run before any component code is loaded so that process.exit() called
+// from component code (e.g. Next.js's `unhandledRejection` handler) is
+// intercepted in workers.
+const { realExit } = require('./workerProcessGuard.ts');
+
 const { Worker, MessageChannel, parentPort, isMainThread, threadId, workerData } = require('worker_threads');
 const { join, isAbsolute, extname } = require('path');
 const { server } = require('../Server.ts');
 const { totalmem } = require('os');
-const { setHeapSnapshotNearHeapLimit } = require('v8');
+const { setHeapSnapshotNearHeapLimit } = typeof globalThis.Bun !== 'undefined' ? {} : require('v8');
 const hdbTerms = require('../../utility/hdbTerms.ts');
-const envMgr = require('../../utility/environment/environmentManager.js');
-const harperLogger = require('../../utility/logging/harper_logger.js');
+const envMgr = require('../../utility/environment/environmentManager.ts');
+const harperLogger = require('../../utility/logging/harper_logger.ts');
 const { randomBytes } = require('crypto');
 const { _assignPackageExport } = require('../../globals.js');
 const { PACKAGE_ROOT } = require('../../utility/packageUtils.js');
 const chokidar = require('chokidar');
+const isBun = typeof globalThis.Bun !== 'undefined';
 const MB = 1024 * 1024;
 const workers = []; // these are our child workers that we are managing
 const connectedPorts = []; // these are all known connected worker ports (siblings, children, parents)
@@ -23,6 +29,8 @@ const RESOURCE_REPORT = 'resource_report';
 const THREAD_INFO = 'thread_info';
 const ADDED_PORT = 'added-port';
 const ACKNOWLEDGEMENT = 'ack';
+const REMOVE_PORT = 'remove-port';
+const FORCE_EXIT = 'force-exit';
 let getThreadInfo;
 _assignPackageExport('threads', connectedPorts);
 
@@ -52,9 +60,16 @@ connectedPorts.onMessageByType = onMessageByType;
 connectedPorts.sendToThread = function (threadId, message) {
 	if (!message?.type) throw new Error('A message with a type must be provided');
 	const port = connectedPorts.find((port) => port.threadId === threadId);
-	if (port) {
+	if (!port) return false;
+	try {
 		port.postMessage(message);
 		return true;
+	} catch (err) {
+		// Port may have closed between find() and postMessage() — treat as unreachable.
+		// Only swallow the documented "closed port" race; let serialization bugs
+		// (DataCloneError) and other unexpected errors surface to the caller.
+		if (err?.code === 'ERR_CLOSED_MESSAGE_PORT') return false;
+		throw err;
 	}
 };
 module.exports.whenThreadsStarted = new Promise((resolve) => {
@@ -109,6 +124,8 @@ listenersByType.set(hdbTerms.ITC_EVENT_TYPES.CHILD_STARTED, null);
 listenersByType.set(hdbTerms.ITC_EVENT_TYPES.SCHEMA, null);
 listenersByType.set(hdbTerms.ITC_EVENT_TYPES.USER, null);
 listenersByType.set(hdbTerms.ITC_EVENT_TYPES.COMPONENT_STATUS_REQUEST, null);
+listenersByType.set(hdbTerms.ITC_EVENT_TYPES.RESOURCE_OPENAPI_REQUEST, null);
+listenersByType.set(hdbTerms.ITC_EVENT_TYPES.RESOURCE_OPENAPI_RESPONSE, null);
 
 function startWorker(path, options = {}) {
 	// Take a percentage of total memory to determine the max memory for each thread. The percentage is based
@@ -145,13 +162,16 @@ function startWorker(path, options = {}) {
 
 	if (!extname(path)) path += '.js';
 
-	const execArgv = [
-		'--enable-source-maps',
-		'--experimental-vm-modules', // used for giving applications their own top level scope
-		'--disable-warning=ExperimentalWarning', // yeah, yeah, we know it is experimental
-		'--expose-internals', // expose Node.js internal utils so jsLoader can use `decorateErrorStack()`
-	];
-	if (envMgr.get(hdbTerms.CONFIG_PARAMS.THREADS_HEAPSNAPSHOTNEARLIMIT))
+	const isBun = typeof globalThis.Bun !== 'undefined';
+	const execArgv = isBun
+		? []
+		: [
+				'--enable-source-maps',
+				'--experimental-vm-modules', // used for giving applications their own top level scope
+				'--disable-warning=ExperimentalWarning', // yeah, yeah, we know it is experimental
+				'--expose-internals', // expose Node.js internal utils so jsLoader can use `decorateErrorStack()`
+			];
+	if (!isBun && envMgr.get(hdbTerms.CONFIG_PARAMS.THREADS_HEAPSNAPSHOTNEARLIMIT))
 		execArgv.push('--heapsnapshot-near-heap-limit=1');
 
 	const worker = new Worker(isAbsolute(path) ? path : join(PACKAGE_ROOT, path), {
@@ -272,10 +292,17 @@ async function restartWorkers(
 			worker.emit('shutdown', {});
 			const overlapping = OVERLAPPING_RESTART_TYPES.indexOf(worker.name) > -1;
 			let whenDone = new Promise((resolve) => {
-				// in case the exit inside the thread doesn't timeout, call terminate if necessary
+				// in case the exit inside the thread doesn't timeout, force it from the outside
 				let timeout = setTimeout(() => {
 					harperLogger.warn('Thread did not voluntarily terminate, terminating from the outside', worker.threadId);
-					worker.terminate();
+					if (isBun) {
+						// worker.terminate() triggers a NAPI segfault in Bun; ask the worker to self-exit instead
+						try {
+							worker.postMessage({ type: FORCE_EXIT });
+						} catch {}
+					} else {
+						worker.terminate();
+					}
 				}, threadTerminationTimeout * 2).unref();
 				worker.on('exit', () => {
 					clearTimeout(timeout);
@@ -324,9 +351,18 @@ async function restartWorkers(
 function shutdownWorkers(name) {
 	return restartWorkers(name, Infinity, false);
 }
-function shutdownWorkersNow(name) {
+async function shutdownWorkersNow(name) {
 	shutdownWorkers(name); // set the state of all the workers to shut down. this should finish the important stuff synchronously
-	return Promise.all(workers.map((worker) => worker.terminate()));
+	if (isBun) {
+		// worker.terminate() triggers a NAPI segfault in Bun; ask workers to self-exit instead
+		workers.forEach((worker) => {
+			try {
+				worker.postMessage({ type: FORCE_EXIT });
+			} catch {}
+		});
+	} else {
+		await Promise.all(workers.map((worker) => worker.terminate()));
+	}
 }
 
 const messageListeners = [];
@@ -455,16 +491,21 @@ function startMonitoring() {
 	// utilization levels (last second) and so we don't have to make these calls to frequently
 	setInterval(() => {
 		for (let worker of workers) {
-			let current_ELU = worker.performance.eventLoopUtilization();
-			let recent_ELU;
-			if (worker.lastTotalELU) {
-				// get the difference between current and last to determine the last second of utilization
-				recent_ELU = worker.performance.eventLoopUtilization(current_ELU, worker.lastTotalELU);
+			if (!isBun && worker.performance?.eventLoopUtilization) {
+				let current_ELU = worker.performance.eventLoopUtilization();
+				let recent_ELU;
+				if (worker.lastTotalELU) {
+					// get the difference between current and last to determine the last second of utilization
+					recent_ELU = worker.performance.eventLoopUtilization(current_ELU, worker.lastTotalELU);
+				} else {
+					recent_ELU = current_ELU;
+				}
+				worker.lastTotalELU = current_ELU;
+				worker.recentELU = recent_ELU;
 			} else {
-				recent_ELU = current_ELU;
+				// Bun doesn't support eventLoopUtilization, use a default idle value
+				worker.recentELU = worker.recentELU || { idle: 1, active: 0, utilization: 0 };
 			}
-			worker.lastTotalELU = current_ELU;
-			worker.recentELU = recent_ELU;
 		}
 		if (monitorListener) monitorListener();
 	}, MONITORING_INTERVAL).unref();
@@ -472,6 +513,9 @@ function startMonitoring() {
 const REPORTING_INTERVAL = 1000;
 
 if (parentPort && workerData?.addPorts) {
+	// Main thread always has threadId 0 (worker_threads convention). Stamp it on
+	// parentPort so sendToThread(0, ...) and similar lookups can route back to main.
+	parentPort.threadId = 0;
 	addPort(parentPort);
 	for (let i = 0, l = workerData.addPorts.length; i < l; i++) {
 		let port = workerData.addPorts[i];
@@ -506,8 +550,30 @@ if (parentPort && workerData?.addPorts) {
 }
 module.exports.getThreadInfo = getThreadInfo;
 
+function removePort(port, deadThreadId) {
+	const idx = connectedPorts.indexOf(port);
+	if (idx === -1) return;
+	connectedPorts.splice(idx, 1);
+	// Notify remaining peers to remove this dead sibling port. In Bun, sibling
+	// MessagePorts don't emit 'close' when a peer worker exits, so we broadcast
+	// a REMOVE_PORT message from here (which fires reliably on Worker 'exit')
+	// instead. This is also harmless on Node.js — peers that already cleaned up
+	// via 'close' will simply find threadId missing and skip the splice.
+	if (deadThreadId != null) {
+		for (let remainingPort of connectedPorts) {
+			try {
+				remainingPort.postMessage({ type: REMOVE_PORT, threadId: deadThreadId });
+			} catch {
+				// port may already be dead; ignore
+			}
+		}
+	}
+}
+
 function addPort(port, keepRef) {
 	connectedPorts.push(port);
+	// Capture threadId now — Bun resets port.threadId to -1 by the time 'exit' fires.
+	const portThreadId = port.threadId;
 	port
 		.on('message', (message) => {
 			if (message.type === ADDED_PORT) {
@@ -518,15 +584,18 @@ function addPort(port, keepRef) {
 				if (completion) {
 					completion();
 				}
+			} else if (message.type === REMOVE_PORT) {
+				const idx = connectedPorts.findIndex((p) => p.threadId === message.threadId);
+				if (idx !== -1) connectedPorts.splice(idx, 1);
 			} else {
 				notifyMessageListeners(message, port);
 			}
 		})
 		.on('close', () => {
-			connectedPorts.splice(connectedPorts.indexOf(port), 1);
+			removePort(port, portThreadId);
 		})
 		.on('exit', () => {
-			connectedPorts.splice(connectedPorts.indexOf(port), 1);
+			removePort(port, portThreadId);
 		});
 	if (keepRef) port.refCount = 100;
 	else port.unref();
@@ -590,7 +659,12 @@ if (isMainThread) {
 			harperLogger.warn('Thread did not voluntarily terminate', threadId);
 			// Note that if this occurs, you may want to use this to debug what is currently running:
 			// require('why-is-node-running')();
-			process.exit(0);
+			realExit(0);
 		}, threadTerminationTimeout).unref(); // don't block the shutdown
 	});
+	// In Bun, worker.terminate() triggers a NAPI segfault; the main thread sends FORCE_EXIT
+	// instead, and the worker self-exits cleanly to avoid the crash.
+	onMessageByType(FORCE_EXIT, () => {
+		realExit(0);
+	});
 }