hackmud-script-manager 0.19.1-b3a477d → 0.19.1-b80922d

package/bin/hsm.js

@@ -12,7 +12,7 @@ import { pull } from "../pull.js"
 import { syncMacros } from "../syncMacros.js"
 import "@samual/lib/readDirectoryWithStats"
 import "@samual/lib/copyFilePersistent"
-const version = "0.19.1-b3a477d",
+const version = "0.19.1-b80922d",
 	options = new Map(),
 	commands = [],
 	userColours = new Cache(user => {
@@ -316,7 +316,7 @@ switch (commands[0]) {
 					: fileBaseName + ".js"
 				)
 			const golfFile = () =>
-				readFile(target, { encoding: "utf8" }).then(async source => {
+				readFile(target, { encoding: "utf-8" }).then(async source => {
 					const timeStart = performance.now(),
 						{ script, warnings } = await processScript(source, {
 							minify: !(options.get("no-minify") || options.get("skip-minify")),
@@ -410,12 +410,11 @@ function logHelp() {
 			)
 	}
 }
-function logInfo({ path, users, characterCount, error }, hackmudPath) {
-	path = relative(".", path)
+function logInfo({ file, users, minLength, error }, hackmudPath) {
 	error ?
-		logError(`error "${chalk.bold(error.message)}" in ${chalk.bold(path)}`)
-	:	log(
-			`pushed ${chalk.bold(path)} to ${users.map(user => chalk.bold(userColours.get(user))).join(", ")} | ${chalk.bold(characterCount + "")} chars | ${chalk.bold(resolve(hackmudPath, users[0], "scripts", basename(path, extname(path))) + ".js")}`
+		logError(`error "${chalk.bold(error.message)}" in ${chalk.bold(file)}`)
+	:	console.log(
+			`pushed ${chalk.bold(file)} to ${users.map(user => chalk.bold(userColours.get(user))).join(", ")} | ${chalk.bold(minLength + "")} chars | ${chalk.bold(resolve(hackmudPath, users[0], "scripts", basename(file, extname(file))) + ".js")}`
 		)
 }
 function logError(message) {

package/index.d.ts

@@ -6,8 +6,8 @@ export { push } from "./push";
 export { syncMacros } from "./syncMacros";
 export { watch } from "./watch";
 export type Info = {
-    path: string;
+    file: string;
     users: string[];
-    characterCount: number;
+    minLength: number;
     error: Error | undefined;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackmud-script-manager",
-  "version": "0.19.1-b3a477d",
+  "version": "0.19.1-b80922d",
   "description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
   "keywords": [
     "api",

package/processScript/transform.js

@@ -51,18 +51,13 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 			referencePath.replaceWith(t.stringLiteral(1 == scriptName ? `$${uniqueID}$SCRIPT_NAME$` : scriptName))
 	if (program.scope.hasGlobal("_FULL_SCRIPT_NAME"))
 		for (const referencePath of getReferencePathsToGlobal("_FULL_SCRIPT_NAME", program))
-			if (1 == scriptUser || 1 == scriptName)
-				referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$FULL_SCRIPT_NAME$`))
-			else if (null == scriptUser) {
-				uniqueIdScriptUserNeeded = !0
-				referencePath.replaceWith(
-					t.binaryExpression(
-						"+",
-						t.identifier(`_${uniqueID}_SCRIPT_USER_`),
-						t.stringLiteral("." + scriptName)
-					)
+			referencePath.replaceWith(
+				t.stringLiteral(
+					1 == scriptUser || 1 == scriptName ?
+						`$${uniqueID}$FULL_SCRIPT_NAME$`
+					:	`${scriptUser}.${scriptName}`
 				)
-			} else referencePath.replaceWith(t.stringLiteral(`${scriptUser}.${scriptName}`))
+			)
 	let functionDotPrototypeIsReferencedMultipleTimes = !1
 	if (program.scope.hasGlobal("Function")) {
 		const FunctionReferencePaths = getReferencePathsToGlobal("Function", program)
@@ -70,30 +65,30 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 			const referencePath = FunctionReferencePaths[0]
 			assert(
 				"MemberExpression" == referencePath.parent.type,
-				"src/processScript/transform.ts:105:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:98:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"Identifier" == referencePath.parent.property.type,
-				"src/processScript/transform.ts:110:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:103:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"prototype" == referencePath.parent.property.name,
-				"src/processScript/transform.ts:115:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:108:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
 		} else {
 			for (const referencePath of FunctionReferencePaths) {
 				assert(
 					"MemberExpression" == referencePath.parent.type,
-					"src/processScript/transform.ts:123:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:116:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"Identifier" == referencePath.parent.property.type,
-					"src/processScript/transform.ts:128:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:121:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"prototype" == referencePath.parent.property.name,
-					"src/processScript/transform.ts:133:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:126:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				functionDotPrototypeIsReferencedMultipleTimes = !0
 				referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
@@ -129,12 +124,12 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 	const neededDbMethodLets = new Set()
 	if (program.scope.hasGlobal("$db"))
 		for (const referencePath of getReferencePathsToGlobal("$db", program)) {
-			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:187:69")
-			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:188:72")
+			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:180:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:181:72")
 			const databaseOpMethodName = referencePath.parentPath.node.property.name
 			assert(
 				validDBMethods.includes(databaseOpMethodName),
-				`src/processScript/transform.ts:194:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+				`src/processScript/transform.ts:187:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath?.type)
 				referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
@@ -167,7 +162,7 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("Object"))
 		for (const referencePath of getReferencePathsToGlobal("Object", program))
 			if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
-				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:241:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:234:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
@@ -177,7 +172,7 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("console"))
 		for (const referencePath of getReferencePathsToGlobal("console", program))
 			if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
-				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:256:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:249:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -185,13 +180,13 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 			}
 	const lastStatement = program.node.body.at(-1)
 	let exportDefaultName
-	assert(lastStatement, "src/processScript/transform.ts:270:27 program is empty")
+	assert(lastStatement, "src/processScript/transform.ts:263:27 program is empty")
 	if ("ExportNamedDeclaration" == lastStatement.type) {
 		program.node.body.pop()
 		for (const specifier of lastStatement.specifiers) {
 			assert(
 				"ExportSpecifier" == specifier.type,
-				`src/processScript/transform.ts:276:51 ${specifier.type} is currently unsupported`
+				`src/processScript/transform.ts:269:51 ${specifier.type} is currently unsupported`
 			)
 			const exportedName =
 				"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
@@ -314,11 +309,11 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 		let hoistedGlobalBlockFunctions = 0
 		for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
 			if ("VariableDeclaration" == globalBlockStatement.type) {
-				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:410:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:403:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:414:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:407:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -333,9 +328,9 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 						Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
 					) {
 						const binding = program.scope.getBinding(declarator.id.name)
-						assert(binding, "src/processScript/transform.ts:433:23")
+						assert(binding, "src/processScript/transform.ts:426:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:436:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:429:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -379,16 +374,16 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 				} else globalBlockVariables.add(declarator.id.name)
 			} else if ("ClassDeclaration" == globalBlockStatement.type) {
 				program.scope.crawl()
-				assert(globalBlockStatement.id, "src/processScript/transform.ts:487:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:480:37")
 				if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
 					globalBlock.body.splice(globalBlockIndex, 1)
 					const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
 						[globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
 					program.scope.crawl()
 					const binding = program.scope.getBinding(globalBlockStatement.id.name)
-					assert(binding, "src/processScript/transform.ts:499:22")
+					assert(binding, "src/processScript/transform.ts:492:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:502:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:495:55")
 						referencePath.replaceWith(
 							t.memberExpression(
 								t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -555,7 +550,7 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 				}
 		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:669:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:662:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -661,23 +656,23 @@ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scr
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:783:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:776:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:785:81"
+				"src/processScript/transform.ts:778:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:786:83"
+				"src/processScript/transform.ts:779:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:790:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:783:8 invalid user "${referencePath.parent.property.name}" in subscript`
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
-				`src/processScript/transform.ts:795:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:788:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
 				referencePath.parentPath.parentPath.replaceWith(

package/push.d.ts

@@ -21,8 +21,8 @@ export type PushOptions = LaxPartial<{
 /** Push scripts from a source directory to the hackmud directory.
   *
   * Pushes files directly in the source folder to all users
-  * @param sourcePath directory containing source code
-  * @param hackmudPath directory created by hackmud containing user data including scripts
+  * @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(sourcePath: string, hackmudPath: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<Info[]>;
+export declare function push(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<Info[]>;

package/push.js

@@ -1,10 +1,10 @@
 import { Cache } from "@samual/lib/Cache"
-import { ensure, assert } from "@samual/lib/assert"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
 import { readFile } from "fs/promises"
-import { basename, resolve } from "path"
+import { basename, resolve, extname } from "path"
+import { supportedExtensions } from "./constants.js"
 import { processScript } from "./processScript/index.js"
 import "@babel/generator"
 import "@babel/parser"
@@ -29,9 +29,9 @@ import "@rollup/plugin-babel"
 import "@rollup/plugin-commonjs"
 import "@rollup/plugin-json"
 import "@rollup/plugin-node-resolve"
+import "@samual/lib/assert"
 import "prettier"
 import "rollup"
-import "./constants.js"
 import "./processScript/minify.js"
 import "@samual/lib/spliceString"
 import "acorn"
@@ -43,96 +43,227 @@ import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
 async function push(
-	sourcePath,
-	hackmudPath,
+	sourceDirectory,
+	hackmudDirectory,
 	{ scripts = ["*.*"], onPush = () => {}, minify = !0, mangleNames = !1, forceQuineCheats } = {}
 ) {
-	const [sourceFolder, hackmudFolder] = await Promise.all([
-			readDirectoryWithStats(sourcePath),
-			readDirectoryWithStats(hackmudPath)
-		]),
-		sourceFolderFolders = sourceFolder.filter(({ stats }) => stats.isDirectory()),
-		allUsers = new Set([
-			...scripts
-				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:52:65"))
-				.filter(name => "*" != name),
-			...sourceFolderFolders.map(({ name }) => name),
-			...hackmudFolder.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
-			...hackmudFolder
-				.filter(({ stats, name }) => stats.isFile() && name.endsWith(".key"))
-				.map(({ name }) => name.slice(0, -4))
-		]),
-		usersToScriptsToPush = new Cache(_user => new Map()),
-		scriptNamesToUsers = new Cache(_scriptName => new Set())
-	for (const script of scripts) {
-		const [user, scriptName] = script.split(".")
-		assert(user, "src/push.ts:69:16")
-		assert(scriptName, "src/push.ts:70:22")
-		"*" == user ? scriptNamesToUsers.set(scriptName, allUsers) : scriptNamesToUsers.get(scriptName).add(user)
+	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 sourceFolderFiles = sourceFolder.filter(({ stats }) => stats.isFile()),
-		wildScriptUsers_ = scriptNamesToUsers.get("*")
-	scriptNamesToUsers.delete("*")
-	for (const { name, path } of [
-		...sourceFolderFiles.filter(({ name }) => name.endsWith(".js")),
-		...sourceFolderFiles.filter(({ name }) => name.endsWith(".ts"))
-	]) {
-		const scriptName = name.slice(0, -3)
-		for (const user of [...wildScriptUsers_, ...scriptNamesToUsers.get(scriptName)])
-			usersToScriptsToPush.get(user).set(scriptName, path)
+	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(
-		sourceFolderFolders.map(async ({ name: user, path }) => {
-			const files = (await readDirectoryWithStats(path)).filter(({ stats }) => stats.isFile()),
-				scriptFiles = [
-					...files.filter(({ name }) => name.endsWith(".js")),
-					...files.filter(({ name }) => name.endsWith(".ts"))
-				]
-			for (const { name, path } of scriptFiles) {
-				const scriptName = name.slice(0, -3)
-				;[...wildScriptUsers_, ...scriptNamesToUsers.get(scriptName)].includes(user) &&
-					usersToScriptsToPush.get(user).set(scriptName, path)
-			}
+		[...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
+									}
+								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
+				}
+			)
 		})
 	)
-	for (const [scriptName, users] of scriptNamesToUsers)
-		for (const user of users)
-			if (!usersToScriptsToPush.get(user).has(scriptName))
-				throw Error(`Could not find script ${user}.${scriptName} to push`)
-	const pathsToUsers = new Cache(_path => new Set())
-	for (const [user, scriptsToPush] of usersToScriptsToPush)
-		for (const path of scriptsToPush.values()) pathsToUsers.get(path).add(user)
-	const allInfo = []
 	await Promise.all(
-		[...pathsToUsers].map(async ([path, [...users]]) => {
-			const scriptName = basename(path.slice(0, -3)),
-				uniqueID = Math.floor(Math.random() * 2 ** 52)
-					.toString(36)
-					.padStart(11, "0"),
-				{ script: minifiedCode } = await processScript(await readFile(path, { encoding: "utf8" }), {
-					minify,
-					scriptUser: !0,
-					scriptName,
-					uniqueID,
-					filePath: path,
-					mangleNames,
-					forceQuineCheats
-				}),
-				info = { path, users, characterCount: countHackmudCharacters(minifiedCode), error: void 0 }
-			await Promise.all(
-				users.map(user =>
-					writeFilePersistent(
-						resolve(hackmudPath, 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)
+		[...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}`,
+									users: [user],
+									minLength: countHackmudCharacters(minifiedCode),
+									error: void 0
+								}
+							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)
+						)
+					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}`
+									)
+							)
+						)
+					)
+					allInfo.push(info)
+					onPush(info)
+				}
+			})
+		))
 	return allInfo
 }
 export { push }

package/syncMacros.js

@@ -12,7 +12,7 @@ async function syncMacros(hackmudPath) {
 					case ".macros":
 						{
 							const [lines, date] = await Promise.all([
-								readFile(resolve(hackmudPath, file.name), { encoding: "utf8" }).then(file =>
+								readFile(resolve(hackmudPath, file.name), { encoding: "utf-8" }).then(file =>
 									file.split("\n")
 								),
 								stat(resolve(hackmudPath, file.name)).then(({ mtime }) => mtime)

package/watch.js

@@ -116,7 +116,7 @@ async function watch(
 			for (const user of scriptNamesToUsers.get(scriptName)) usersToPushToSet.add(user)
 			const usersToPushTo = [...usersToPushToSet].filter(user => !scriptNamesToUsersToSkip.has(user))
 			if (!usersToPushTo.length) {
-				onPush?.({ path, users: [], characterCount: 0, error: Error("no users to push to") })
+				onPush?.({ file: path, users: [], minLength: 0, error: Error("no users to push to") })
 				return
 			}
 			const uniqueID = Math.floor(Math.random() * 2 ** 52)
@@ -125,7 +125,7 @@ async function watch(
 				filePath = resolve(sourceDirectory, path)
 			let minifiedCode
 			try {
-				;({ script: minifiedCode } = await processScript(await readFile(filePath, { encoding: "utf8" }), {
+				;({ script: minifiedCode } = await processScript(await readFile(filePath, { encoding: "utf-8" }), {
 					minify,
 					scriptUser: !0,
 					scriptName,
@@ -136,7 +136,7 @@ async function watch(
 				}))
 			} catch (error) {
 				assert(error instanceof Error, "src/watch.ts:141:36")
-				onPush?.({ path, users: [], characterCount: 0, error })
+				onPush?.({ file: path, users: [], minLength: 0, error })
 				return
 			}
 			await Promise.all(
@@ -150,9 +150,9 @@ async function watch(
 				)
 			)
 			onPush?.({
-				path,
+				file: path,
 				users: usersToPushTo,
-				characterCount: countHackmudCharacters(minifiedCode),
+				minLength: countHackmudCharacters(minifiedCode),
 				error: void 0
 			})
 			return
@@ -168,7 +168,7 @@ async function watch(
 		)
 			return
 		const filePath = resolve(sourceDirectory, path),
-			sourceCode = await readFile(filePath, { encoding: "utf8" })
+			sourceCode = await readFile(filePath, { encoding: "utf-8" })
 		let script
 		try {
 			;({ script } = await processScript(sourceCode, {
@@ -181,11 +181,11 @@ async function watch(
 			}))
 		} catch (error) {
 			assert(error instanceof Error, "src/watch.ts:177:35")
-			onPush?.({ path, users: [], characterCount: 0, error })
+			onPush?.({ file: path, users: [], minLength: 0, error })
 			return
 		}
 		await writeFilePersistent(resolve(hackmudDirectory, user, "scripts", scriptName + ".js"), script)
-		onPush?.({ path, users: [user], characterCount: countHackmudCharacters(script), error: void 0 })
+		onPush?.({ file: path, users: [user], minLength: countHackmudCharacters(script), error: void 0 })
 	})
 	onReady && watcher.on("ready", onReady)
 	if (!typeDeclarationPath_) return