hackmud-script-manager 0.20.4-8b61cf2 → 0.20.4-9181c22

package/processScript/transform.js

@@ -22,9 +22,8 @@ const { default: traverse } = babelTraverse,
 		"BigInt"
 	]
 function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scriptName, seclevel = 4 }) {
-	const topFunctionName = `_${uniqueId}_SCRIPT_`,
-		exports = new Map(),
-		liveExports = new Map()
+	const warnings = [],
+		topFunctionName = `_${uniqueId}_SCRIPT_`
 	let program
 	traverse(file, {
 		Program(path) {
@@ -46,9 +45,17 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				referencePath.replaceWith(t.identifier(`_${uniqueId}_SCRIPT_USER_`))
 			} else
 				referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueId}$SCRIPT_USER$` : scriptUser))
-	if (program.scope.hasGlobal("_SCRIPT_NAME"))
+	if (program.scope.hasGlobal("_SCRIPT_NAME")) {
+		warnings.push({
+			message:
+				"Global _SCRIPT_NAME is deprecated and will be removed in the next minor release of HSM, use _SCRIPT_SUBNAME instead"
+		})
 		for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
 			referencePath.replaceWith(t.stringLiteral(1 == scriptName ? `$${uniqueId}$SCRIPT_NAME$` : scriptName))
+	}
+	if (program.scope.hasGlobal("_SCRIPT_SUBNAME"))
+		for (const referencePath of getReferencePathsToGlobal("_SCRIPT_SUBNAME", program))
+			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)
@@ -70,30 +77,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:111: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:116: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:121: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:129: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:134: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:139: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 +136,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:193:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:194: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:200: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}$`))
@@ -157,27 +164,32 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("$FMCL"))
 		for (const referencePath of getReferencePathsToGlobal("$FMCL", program))
 			referencePath.replaceWith(t.identifier(`$${uniqueId}$FMCL$`))
-	if (program.scope.hasGlobal("$G"))
+	let needG = program.scope.hasGlobal("$G")
+	if (needG)
 		for (const referencePath of getReferencePathsToGlobal("$G", program))
-			referencePath.replaceWith(t.identifier(`$${uniqueId}$GLOBAL$`))
+			referencePath.replaceWith(t.identifier(`_${uniqueId}_G_`))
 	if (program.scope.hasGlobal("_SECLEVEL"))
 		for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
 			referencePath.replaceWith(t.numericLiteral(seclevel))
-	let needGetPrototypeOf = !1
+	let needGetPrototypeOf = !1,
+		needHasOwn = !1
 	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:250:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
+				} else if ("hasOwn" == referencePath.parent.property.name) {
+					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_HAS_OWN_`))
+					needHasOwn = !0
 				}
 			}
 	const consoleMethodsReferenced = new Set()
 	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:268:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueId}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -185,19 +197,20 @@ 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:282: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:288:51 ${specifier.type} is currently unsupported`
+			)
+			if (
+				"default" !=
+				("Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value)
 			)
-			const exportedName =
-				"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
-			"default" == exportedName ?
-				(exportDefaultName = specifier.local.name)
-			:	exports.set(specifier.local.name, exportedName)
+				throw Error("Only default exports are supported")
+			exportDefaultName = specifier.local.name
 		}
 	}
 	const globalBlock = t.blockStatement([])
@@ -223,10 +236,6 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 									t.returnStatement(t.callExpression(t.identifier(exportDefaultName), []))
 								])
 							))
-						if ("const" != statement.kind && exports.has(identifierName)) {
-							liveExports.set(identifierName, exports.get(identifierName))
-							exports.delete(identifierName)
-						}
 						globalBlock.body.push(
 							t.variableDeclaration("let", [t.variableDeclarator(t.identifier(identifierName))])
 						)
@@ -291,34 +300,16 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	}
 	program.node.body = [mainFunction]
 	if (globalBlock.body.length) {
-		;(exports.size || liveExports.size) &&
-			mainFunction.body.body.push(
-				t.returnStatement(
-					t.objectExpression([
-						...[...exports].map(([local, exported]) =>
-							t.objectProperty(t.identifier(exported), t.identifier(local))
-						),
-						...[...liveExports].map(([local, exported]) =>
-							t.objectMethod(
-								"get",
-								t.identifier(exported),
-								[],
-								t.blockStatement([t.returnStatement(t.identifier(local))])
-							)
-						)
-					])
-				)
-			)
 		program.scope.crawl()
 		const globalBlockVariables = new Set()
 		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:402: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:406:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -333,15 +324,16 @@ 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:425: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:428:56")
 							referencePath.replaceWith(
 								t.memberExpression(
-									t.identifier(`$${uniqueId}$GLOBAL$`),
+									t.identifier(`_${uniqueId}_G_`),
 									t.identifier(referencePath.node.name)
 								)
 							)
+							needG = !0
 						}
 						for (const referencePath of binding.constantViolations)
 							if ("AssignmentExpression" == referencePath.node.type)
