hackmud-script-manager 0.19.1-3ef8894 → 0.19.1-531ddb2

package/pull.js

@@ -1,6 +1,6 @@
 import { copyFilePersistent } from "@samual/lib/copyFilePersistent"
 import { resolve } from "path"
-const pull = async (sourceFolderPath, hackmudPath, script) => {
+async function pull(sourceFolderPath, hackmudPath, script) {
 	const [user, name] = script.split(".")
 	if (!user || !name) throw Error('`script` argument must be in "user.name" format')
 	await copyFilePersistent(

package/push.js

@@ -1,7 +1,8 @@
 import { Cache } from "@samual/lib/Cache"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
+import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
-import { readFile, readdir, stat } from "fs/promises"
+import { readFile } from "fs/promises"
 import { basename, resolve, extname } from "path"
 import { supportedExtensions } from "./constants.js"
 import { processScript } from "./processScript/index.js"
@@ -41,240 +42,228 @@ import "./processScript/preprocess.js"
 import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
-const readDirectoryWithStats = async path =>
-		Promise.all(
-			(await readdir(path)).map(async name => {
-				const resolvedPath = resolve(path, name)
-				return { path: resolvedPath, name, stats: await stat(resolvedPath) }
-			})
-		),
-	push = async (
-		sourceDirectory,
-		hackmudDirectory,
-		{ scripts = ["*.*"], onPush = () => {}, minify = !0, mangleNames = !1, forceQuineCheats } = {}
-	) => {
-		const scriptNamesByUser = new Cache(_user => new Set()),
-			wildScriptUsers = new Set(),
-			wildUserScripts = new Set()
-		let pushEverything = !1
-		for (const fullScriptName of scripts) {
-			const [user, scriptName] = fullScriptName.split(".")
-			user && "*" != user ?
-				scriptName && "*" != scriptName ?
-					scriptNamesByUser.get(user).add(scriptName)
-				:	wildScriptUsers.add(user)
-			: scriptName && "*" != scriptName ? wildUserScripts.add(scriptName)
-			: (pushEverything = !0)
-		}
-		const usersByGlobalScriptsToPush = new Cache(_user => new Set()),
-			allInfo = [],
-			scriptNamesAlreadyPushedByUser = new Cache(_user => new Set())
-		let sourceDirectoryDirents
-		if (wildUserScripts.size || pushEverything) {
-			let hackmudDirectoryEntries
-			;[hackmudDirectoryEntries, sourceDirectoryDirents] = await Promise.all([
-				readDirectoryWithStats(hackmudDirectory),
-				readDirectoryWithStats(sourceDirectory)
-			])
-			const allUsers = new Set([
-				...sourceDirectoryDirents.filter(({ stats }) => stats.isDirectory()).map(({ path }) => basename(path)),
-				...hackmudDirectoryEntries.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
-				...hackmudDirectoryEntries
-					.filter(({ name, stats }) => stats.isFile() && name.endsWith(".key"))
-					.map(({ name }) => name.slice(0, -4)),
-				...scriptNamesByUser.keys(),
-				...wildScriptUsers
-			])
-			if (pushEverything) for (const user of allUsers) wildScriptUsers.add(user)
-			else
-				for (const user of allUsers) {
-					const scriptNames = scriptNamesByUser.get(user)
-					for (const scriptName of wildUserScripts) scriptNames.add(scriptName)
-				}
-		}
-		await Promise.all(
-			[...wildScriptUsers].map(async user => {
-				await readDirectoryWithStats(resolve(sourceDirectory, user)).then(
-					async entries => {
-						await Promise.all(
-							entries.map(async ({ stats, name, path }) => {
-								if (name.endsWith(".d.ts")) return
-								const extension = extname(name)
-								if (stats.isFile() && supportedExtensions.includes(extension)) {
-									const scriptName = basename(name, extension),
-										{ script: minifiedCode } = await processScript(
-											await readFile(path, { encoding: "utf-8" }),
-											{
-												minify,
-												scriptUser: user,
-												scriptName,
-												filePath: path,
-												mangleNames,
-												forceQuineCheats
-											}
-										),
-										info = {
-											file: `${user}/${name}`,
-											users: [user],
-											minLength: countHackmudCharacters(minifiedCode),
-											error: void 0
+async function push(
+	sourceDirectory,
+	hackmudDirectory,
+	{ scripts = ["*.*"], onPush = () => {}, minify = !0, mangleNames = !1, forceQuineCheats } = {}
+) {
+	const scriptNamesByUser = new Cache(_user => new Set()),
+		wildScriptUsers = new Set(),
+		wildUserScripts = new Set()
+	let pushEverything = !1
+	for (const fullScriptName of scripts) {
+		const [user, scriptName] = fullScriptName.split(".")
+		user && "*" != user ?
+			scriptName && "*" != scriptName ?
+				scriptNamesByUser.get(user).add(scriptName)
+			:	wildScriptUsers.add(user)
+		: scriptName && "*" != scriptName ? wildUserScripts.add(scriptName)
+		: (pushEverything = !0)
+	}
+	const usersByGlobalScriptsToPush = new Cache(_user => new Set()),
+		allInfo = [],
+		scriptNamesAlreadyPushedByUser = new Cache(_user => new Set())
+	let sourceDirectoryDirents
+	if (wildUserScripts.size || pushEverything) {
+		let hackmudDirectoryEntries
+		;[hackmudDirectoryEntries, sourceDirectoryDirents] = await Promise.all([
+			readDirectoryWithStats(hackmudDirectory),
+			readDirectoryWithStats(sourceDirectory)
+		])
+		const allUsers = new Set([
+			...sourceDirectoryDirents.filter(({ stats }) => stats.isDirectory()).map(({ path }) => basename(path)),
+			...hackmudDirectoryEntries.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
+			...hackmudDirectoryEntries
+				.filter(({ name, stats }) => stats.isFile() && name.endsWith(".key"))
+				.map(({ name }) => name.slice(0, -4)),
+			...scriptNamesByUser.keys(),
+			...wildScriptUsers
+		])
+		if (pushEverything) for (const user of allUsers) wildScriptUsers.add(user)
+		else
+			for (const user of allUsers) {
+				const scriptNames = scriptNamesByUser.get(user)
+				for (const scriptName of wildUserScripts) scriptNames.add(scriptName)
+			}
+	}
+	await Promise.all(
+		[...wildScriptUsers].map(async user => {
+			await readDirectoryWithStats(resolve(sourceDirectory, user)).then(
+				async entries => {
+					await Promise.all(
+						entries.map(async ({ stats, name, path }) => {
+							if (name.endsWith(".d.ts")) return
+							const extension = extname(name)
+							if (stats.isFile() && supportedExtensions.includes(extension)) {
+								const scriptName = basename(name, extension),
+									{ script: minifiedCode } = await processScript(
+										await readFile(path, { encoding: "utf-8" }),
+										{
+											minify,
+											scriptUser: user,
+											scriptName,
+											filePath: path,
+											mangleNames,
+											forceQuineCheats
 										}
-									scriptNamesAlreadyPushedByUser.get(user).add(scriptName)
-									allInfo.push(info)
-									await writeFilePersistent(
-										resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
-										minifiedCode
-									)
-									onPush(info)
-								}
-							})
-						)
-					},
-					error => {
-						if ("ENOENT" != error.code) throw error
-					}
-				)
-			})
-		)
-		await Promise.all(
-			[...scriptNamesByUser].map(async ([user, scripts]) => {
-				wildScriptUsers.has(user) ||
-					(await Promise.all(
-						[...scripts].map(async scriptName => {
-							let code, fileName, filePath
-							for (const extension of supportedExtensions)
-								try {
-									fileName = `${scriptName}${extension}`
-									code = await readFile((filePath = resolve(sourceDirectory, user, fileName)), {
-										encoding: "utf-8"
-									})
-									break
-								} catch {}
-							if (code) {
-								const { script: minifiedCode } = await processScript(code, {
-										minify,
-										scriptUser: user,
-										scriptName,
-										filePath,
-										mangleNames,
-										forceQuineCheats
-									}),
+									),
 									info = {
-										file: `${user}/${fileName}`,
+										file: `${user}/${name}`,
 										users: [user],
 										minLength: countHackmudCharacters(minifiedCode),
 										error: void 0
 									}
+								scriptNamesAlreadyPushedByUser.get(user).add(scriptName)
 								allInfo.push(info)
 								await writeFilePersistent(
-									resolve(hackmudDirectory, user, "scripts", scriptName + ".js"),
+									resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
 									minifiedCode
 								)
 								onPush(info)
-							} else usersByGlobalScriptsToPush.get(scriptName).add(user)
+							}
 						})
-					))
-			})
-		)
-		await (wildScriptUsers.size ?
-			Promise.all(
-				(sourceDirectoryDirents || (await readDirectoryWithStats(sourceDirectory))).map(
-					async ({ path, stats, name }) => {
-						if (name.endsWith(".d.ts")) return
-						const extension = extname(name)
-						if (!stats.isFile() || !supportedExtensions.includes(extension)) return
-						const scriptName = basename(name, extension),
-							usersToPushTo = [...wildScriptUsers, ...usersByGlobalScriptsToPush.get(scriptName)].filter(
-								user => !scriptNamesAlreadyPushedByUser.get(user).has(scriptName)
-							)
-						if (!usersToPushTo.length) return
-						const uniqueID = Math.floor(Math.random() * 2 ** 52)
-								.toString(36)
-								.padStart(11, "0"),
-							{ script: minifiedCode } = await processScript(
-								await readFile(path, { encoding: "utf-8" }),
-								{
+					)
+				},
+				error => {
+					if ("ENOENT" != error.code) throw error
+				}
+			)
+		})
+	)
+	await Promise.all(
+		[...scriptNamesByUser].map(async ([user, scripts]) => {
+			wildScriptUsers.has(user) ||
+				(await Promise.all(
+					[...scripts].map(async scriptName => {
+						let code, fileName, filePath
+						for (const extension of supportedExtensions)
+							try {
+								fileName = `${scriptName}${extension}`
+								code = await readFile((filePath = resolve(sourceDirectory, user, fileName)), {
+									encoding: "utf-8"
+								})
+								break
+							} catch {}
+						if (code) {
+							const { script: minifiedCode } = await processScript(code, {
 									minify,
-									scriptUser: !0,
+									scriptUser: user,
 									scriptName,
-									uniqueID,
-									filePath: path,
+									filePath,
 									mangleNames,
 									forceQuineCheats
+								}),
+								info = {
+									file: `${user}/${fileName}`,
+									users: [user],
+									minLength: countHackmudCharacters(minifiedCode),
+									error: void 0
 								}
-							),
-							info = {
-								file: name,
-								users: usersToPushTo,
-								minLength: countHackmudCharacters(minifiedCode),
-								error: void 0
-							}
-						await Promise.all(
-							usersToPushTo.map(user =>
-								writeFilePersistent(
-									resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
-									minifiedCode
-										.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
-										.replace(
-											RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
-											`${user}.${scriptName}`
-										)
-								)
+							allInfo.push(info)
+							await writeFilePersistent(
+								resolve(hackmudDirectory, user, "scripts", scriptName + ".js"),
+								minifiedCode
 							)
+							onPush(info)
+						} else usersByGlobalScriptsToPush.get(scriptName).add(user)
+					})
+				))
+		})
+	)
+	await (wildScriptUsers.size ?
+		Promise.all(
+			(sourceDirectoryDirents || (await readDirectoryWithStats(sourceDirectory))).map(
+				async ({ path, stats, name }) => {
+					if (name.endsWith(".d.ts")) return
+					const extension = extname(name)
+					if (!stats.isFile() || !supportedExtensions.includes(extension)) return
+					const scriptName = basename(name, extension),
+						usersToPushTo = [...wildScriptUsers, ...usersByGlobalScriptsToPush.get(scriptName)].filter(
+							user => !scriptNamesAlreadyPushedByUser.get(user).has(scriptName)
 						)
-						allInfo.push(info)
-						onPush(info)
-					}
-				)
+					if (!usersToPushTo.length) return
+					const uniqueID = Math.floor(Math.random() * 2 ** 52)
+							.toString(36)
+							.padStart(11, "0"),
+						{ script: minifiedCode } = await processScript(await readFile(path, { encoding: "utf-8" }), {
+							minify,
+							scriptUser: !0,
+							scriptName,
+							uniqueID,
+							filePath: path,
+							mangleNames,
+							forceQuineCheats
+						}),
+						info = {
+							file: name,
+							users: usersToPushTo,
+							minLength: countHackmudCharacters(minifiedCode),
+							error: void 0
+						}
+					await Promise.all(
+						usersToPushTo.map(user =>
+							writeFilePersistent(
+								resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
+								minifiedCode
+									.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
+									.replace(
+										RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
+										`${user}.${scriptName}`
+									)
+							)
+						)
+					)
+					allInfo.push(info)
+					onPush(info)
+				}
 			)
-		:	Promise.all(
-				[...usersByGlobalScriptsToPush].map(async ([scriptName, users]) => {
-					let code, fileName, filePath
-					for (const extension of supportedExtensions)
-						try {
-							fileName = `${scriptName}${extension}`
-							code = await readFile((filePath = resolve(sourceDirectory, fileName)), {
-								encoding: "utf-8"
-							})
-							break
-						} catch {}
-					if (code) {
-						const uniqueID = Math.floor(Math.random() * 2 ** 52)
-								.toString(36)
-								.padStart(11, "0"),
-							{ script: minifiedCode } = await processScript(code, {
-								minify,
-								scriptUser: !0,
-								scriptName,
-								uniqueID,
-								filePath,
-								mangleNames,
-								forceQuineCheats
-							}),
-							info = {
-								file: fileName,
-								users: [...users],
-								minLength: countHackmudCharacters(minifiedCode),
-								error: void 0
-							}
-						await Promise.all(
-							[...users].map(user =>
-								writeFilePersistent(
-									resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
-									minifiedCode
-										.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
-										.replace(
-											RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
-											`${user}.${scriptName}`
-										)
-								)
+		)
+	:	Promise.all(
+			[...usersByGlobalScriptsToPush].map(async ([scriptName, users]) => {
+				let code, fileName, filePath
+				for (const extension of supportedExtensions)
+					try {
+						fileName = `${scriptName}${extension}`
+						code = await readFile((filePath = resolve(sourceDirectory, fileName)), { encoding: "utf-8" })
+						break
+					} catch {}
+				if (code) {
+					const uniqueID = Math.floor(Math.random() * 2 ** 52)
+							.toString(36)
+							.padStart(11, "0"),
+						{ script: minifiedCode } = await processScript(code, {
+							minify,
+							scriptUser: !0,
+							scriptName,
+							uniqueID,
+							filePath,
+							mangleNames,
+							forceQuineCheats
+						}),
+						info = {
+							file: fileName,
+							users: [...users],
+							minLength: countHackmudCharacters(minifiedCode),
+							error: void 0
+						}
+					await Promise.all(
+						[...users].map(user =>
+							writeFilePersistent(
+								resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
+								minifiedCode
+									.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
+									.replace(
+										RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
+										`${user}.${scriptName}`
+									)
 							)
 						)
-						allInfo.push(info)
-						onPush(info)
-					}
-				})
-			))
-		return allInfo
-	}
+					)
+					allInfo.push(info)
+					onPush(info)
+				}
+			})
+		))
+	return allInfo
+}
 export { push as default, push }

package/src/generateTypeDeclaration.d.ts

@@ -0,0 +1,2 @@
+export declare function generateTypeDeclaration(sourceDirectory: string, hackmudPath?: string): Promise<string>;
+export default generateTypeDeclaration;

package/src/processScript/index.d.ts

@@ -0,0 +1,31 @@
+import type { LaxPartial } from "@samual/lib";
+export { minify } from "./minify";
+export { postprocess } from "./postprocess";
+export { preprocess } from "./preprocess";
+export { transform } from "./transform";
+export type ProcessOptions = {
+    /** whether to minify the given code */ minify: boolean;
+    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** the user going to be hosting this script (or set to `true` if not yet known) */ scriptUser: string | true;
+    /** the name of this script (or set to `true` if not yet known) */ scriptName: string | true;
+    filePath: string;
+    /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
+    /** when set to `true` forces use of quine cheats
+      *
+      * when set to `false` forces quine cheats not to be used
+      *
+      * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
+      */
+    forceQuineCheats: boolean;
+};
+/** Minifies a given script
+  * @param code JavaScript or TypeScript code
+  * @param options {@link ProcessOptions details} */
+export declare function processScript(code: string, { minify: shouldMinify, uniqueID, scriptUser, scriptName, filePath, mangleNames, forceQuineCheats }?: LaxPartial<ProcessOptions>): Promise<{
+    script: string;
+    warnings: {
+        message: string;
+        line: number;
+    }[];
+}>;
+export default processScript;

package/src/processScript/minify.d.ts

@@ -0,0 +1,18 @@
+import type { File } from "@babel/types";
+import type { LaxPartial } from "@samual/lib";
+type MinifyOptions = {
+    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
+    /** when set to `true` forces use of quine cheats
+      *
+      * when set to `false` forces quine cheats not to be used
+      *
+      * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
+      */
+    forceQuineCheats: boolean;
+    /** the comment inserted after the function signature */ autocomplete: string;
+};
+/** @param file babel ast node representing a file containing transformed code
+  * @param options {@link MinifyOptions details} */
+export declare function minify(file: File, { uniqueID, mangleNames, forceQuineCheats, autocomplete }?: LaxPartial<MinifyOptions>): Promise<string>;
+export default minify;

package/src/processScript/preprocess.d.ts

@@ -0,0 +1,9 @@
+export type PreprocessOptions = {
+    /** 11 a-z 0-9 characters */ uniqueID: string;
+};
+/** @param code source code for preprocessing
+  * @param options {@link PreprocessOptions details} */
+export declare function preprocess(code: string, { uniqueID }?: Partial<PreprocessOptions>): Promise<{
+    code: string;
+}>;
+export default preprocess;

package/{processScript → src/processScript}/shared.d.ts

@@ -1,5 +1,5 @@
 import type { NodePath } from "@babel/traverse";
 import type { Identifier, Program } from "@babel/types";
-export declare const getReferencePathsToGlobal: (name: string, program: NodePath<Program>) => NodePath<Identifier>[];
+export declare function getReferencePathsToGlobal(name: string, program: NodePath<Program>): NodePath<Identifier>[];
 export declare const includesIllegalString: (toCheck: string) => boolean;
 export declare const replaceUnsafeStrings: (uniqueID: string, toReplace: string) => string;

package/src/processScript/transform.d.ts

@@ -0,0 +1,18 @@
+import type { File } from "@babel/types";
+export type TransformOptions = {
+    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** the user going to be hosting this script (or set to `true` if not yet known) */ scriptUser: string | true;
+    /** the name of this script (or set to `true` if not yet known) */ scriptName: string | true;
+    seclevel: number;
+};
+/** transform a given babel `File` to be hackmud compatible
+  *
+  * (returned File will need `postprocess()`ing)
+  * @param file babel ast node representing a file containing preprocessed code
+  * @param sourceCode the original untouched source code
+  * @param options {@link TransformOptions details} */
+export declare function transform(file: File, sourceCode: string, { uniqueID, scriptUser, scriptName, seclevel }?: Partial<TransformOptions>): {
+    file: File;
+    seclevel: number;
+};
+export default transform;

package/src/pull.d.ts

@@ -0,0 +1,6 @@
+/** Copies script from hackmud to local source folder.
+  * @param sourceFolderPath path to folder containing source files
+  * @param hackmudPath path to hackmud directory
+  * @param script to pull in `user.name` format */
+export declare function pull(sourceFolderPath: string, hackmudPath: string, script: string): Promise<void>;
+export default pull;

package/src/push.d.ts

@@ -0,0 +1,29 @@
+import type { LaxPartial } from "@samual/lib";
+import type { Info } from ".";
+export type PushOptions = {
+    /** whether to do the minify step (defaults to `true`) */ minify: boolean;
+    /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
+    /** array of scripts in the format `foo.bar`
+      *
+      * also accepts wild card (`*`) e.g. `*.bar` or `foo.*`
+      *
+      * pushes everything by default (`*.*`) */
+    scripts: string[];
+    /** callback called on script push */ onPush: (info: Info) => void;
+    /** when set to `true` forces use of quine cheats
+      *
+      * when set to `false` forces quine cheats not to be used
+      *
+      * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
+      */
+    forceQuineCheats: boolean;
+};
+/** Push scripts from a source directory to the hackmud directory.
+  *
+  * Pushes files directly in the source folder to all users
+  * @param sourceDirectory directory containing source code
+  * @param hackmudDirectory directory created by hackmud containing user data including scripts
+  * @param options {@link PushOptions details}
+  * @returns array of info on pushed scripts */
+export declare function push(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: LaxPartial<PushOptions>): Promise<Info[]>;
+export default push;

package/{syncMacros.d.ts → src/syncMacros.d.ts}

@@ -1,4 +1,4 @@
-export declare const syncMacros: (hackmudPath: string) => Promise<{
+export declare function syncMacros(hackmudPath: string): Promise<{
     macrosSynced: number;
     usersSynced: number;
 }>;

package/src/watch.d.ts

@@ -0,0 +1,15 @@
+import type { LaxPartial } from "@samual/lib";
+import type { PushOptions } from "./push";
+export type WatchOptions = PushOptions & {
+    /** if provided, will write typescript type declarations for all the scripts on every change detected
+      *
+      * writing the type declarations enables interscript type checking and autocompletetes for the args */
+    typeDeclarationPath: string;
+    onReady: () => void;
+};
+/** Watches target file or folder for updates and builds and pushes updated file.
+  * @param sourceDirectory path to folder containing source files
+  * @param hackmudDirectory path to hackmud directory
+  * @param options {@link WatchOptions details} and {@link PushOptions more details} */
+export declare function watch(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, typeDeclarationPath: typeDeclarationPath_, onReady, forceQuineCheats }?: LaxPartial<WatchOptions>): Promise<void>;
+export default watch;

package/syncMacros.js

@@ -1,12 +1,13 @@
-import { readdir, readFile, stat, writeFile } from "fs/promises"
+import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
+import { readFile, stat, writeFile } from "fs/promises"
 import { extname, basename, resolve } from "path"
-const syncMacros = async hackmudPath => {
-	const files = await readdir(hackmudPath, { withFileTypes: !0 }),
+async function syncMacros(hackmudPath) {
+	const files = await readDirectoryWithStats(hackmudPath),
 		macros = new Map(),
 		users = []
 	await Promise.all(
 		files.map(async file => {
-			if (file.isFile())
+			if (file.stats.isFile())
 				switch (extname(file.name)) {
 					case ".macros":
 						{