@arkstack/common 0.14.18 → 0.14.20

package/dist/utils-DJQAOLbx.js

@@ -1,803 +0,0 @@
-import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
-import { Arr, Obj, undot } from "@h3ravel/support";
-import { createJiti } from "jiti";
-import { existsSync, readdirSync } from "fs";
-import { Arkstack } from "@arkstack/contract";
-import { createRequire } from "module";
-import path, { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { rm } from "node:fs/promises";
-import { spawn } from "node:child_process";
-import { Secret, TOTP } from "otpauth";
-import { compare, genSalt, hash } from "bcryptjs";
-import { getUserConfig } from "arkormx";
-//#region src/system.ts
-/**
-* Read the .env file
-*
-* @param env
-* @param def
-* @returns
-*/
-const env = (env, defaultValue) => {
-	let val = process.env[env] ?? "";
-	if ([
-		true,
-		"true",
-		"on",
-		false,
-		"false",
-		"off"
-	].includes(val)) val = [
-		true,
-		"true",
-		"on"
-	].includes(val);
-	if (!isNaN(Number(val)) && typeof val !== "boolean" && typeof val !== "undefined" && val !== "") val = Number(val);
-	if (val === "") val = void 0;
-	if (val === "null") val = null;
-	val ??= defaultValue;
-	return val;
-};
-/**
-* Build the app url
-*
-* @param link
-* @returns
-*/
-const appUrl = (link) => {
-	const port = env("PORT", env("APP_PORT", "3000"));
-	const defaultUrl = `http://localhost:${port}`;
-	const appUrl = env("APP_URL", `http://localhost:${port}`);
-	try {
-		const url = new URL(appUrl);
-		if (url.port || url.hostname === "localhost") url.port = port;
-		const baseUrl = url.toString().replace(/\/$/, "");
-		if (link) return `${baseUrl}${`/${link.replace(/^\/+/, "")}`}`;
-		return baseUrl;
-	} catch {
-		return link ? `${defaultUrl}/${link.replace(/^\/+/, "")}` : defaultUrl;
-	}
-};
-const CONFIG_KEY = Symbol("globalConfig");
-globalThis[CONFIG_KEY] = {};
-/**
-* Gets the application configuration.
-*
-* @param key             The configuration key to retrieve.
-* @param defaultValue    The default value to return if the key is not found.
-* @returns               The configuration value.
-*/
-const config = (key, defaultValue) => {
-	if (typeof globalThis.env === "undefined") globalThis.env = (key, def) => key ? process.env[key] ?? def : process.env;
-	const config = globalThis[CONFIG_KEY];
-	if (Object.entries(config).length < 1) {
-		let files;
-		const dist = path.relative(Arkstack.rootDir(), outputDir());
-		const require = createRequire(import.meta.url);
-		const configDir = env("CONFIG_PATH", path.join(Arkstack.rootDir(), `${dist}/config`));
-		try {
-			files = readdirSync(configDir, { withFileTypes: true }).filter((file) => {
-				if (file.name.includes("middleware") && globalThis.arkctx?.runtime === "CLI") return false;
-				return file.isFile() && (file.name.endsWith(".js") || file.name.endsWith(".ts"));
-			});
-		} catch {
-			files = [];
-		}
-		Object.assign(config, files.reduce((configs, file) => {
-			const configName = path.basename(file.name, path.extname(file.name));
-			configs[configName] = require(path.join(file.parentPath, file.name)).default(typeof globalThis.app === "function" ? globalThis.app() : {});
-			return configs;
-		}, {}));
-		globalThis[CONFIG_KEY] = config;
-	}
-	if (typeof key === "object" && key !== null) {
-		const config = Object.assign({}, Arr.dot(globalThis[CONFIG_KEY]), Arr.dot(key));
-		globalThis[CONFIG_KEY] = undot(config);
-	} else if (typeof key === "string") return Obj.get(globalThis[CONFIG_KEY], key, defaultValue);
-	return globalThis[CONFIG_KEY];
-};
-/**
-* Resolve the unified application key.
-*
-* `APP_KEY` (exposed as `config('app.key')`) is the single secret used for
-* signing and encryption across the framework. Resolution order:
-*
-*   1. An explicit `APP_KEY` environment variable.
-*   2. Any legacy environment variable(s) passed in, for backward compatibility
-*      with apps that predate `APP_KEY` (e.g. `JWT_SECRET`,
-*      `TWO_FACTOR_ENCRYPTION_KEY`).
-*   3. `config('app.key')` — the value from `src/config/app.ts`, which may itself
-*      be a placeholder default when no config is loaded.
-*
-* @param legacy  Legacy env var name(s) to fall back to.
-* @returns       The resolved key, or `undefined` when none is configured.
-*/
-const appKey = (legacy = []) => {
-	const explicit = env("APP_KEY");
-	if (explicit) return explicit;
-	for (const name of Array.isArray(legacy) ? legacy : [legacy]) {
-		const value = env(name);
-		if (value) return value;
-	}
-	return config("app.key") || void 0;
-};
-/**
-* Gets the current Node environment (development or production).
-*
-* @returns
-*/
-const nodeEnv = () => {
-	let envValue = env("NODE_ENV", "development");
-	if (envValue !== "development" && envValue !== "production") envValue = "development";
-	return envValue === "production" ? "prod" : "dev";
-};
-/**
-* Gets the output directory for the application based on the current environment.
-*
-* @param cwd  The current working directory (optional, defaults to Arkstack.rootDir()).
-* @returns
-*/
-const outputDir = (cwd) => {
-	cwd ??= Arkstack.rootDir();
-	const NODE_ENV = nodeEnv();
-	const output = {
-		dev: env("OUTPUT_DIR_DEV", ".arkstack/build"),
-		prod: env("OUTPUT_DIR", "dist")
-	};
-	return path.isAbsolute(output[NODE_ENV] ?? output.dev) ? output[NODE_ENV] ?? output.dev : path.join(cwd, output[NODE_ENV] ?? output.dev);
-};
-const SOURCE_DIR = "src";
-const SOURCE_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".mts",
-	".cts",
-	".js",
-	".mjs",
-	".cjs"
-];
-const OUTPUT_EXTENSIONS = [
-	".js",
-	".mjs",
-	".cjs",
-	".ts"
-];
-/** 
-* Strip a trailing known source/compiled extension from a path. 
-* 
-* @param value 
-* @returns 
-*/
-const stripKnownExtension = (value) => value.replace(/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i, "");
-/**
-* Build the list of concrete file candidates for a base path. Any existing
-* source/compiled extension is dropped first so the correct runtime extension
-* can be tried (e.g. a `.ts` source maps to a `.js` candidate under `dist`).
-* 
-* @param base 
-* @param extensions 
-* @returns 
-*/
-const moduleCandidates = (base, extensions) => {
-	const bare = stripKnownExtension(base);
-	return extensions.map((ext) => bare + ext);
-};
-/**
-* Map an application source path to its build-output counterpart.
-*
-* Application code is authored under `src/` and compiled into {@link outputDir},
-* which strips the leading `src/` segment and emits JavaScript (e.g.
-* `src/app/models/User.ts` -> `dist/app/models/User.js`). A TypeScript source
-* extension is rewritten to `.js`; paths without one (directories) keep their
-* shape. Absolute or root-relative paths outside the app root are returned
-* unchanged.
-*
-* This is a pure path transform — it does not touch the filesystem. Use
-* {@link resolveRuntimeModule} / {@link resolveRuntimeDir} when you need an
-* existing file/dir for the current environment.
-*
-* @param sourcePath  Absolute or root-relative source path.
-*/
-const toOutputPath = (sourcePath) => {
-	const root = Arkstack.rootDir();
-	const abs = path.isAbsolute(sourcePath) ? sourcePath : path.join(root, sourcePath);
-	const rel = path.relative(root, abs);
-	if (!rel || rel.startsWith("..")) return abs;
-	return path.join(outputDir(), rel.replace(new RegExp(`^${SOURCE_DIR}[\\\\/]`), "")).replace(/\.(ts|tsx|mts|cts)$/i, ".js");
-};
-/**
-* Resolve an application module's source path to a file that can be imported at
-* runtime.
-*
-* In development the TypeScript source is loaded directly (jiti compiles on the
-* fly); in production only the build output ships, so the path is remapped into
-* {@link outputDir} with a compiled extension. The first existing candidate
-* wins — production prefers the build output, development prefers source — so a
-* deploy that ships only `dist` never reaches for `src`.
-*
-* @param sourcePath  Absolute or root-relative source path, with or without extension.
-* @returns           An existing importable path, or `sourcePath` unchanged when none exists.
-*/
-const resolveRuntimeModule = (sourcePath) => {
-	const root = Arkstack.rootDir();
-	const abs = path.isAbsolute(sourcePath) ? sourcePath : path.join(root, sourcePath);
-	const sourceCandidates = moduleCandidates(abs, SOURCE_EXTENSIONS);
-	const outputCandidates = moduleCandidates(toOutputPath(abs), OUTPUT_EXTENSIONS);
-	return (nodeEnv() === "prod" ? [...outputCandidates, ...sourceCandidates] : [...sourceCandidates, ...outputCandidates]).find((candidate) => existsSync(candidate)) ?? abs;
-};
-/**
-* Resolve an application source directory to the directory that exists at
-* runtime.
-*
-* The directory counterpart of {@link resolveRuntimeModule}: it maps the source
-* directory into {@link outputDir} (stripping the leading `src/` segment) but
-* appends no file extension. Production prefers the build output, development
-* prefers source, and the absolute source path is returned when neither exists.
-*
-* @param sourcePath  Absolute or root-relative source directory.
-* @returns           An existing directory path, or the absolute source path when none exists.
-*/
-const resolveRuntimeDir = (sourcePath) => {
-	const root = Arkstack.rootDir();
-	const abs = path.isAbsolute(sourcePath) ? sourcePath : path.join(root, sourcePath);
-	const mapped = toOutputPath(abs);
-	return (nodeEnv() === "prod" ? [mapped, abs] : [abs, mapped]).find((candidate) => existsSync(candidate)) ?? abs;
-};
-/**
-* Rebuild the application output (tsdown) into {@link outputDir}, wiping it first
-* so no stale emitted modules survive a source change. Standalone — it does NOT
-* boot the app — so the console kernel can call it to self-heal a stale or
-* incomplete build artifact that would otherwise wedge startup. Build-only: it
-* sets `CLI_BUILD` so tsdown emits without starting a watcher/dev server, and
-* inherits the current `NODE_ENV` so it targets the same dir the kernel reads.
-*/
-const rebuildOutput = async () => {
-	await rm(outputDir(), {
-		recursive: true,
-		force: true
-	});
-	await new Promise((resolveBuild, reject) => {
-		const child = spawn(process.platform === "win32" ? "pnpm.cmd" : "pnpm", [
-			"exec",
-			"tsdown",
-			"--log-level",
-			"silent"
-		], {
-			cwd: Arkstack.rootDir(),
-			stdio: "inherit",
-			env: Object.assign({}, process.env, { CLI_BUILD: "true" })
-		});
-		child.on("error", reject);
-		child.on("exit", (code) => {
-			if (code === 0 || code === null) {
-				resolveBuild();
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`tsdown exited with code ${code}`));
-		});
-	});
-};
-/**
-* 
-* Dynamically imports a file at the given path with full TypeScript support,
-* including `tsconfig.json` path aliases. 
-*
-* @param filePath - The path to the file to import. 
-* @returns The imported module typed as `T`.
-*
-* @example
-* const config = await importFile<AppConfig>('./config/app.ts')
-*/
-const importFile = async (filePath, userOptions, resolveOptions) => {
-	const resolvedPath = resolve(filePath);
-	return await createJiti(pathToFileURL(resolvedPath).href, {
-		...userOptions,
-		interopDefault: false,
-		tsconfigPaths: true
-	}).import(resolvedPath, resolveOptions);
-};
-/**
-* Picks the command class out of an imported module. Prefers the export named
-* after the file (musket's discovery convention), then a default export, then
-* the first exported constructor it finds.
-*
-* @param mod        The imported module namespace.
-* @param basename   The file name without extension.
-* @returns          The resolved command class, or undefined when none is found.
-*/
-const resolveCommandExport = (mod, basename) => {
-	const named = mod[basename];
-	if (typeof named === "function") return named;
-	if (typeof mod.default === "function") return mod.default;
-	return Object.values(mod).find((value) => typeof value === "function");
-};
-/**
-* Discover console command classes from the application's command directory.
-*
-* Commands are loaded straight from TypeScript source through {@link importFile}
-* (jiti), so they are picked up without a build and reflect edits on every run.
-* The built output is only used as a fallback when the source directory is
-* absent — e.g. a production deploy that ships `dist` without `src`.
-*
-* This exists because musket's own glob discovery imports paths with native
-* `import()`, which silently skips `.ts` files — the reason commands previously
-* only appeared after a `build --dev` and never reflected later edits.
-*
-* @param subPath   Command directory relative to the app root (src/dist aware).
-* @returns         The discovered command classes.
-*/
-const discoverCommands = async (subPath = path.join("app", "console", "commands")) => {
-	const root = Arkstack.rootDir();
-	const sourceDir = path.join(root, SOURCE_DIR, subPath);
-	const outputCommandDir = path.join(outputDir(), subPath);
-	const candidateDirs = nodeEnv() === "prod" ? [outputCommandDir, sourceDir] : [sourceDir, outputCommandDir];
-	let commandsDir;
-	let files = [];
-	for (const dir of candidateDirs) try {
-		const entries = readdirSync(dir, { withFileTypes: true }).filter((file) => file.isFile() && [
-			".ts",
-			".js",
-			".mjs"
-		].includes(path.extname(file.name)));
-		if (entries.length > 0) {
-			commandsDir = dir;
-			files = entries;
-			break;
-		}
-	} catch {}
-	if (!commandsDir) return [];
-	const commands = [];
-	for (const file of files) {
-		const basename = path.basename(file.name, path.extname(file.name));
-		try {
-			const command = resolveCommandExport(await importFile(path.join(commandsDir, file.name)), basename);
-			if (command) commands.push(command);
-		} catch (error) {
-			console.error(`[arkstack] Failed to load command "${file.name}":`, error);
-		}
-	}
-	return commands;
-};
-/**
-* Resolves the default export from a module, handling both CJS and ESM interop.
-* In CJS modules, the default export is often the module itself (a function or object),
-* while in ESM the default is nested under the `default` property.
-*
-* @param imp - The imported module
-* @returns The resolved default export
-*/
-const interopDefault = (imp) => {
-	return typeof imp === "function" ? imp : imp.default;
-};
-//#endregion
-//#region src/utils/encryption.ts
-var Encryption = class {
-	static algorithm = "aes-256-gcm";
-	static getKey() {
-		const secret = appKey("TWO_FACTOR_ENCRYPTION_KEY");
-		if (!secret) throw new Error("APP_KEY is required to use two-factor authentication. Run `ark key:generate`.");
-		return createHash("sha256").update(secret).digest();
-	}
-	static encrypt(value) {
-		const iv = randomBytes(12);
-		const cipher = createCipheriv(this.algorithm, this.getKey(), iv);
-		const ciphertext = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
-		return [
-			iv,
-			cipher.getAuthTag(),
-			ciphertext
-		].map((part) => part.toString("base64url")).join(":");
-	}
-	static decrypt(payload) {
-		const [iv, authTag, ciphertext] = payload.split(":");
-		if (!iv || !authTag || !ciphertext) throw new Error("Invalid encrypted payload format");
-		const decipher = createDecipheriv(this.algorithm, this.getKey(), Buffer.from(iv, "base64url"));
-		decipher.setAuthTag(Buffer.from(authTag, "base64url"));
-		return Buffer.concat([decipher.update(Buffer.from(ciphertext, "base64url")), decipher.final()]).toString("utf8");
-	}
-};
-//#endregion
-//#region src/utils/hash.ts
-var Hash = class {
-	/**
-	* Hash a value using bcrypt
-	* 
-	* @param value 
-	* @returns 
-	*/
-	static async make(value) {
-		return await hash(value, await genSalt(10));
-	}
-	/**
-	* Verify a value against a hashed value
-	* 
-	* @param value 
-	* @param hashedValue 
-	* @returns 
-	*/
-	static async verify(value, hashedValue) {
-		return await compare(value, hashedValue);
-	}
-	/**
-	* Generate a one-time password (OTP) using TOTP algorithm
-	* 
-	* @param digits    The number of digits for the OTP, default is 6.
-	* @param label     A label to identify the OTP, can be an email or phone number.
-	* @param period    Interval of time for which a token is valid, in seconds.
-	* @returns 
-	*/
-	static otp(digits = 6, label = "Alice", period = 30) {
-		return new TOTP({
-			label,
-			digits,
-			issuer: env("APP_NAME", "Roseed"),
-			algorithm: "SHA1",
-			period,
-			secret: "US3WHSG7X5KAPV27VANWKQHF3SH3HULL"
-		});
-	}
-	static totp(secret, label, issuer = env("APP_NAME", "Roseed"), period = 30) {
-		return new TOTP({
-			issuer,
-			label,
-			algorithm: "SHA1",
-			digits: 6,
-			period,
-			secret: Secret.fromBase32(secret)
-		});
-	}
-};
-//#endregion
-//#region src/Exceptions/Exception.ts
-var Exception = class extends Error {
-	name;
-	constructor(message, options) {
-		super(message, options);
-		this.name = "Exception";
-	}
-};
-//#endregion
-//#region src/Exceptions/AppException.ts
-var AppException = class extends Exception {
-	errors = void 0;
-	statusCode;
-	constructor(message, statusCode = 400, options) {
-		super(message, options);
-		this.statusCode = statusCode;
-	}
-};
-//#endregion
-//#region src/Exceptions/RequestException.ts
-var RequestException = class RequestException extends AppException {
-	statusCode;
-	constructor(message, statusCode = 400, options) {
-		super(message, statusCode, options);
-		this.statusCode = statusCode;
-	}
-	/**
-	* Asserts that a value is not null or undefined. 
-	* 
-	* @param value 
-	* @param message 
-	* @param code 
-	* @throws {RequestException} Throws if the value is null or undefined.
-	*/
-	static assertFound(value, message, code = 404) {
-		if (!value) throw new RequestException(message, code);
-	}
-	/**
-	* Asserts that a value is not null or undefined. 
-	* 
-	* @param value 
-	* @param message 
-	* @param code 
-	* @throws {RequestException} Throws if the value is null or undefined.
-	* @deprecated Use assertFound instead
-	*/
-	static assertNotEmpty(value, message, code = 404) {
-		return this.assertFound(value, message, code);
-	}
-	/**
-	* Asserts that a boolean condition is true. 
-	* 
-	* @param boolean 
-	* @param message 
-	* @param code 
-	* @throws {RequestException} Throws if the boolean condition is true.
-	*/
-	static abortIf(boolean, message, code) {
-		if (boolean) throw new RequestException(message, code);
-	}
-};
-//#endregion
-//#region src/utils/helpers.ts
-/**
-* Checks and asserts if target is a class
-* 
-* @param target 
-* @returns 
-*/
-const isClass = (target) => {
-	return typeof target === "function" && /^class\s/.test(Function.prototype.toString.call(target));
-};
-/**
-* Determine the number of items to return per page based on the provided query parameters.
-* 
-* @param query 
-* @returns 
-*/
-const perPage = (query) => {
-	const requestedPerPage = Number(query.limit ?? query.perPage ?? 15);
-	return Number.isFinite(requestedPerPage) && requestedPerPage > 0 ? Math.min(requestedPerPage, 50) : 15;
-};
-async function getModel(modelName) {
-	const resolveModelExport = (module, modelName) => {
-		if (!isModelModule(module)) return module;
-		return module.default ?? module[modelName] ?? module;
-	};
-	const isModelModule = (value) => typeof value === "object" && value !== null;
-	const modelPath = getUserConfig().paths?.models || "./src/models";
-	const model = resolveModelExport(await importFile(resolveRuntimeModule(path.join(path.isAbsolute(modelPath) ? modelPath : path.join(Arkstack.rootDir(), modelPath), modelName))), path.basename(modelName, path.extname(modelName)));
-	if (typeof model !== "function") throw new Error(`Model "${modelName}" not found`);
-	return model;
-}
-const initializeGlobalContext = async ({ Request, Response, Session } = {}) => {
-	try {
-		const { Request: Req, Response: Res, Session: Ses } = await import("@arkstack/http");
-		Session ??= new Ses();
-		Request ??= new Req();
-		Response ??= new Res();
-	} catch {
-		Session ??= new class {}();
-		Request ??= new class {}();
-		Response ??= new class {}();
-	}
-	globalThis.session ??= () => Session;
-	globalThis.request ??= () => Request;
-	globalThis.response ??= () => Response;
-};
-/**
-* Thows to abort the current request
-* 
-* @param message 
-* @param code 
-* @throws {RequestException}
-*/
-const abort = (message = "Request Aborted", code = 404) => {
-	RequestException.abortIf(true, message, code);
-};
-/**
-* Asserts that a boolean condition is true. 
-* 
-* @param boolean 
-* @param message 
-* @param code 
-* @throws {RequestException} Throws if the boolean condition is true.
-*/
-const abortIf = (boolean, message = "Request Aborted", code = 404) => {
-	RequestException.abortIf(boolean, message, code);
-};
-/**
-* Asserts that a value is not null or undefined. 
-* 
-* @param value 
-* @param message 
-* @param code 
-* @throws {RequestException} Throws if the value is null or undefined.
-*/
-const assertFound = (value, message, code = 404) => {
-	if (!value) throw new RequestException(message, code);
-};
-//#endregion
-//#region src/utils/traits.ts
-/**
-* CRC32 implementation in TypeScript, adapted from https://stackoverflow.com/a/18639999
-* Note: This implementation is not cryptographically secure and is only used for generating 
-* unique identifiers for traits based on their factory function's string representation. 
-*/
-const crcTable = [];
-for (let n = 0; n < 256; n++) {
-	let c = n;
-	for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-	crcTable[n] = c;
-}
-const crc32 = (str) => {
-	let crc = -1;
-	for (let i = 0; i < str.length; i++) crc = crc >>> 8 ^ crcTable[(crc ^ str.charCodeAt(i)) & 255];
-	return (crc ^ -1) >>> 0;
-};
-const isCons = (fn) => typeof fn === "function" && !!fn.prototype && !!fn.prototype.constructor;
-const isArkormModelInstance = (value) => typeof value === "object" && value !== null && typeof value.constructor === "function" && typeof value.getAttribute === "function" && typeof value.setAttribute === "function";
-const isTypeFactory = (fn) => typeof fn === "function" && !fn.prototype && fn.length === 0;
-/**
-* API: generate trait (technical implementation)
-* 
-* @param args 
-*/
-function trait(...args) {
-	const factory = args.length === 2 ? args[1] : args[0];
-	const superTraits = args.length === 2 ? args[0] : void 0;
-	return {
-		id: crc32(factory.toString()),
-		symbol: Symbol("trait"),
-		factory,
-		superTraits
-	};
-}
-/**
-* utility function: add an additional invisible property to an object
-* 
-* @param cons 
-* @param field 
-* @param value 
-* @returns 
-*/
-const extendProperties = (cons, field, value) => Object.defineProperty(cons, field, {
-	value,
-	enumerable: false,
-	writable: false
-});
-const traitMethodRegistry = Symbol("trait-method-registry");
-const cloneMethodRegistry = (target) => {
-	const registry = target[traitMethodRegistry];
-	return new Map([...registry?.entries() ?? []].map(([name, methods]) => [name, [...methods]]));
-};
-const registerMethodScope = (target, base, ignored) => {
-	const registry = cloneMethodRegistry(base);
-	for (const name of Reflect.ownKeys(target)) {
-		if (ignored.has(name)) continue;
-		const method = Object.getOwnPropertyDescriptor(target, name)?.value;
-		if (typeof method !== "function") continue;
-		const methods = registry.get(name);
-		const previous = base?.[name];
-		if (methods) {
-			if (methods.at(-1) !== method) methods.push(method);
-			registry.set(name, methods);
-		} else if (typeof previous === "function" && previous !== method) registry.set(name, [previous, method]);
-	}
-	Object.defineProperty(target, traitMethodRegistry, {
-		configurable: false,
-		enumerable: false,
-		value: registry,
-		writable: false
-	});
-};
-/**
-* Registers conflicting trait methods
-* 
-* @param classInstance 
-* @param baseClass 
-*/
-const registerTraitMethods = (classInstance, baseClass) => {
-	registerMethodScope(classInstance.prototype, baseClass.prototype, new Set(["constructor"]));
-	registerMethodScope(classInstance, baseClass, new Set([
-		"length",
-		"name",
-		"prototype",
-		"arguments",
-		"caller"
-	]));
-};
-/**
-* Return every trait implementation for a method, bound to the supplied
-* instance or class. Methods are ordered from the base implementation to the
-* currently active trait implementation.
-* 
-* @param target 
-* @param name 
-* @returns 
-*/
-const getTraitMethods = (target, name) => {
-	return (((typeof target === "function" ? target : Object.getPrototypeOf(target))?.[traitMethodRegistry])?.get(name) ?? []).map((method) => method.bind(target));
-};
-/**
-* Invoke every trait implementation for a method in registration order.
-* 
-* @param target 
-* @param name 
-* @param args 
-* @returns 
-*/
-const callTraitMethods = (target, name, ...args) => {
-	const methods = getTraitMethods(target, name);
-	if (methods.length === 0) {
-		console.warn(`No conflicting trait methods found for "${String(name)}".`);
-		return [];
-	}
-	return methods.map((method) => method(...args));
-};
-/**
-* utility function: get raw trait
-* 
-* @param x 
-* @returns 
-*/
-const rawTrait = (x) => isTypeFactory(x) ? x() : x;
-/**
-* utility function: derive a trait
-* 
-* @param trait$ 
-* @param baseClass 
-* @param derived 
-* @returns 
-*/
-const deriveTrait = (trait$, baseClass, derived) => {
-	const trait = rawTrait(trait$);
-	if (trait === void 0 || trait === null || typeof trait.id !== "number") throw new Error("use(): received an undefined or invalid trait. This usually means a circular import — the trait module had not finished initializing when use() ran. Avoid importing models at the top level of trait modules, or break the import cycle.");
-	let classInstance = baseClass;
-	if (!derived.has(trait.id)) {
-		derived.set(trait.id, true);
-		if (trait.superTraits !== void 0) for (const superTrait of reverseTraitList(trait.superTraits)) classInstance = deriveTrait(superTrait, classInstance, derived);
-		const base = classInstance;
-		classInstance = trait.factory(classInstance);
-		registerTraitMethods(classInstance, base);
-		extendProperties(classInstance, "id", crc32(trait.factory.toString()));
-		extendProperties(classInstance, trait.symbol, true);
-	}
-	return classInstance;
-};
-/**
-* utility function: get reversed trait list
-* 
-* @param traits 
-* @returns 
-*/
-const reverseTraitList = (traits) => traits.slice().reverse();
-function use(...args) {
-	const withMethodHelpers = args[0] === true;
-	const traits = withMethodHelpers ? args.slice(1) : args;
-	if (traits.length === 0) throw new Error("invalid number of parameters (expected one or more traits)");
-	let classInstance;
-	let lot;
-	const last = traits[traits.length - 1];
-	if (isCons(last) && !isTypeFactory(last)) {
-		classInstance = last;
-		lot = traits.slice(0, -1);
-	} else if (isArkormModelInstance(last)) {
-		classInstance = last.constructor;
-		lot = traits.slice(0, -1);
-	} else {
-		classInstance = class ROOT {};
-		lot = traits;
-	}
-	const derived = /* @__PURE__ */ new Map();
-	for (const trait of reverseTraitList(lot)) classInstance = deriveTrait(trait, classInstance, derived);
-	if (withMethodHelpers) classInstance = class TraitMethodEnabled extends classInstance {
-		getTraitMethods(name) {
-			return getTraitMethods(this, name);
-		}
-		callTraitMethods(name, ...args) {
-			return callTraitMethods(this, name, ...args);
-		}
-		static getTraitMethods(name) {
-			return getTraitMethods(this, name);
-		}
-		static callTraitMethods(name, ...args) {
-			return callTraitMethods(this, name, ...args);
-		}
-	};
-	return classInstance;
-}
-/**
-* API: type guard for checking whether class instance is derived from a trait
-* 
-* @param instance 
-* @param trait 
-* @returns 
-*/
-function uses(instance, trait) {
-	if (typeof instance !== "object" || instance === null) return false;
-	let obj = instance;
-	if (isCons(trait) && !isTypeFactory(trait)) return instance instanceof trait;
-	const idTrait = (isTypeFactory(trait) ? trait() : trait)["id"];
-	while (obj) {
-		if (Object.hasOwn(obj, "constructor")) {
-			if ((obj.constructor["id"] ?? 0) === idTrait) return true;
-		}
-		obj = Object.getPrototypeOf(obj);
-	}
-	return false;
-}
-//#endregion
-export { resolveRuntimeDir as A, discoverCommands as C, nodeEnv as D, interopDefault as E, toOutputPath as M, outputDir as O, config as S, importFile as T, Hash as _, use as a, appKey as b, abortIf as c, initializeGlobalContext as d, isClass as f, Exception as g, AppException as h, trait as i, resolveRuntimeModule as j, rebuildOutput as k, assertFound as l, RequestException as m, crc32 as n, uses as o, perPage as p, getTraitMethods as r, abort as s, callTraitMethods as t, getModel as u, Encryption as v, env as w, appUrl as x, CONFIG_KEY as y };