@@ -350,12 +342,13 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 										clearObject(node)
 										Object.assign(
 											node,
-											t.memberExpression(t.identifier(`$${uniqueId}$GLOBAL$`), t.identifier(name))
+											t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(name))
 										)
+										needG = !0
 									}
 						globalBlockPath.remove()
 						globalBlockStatementPath.remove()
-						declarator.init &&
+						if (declarator.init) {
 							globalBlock.body.splice(
 								globalBlockIndex,
 								0,
@@ -363,13 +356,15 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 									t.assignmentExpression(
 										"=",
 										t.memberExpression(
-											t.identifier(`$${uniqueId}$GLOBAL$`),
+											t.identifier(`_${uniqueId}_G_`),
 											t.identifier(declarator.id.name)
 										),
 										declarator.init
 									)
 								)
 							)
+							needG = !0
+						}
 					} else {
 						globalBlockPath.remove()
 						globalBlockStatementPath.remove()
@@ -379,22 +374,20 @@ 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:485: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:497: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:500:55")
 						referencePath.replaceWith(
-							t.memberExpression(
-								t.identifier(`$${uniqueId}$GLOBAL$`),
-								t.identifier(referencePath.node.name)
-							)
+							t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(referencePath.node.name))
 						)
+						needG = !0
 					}
 					globalBlockPath.remove()
 					globalBlockStatementPath.remove()
@@ -405,7 +398,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 							t.assignmentExpression(
 								"=",
 								t.memberExpression(
-									t.identifier(`$${uniqueId}$GLOBAL$`),
+									t.identifier(`_${uniqueId}_G_`),
 									t.identifier(globalBlockStatement.id.name)
 								),
 								t.classExpression(
@@ -417,13 +410,9 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 							)
 						)
 					)
+					needG = !0
 				}
 			}
-		if (program.scope.hasGlobal("_EXPORTS"))
-			for (const referencePath of getReferencePathsToGlobal("_EXPORTS", program))
-				referencePath.replaceWith(
-					t.arrayExpression([...exports.keys(), ...liveExports.keys()].map(name => t.stringLiteral(name)))
-				)
 		globalBlock.body.length &&
 			mainFunction.body.body.splice(
 				hoistedGlobalBlockFunctions,
@@ -472,6 +461,31 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				)
 			])
 		)
+	needHasOwn &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(
+					t.identifier(`_${uniqueId}_HAS_OWN_`),
+					t.callExpression(
+						t.memberExpression(
+							t.memberExpression(
+								t.identifier(
+									globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
+								),
+								t.identifier("call")
+							),
+							t.identifier("bind")
+						),
+						[
+							t.memberExpression(
+								t.memberExpression(t.identifier("Object"), t.identifier("prototype")),
+								t.identifier("hasOwnProperty")
+							)
+						]
+					)
+				)
+			])
+		)
 	consoleMethodsReferenced.size &&
 		mainFunction.body.body.unshift(
 			t.variableDeclaration(
@@ -535,6 +549,12 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				)
 			)
 		)
+	needG &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(t.identifier(`_${uniqueId}_G_`), t.identifier(`$${uniqueId}$GLOBAL$`))
+			])
+		)
 	traverse(file, {
 		BlockStatement({ node: blockStatement }) {
 			for (const [index, functionDeclaration] of blockStatement.body.entries())
@@ -555,7 +575,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:695:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -645,41 +665,33 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			)
 		}
 	})
-	return { file, seclevel }
+	return { file, seclevel, warnings }
 	function createGetFunctionPrototypeNode() {
-		for (const globalFunction of globalFunctionsUnder7Characters)
-			if (!program.scope.hasOwnBinding(globalFunction))
-				return t.memberExpression(
-					t.memberExpression(t.identifier(globalFunction), t.identifier("constructor")),
-					t.identifier("prototype")
-				)
+		const name = globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
 		return t.memberExpression(
-			t.memberExpression(
-				t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
-				t.identifier("constructor")
-			),
-			t.identifier("prototype")
+			name ? t.identifier(name) : t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
+			t.identifier("__proto__")
 		)
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName, seclevel) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:785:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:801:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:787:81"
+				"src/processScript/transform.ts:803:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:788:83"
+				"src/processScript/transform.ts:804:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:792:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:808: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:797:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:813: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.js

@@ -1,10 +1,10 @@
-import { Cache } from "@samual/lib/Cache"
+import { AutoMap } from "@samual/lib/AutoMap"
 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 { resolve, basename } from "path"
 import { processScript } from "./processScript/index.js"
 import "@babel/generator"
 import "@babel/parser"
@@ -25,6 +25,7 @@ import "@babel/plugin-transform-private-property-in-object"
 import "@babel/plugin-transform-unicode-sets-regex"
 import "@babel/traverse"
 import "@babel/types"
+import "@rollup/plugin-alias"
 import "@rollup/plugin-babel"
 import "@rollup/plugin-commonjs"
 import "@rollup/plugin-json"
@@ -84,8 +85,8 @@ async function push(
 		return new NoUsersError(
 			"Could not find any users. Either provide the names of your users or log into a user in hackmud"
 		)
-	const usersToScriptsToPush = new Cache(_user => new Map()),
-		scriptNamesToUsers = new Cache(_scriptName => new Set())
+	const usersToScriptsToPush = new AutoMap(_user => new Map()),
+		scriptNamesToUsers = new AutoMap(_scriptName => new Set())
 	for (const script of scripts) {
 		const [user, scriptName] = script.split(".")
 		assert(user, "src/push.ts:105:16")
@@ -121,26 +122,28 @@ async function push(
 		for (const user of users)
 			if (!usersToScriptsToPush.get(user).has(scriptName))
 				return new NoScriptsError(`Could not find script ${user}.${scriptName} to push`)
-	const pathsToUsers = new Cache(_path => new Set())
+	const pathsToUsers = new AutoMap(_path => new Set())
 	for (const [user, scriptsToPush] of usersToScriptsToPush)
 		for (const path of scriptsToPush.values()) pathsToUsers.get(path).add(user)
-	const allInfo = []
+	const allInfo = [],
+		sourcePathResolved = resolve(sourcePath)
 	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" }), {
+				{ script: minifiedCode, warnings } = await processScript(await readFile(path, { encoding: "utf8" }), {
 					minify,
 					scriptUser: !0,
 					scriptName,
 					uniqueId,
 					filePath: path,
 					mangleNames,
-					forceQuineCheats
+					forceQuineCheats,
+					rootFolderPath: sourcePathResolved
 				}),
-				info = { path, users, characterCount: countHackmudCharacters(minifiedCode), error: void 0 }
+				info = { path, users, characterCount: countHackmudCharacters(minifiedCode), error: void 0, warnings }
 			await Promise.all(
 				users.map(user =>
 					writeFilePersistent(

package/watch.js

@@ -1,14 +1,15 @@
-import { Cache } from "@samual/lib/Cache"
+import { AutoMap } from "@samual/lib/AutoMap"
 import { assert } from "@samual/lib/assert"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
 import { watch as watch$1 } from "chokidar"
-import { readFile, writeFile } from "fs/promises"
+import { stat, readFile, writeFile } from "fs/promises"
 import { extname, basename, resolve } from "path"
 import { supportedExtensions } from "./constants.js"
 import { generateTypeDeclaration } from "./generateTypeDeclaration.js"
 import { processScript } from "./processScript/index.js"
+import "path/posix"
 import "@babel/generator"
 import "@babel/parser"
 import "@babel/plugin-proposal-decorators"
@@ -28,6 +29,7 @@ import "@babel/plugin-transform-private-property-in-object"
 import "@babel/plugin-transform-unicode-sets-regex"
 import "@babel/traverse"
 import "@babel/types"
+import "@rollup/plugin-alias"
 import "@rollup/plugin-babel"
 import "@rollup/plugin-commonjs"
 import "@rollup/plugin-json"
@@ -58,7 +60,8 @@ async function watch(
 	} = {}
 ) {
 	if (!scripts.length) throw Error("scripts option was an empty array")
-	const scriptNamesToUsers = new Cache(_scriptName => new Set()),
+	if (!(await stat(sourceDirectory)).isDirectory()) throw Error("Target folder must be a folder")
+	const scriptNamesToUsers = new AutoMap(_scriptName => new Set()),
 		wildScriptUsers = new Set(),
 		wildUserScripts = new Set()
 	let pushEverything = !1
@@ -71,10 +74,11 @@ async function watch(
 		: scriptName && "*" != scriptName ? wildUserScripts.add(scriptName)
 		: (pushEverything = !0)
 	}
-	const watcher = watch$1(["*.ts", "*.js", "*/*.ts", "*/*.js"], {
+	const watcher = watch$1(".", {
 		cwd: sourceDirectory,
 		awaitWriteFinish: { stabilityThreshold: 100 },
-		ignored: "*.d.ts"
+		ignored: (path, stats) =>
+			!!stats?.isFile() && !(path.endsWith(".js") || (path.endsWith(".ts") && !path.endsWith(".d.ts")))
 	}).on("change", async path => {
 		if (path.endsWith(".d.ts")) return
 		const extension = extname(path)
@@ -90,7 +94,7 @@ async function watch(
 				)
 			)
 				return
-			const scriptNamesToUsersToSkip = new Cache(_scriptName => [])
+			const scriptNamesToUsersToSkip = new AutoMap(_scriptName => [])
 			await Promise.all(
 				(await readDirectoryWithStats(sourceDirectory)).map(async ({ stats, name, path }) => {
 					if (stats.isDirectory())
@@ -116,27 +120,22 @@ 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?.({ path, users: [], characterCount: 0, error: Error("no users to push to"), warnings: [] })
 				return
 			}
 			const uniqueId = Math.floor(Math.random() * 2 ** 52)
 					.toString(36)
 					.padStart(11, "0"),
 				filePath = resolve(sourceDirectory, path)
-			let minifiedCode
+			let minifiedCode, warnings
 			try {
-				;({ script: minifiedCode } = await processScript(await readFile(filePath, { encoding: "utf8" }), {
-					minify,
-					scriptUser: !0,
-					scriptName,
-					uniqueId,
-					filePath,
-					mangleNames,
-					forceQuineCheats
-				}))
+				;({ script: minifiedCode, warnings } = await processScript(
+					await readFile(filePath, { encoding: "utf8" }),
+					{ minify, scriptUser: !0, scriptName, uniqueId, filePath, mangleNames, forceQuineCheats }
+				))
 			} catch (error) {
-				assert(error instanceof Error, "src/watch.ts:141:36")
-				onPush?.({ path, users: [], characterCount: 0, error })
+				assert(error instanceof Error, "src/watch.ts:149:36")
+				onPush?.({ path, users: [], characterCount: 0, error, warnings: [] })
 				return
 			}
 			await Promise.all(
@@ -153,7 +152,8 @@ async function watch(
 				path,
 				users: usersToPushTo,
 				characterCount: countHackmudCharacters(minifiedCode),
-				error: void 0
+				error: void 0,
+				warnings
 			})
 			return
 		}
@@ -167,25 +167,27 @@ async function watch(
 			)
 		)
 			return
-		const filePath = resolve(sourceDirectory, path),
+		const sourceDirectoryResolved = resolve(sourceDirectory),
+			filePath = resolve(sourceDirectoryResolved, path),
 			sourceCode = await readFile(filePath, { encoding: "utf8" })
-		let script
+		let script, warnings
 		try {
-			;({ script } = await processScript(sourceCode, {
+			;({ script, warnings } = await processScript(sourceCode, {
 				minify,
 				scriptUser: user,
 				scriptName,
 				filePath,
 				mangleNames,
-				forceQuineCheats
+				forceQuineCheats,
+				rootFolderPath: sourceDirectoryResolved
 			}))
 		} catch (error) {
-			assert(error instanceof Error, "src/watch.ts:177:35")
-			onPush?.({ path, users: [], characterCount: 0, error })
+			assert(error instanceof Error, "src/watch.ts:196:35")
+			onPush?.({ path, users: [], characterCount: 0, error, warnings: [] })
 			return
 		}
 		await writeFilePersistent(resolve(hackmudDirectory, user, "scripts", scriptName + ".js"), script)
-		onPush?.({ path, users: [user], characterCount: countHackmudCharacters(script), error: void 0 })
+		onPush?.({ path, users: [user], characterCount: countHackmudCharacters(script), error: void 0, warnings })
 	})
 	onReady && watcher.on("ready", onReady)
 	if (!typeDeclarationPath_) return
@@ -195,7 +197,7 @@ async function watch(
 		try {
 			await writeFile(typeDeclarationPath, typeDeclaration)
 		} catch (error) {
-			assert(error instanceof Error, "src/watch.ts:210:35")
+			assert(error instanceof Error, "src/watch.ts:229:35")
 			if ("EISDIR" != error.code) throw error
 			typeDeclarationPath = resolve(typeDeclarationPath, "player.d.ts")
 			await writeFile(typeDeclarationPath, typeDeclaration)