hackmud-script-manager 0.19.1-27bbd7d → 0.19.1-29fcf72

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,8 +1,9 @@
 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 { readdir, readFile } from "fs/promises"
-import { resolve, extname, basename } from "path"
+import { readFile } from "fs/promises"
+import { basename, resolve, extname } from "path"
 import { supportedExtensions } from "./constants.js"
 import { processScript } from "./processScript/index.js"
 import "@babel/generator"
@@ -41,11 +42,11 @@ import "./processScript/preprocess.js"
 import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
-const push = async (
+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()
@@ -64,18 +65,20 @@ const push = async (
 		scriptNamesAlreadyPushedByUser = new Cache(_user => new Set())
 	let sourceDirectoryDirents
 	if (wildUserScripts.size || pushEverything) {
-		const hackmudDirectoryDirents = await readdir(resolve(hackmudDirectory), { withFileTypes: !0 }),
-			allUsers = new Set([
-				...(sourceDirectoryDirents = await readdir(resolve(sourceDirectory), { withFileTypes: !0 }))
-					.filter(dirent => dirent.isDirectory())
-					.map(dirent => dirent.name),
-				...hackmudDirectoryDirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name),
-				...hackmudDirectoryDirents
-					.filter(dirent => dirent.isFile() && dirent.name.endsWith(".key"))
-					.map(dirent => dirent.name.slice(0, -4)),
-				...scriptNamesByUser.keys(),
-				...wildScriptUsers
-			])
+		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) {
@@ -85,28 +88,27 @@ const push = async (
 	}
 	await Promise.all(
 		[...wildScriptUsers].map(async user => {
-			await readdir(resolve(sourceDirectory, user), { withFileTypes: !0 }).then(
-				async dirents => {
+			await readDirectoryWithStats(resolve(sourceDirectory, user)).then(
+				async entries => {
 					await Promise.all(
-						dirents.map(async dirent => {
-							if (dirent.name.endsWith(".d.ts")) return
-							const extension = extname(dirent.name)
-							if (dirent.isFile() && supportedExtensions.includes(extension)) {
-								const scriptName = basename(dirent.name, extension),
-									filePath = resolve(sourceDirectory, user, dirent.name),
+						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(filePath, { encoding: "utf-8" }),
+										await readFile(path, { encoding: "utf-8" }),
 										{
 											minify,
 											scriptUser: user,
 											scriptName,
-											filePath,
+											filePath: path,
 											mangleNames,
 											forceQuineCheats
 										}
 									),
 									info = {
-										file: `${user}/${dirent.name}`,
+										file: `${user}/${name}`,
 										users: [user],
 										minLength: countHackmudCharacters(minifiedCode),
 										error: void 0
@@ -170,12 +172,12 @@ const push = async (
 	)
 	await (wildScriptUsers.size ?
 		Promise.all(
-			(sourceDirectoryDirents || (await readdir(resolve(sourceDirectory), { withFileTypes: !0 }))).map(
-				async dirent => {
-					if (dirent.name.endsWith(".d.ts")) return
-					const extension = extname(dirent.name)
-					if (!dirent.isFile() || !supportedExtensions.includes(extension)) return
-					const scriptName = basename(dirent.name, extension),
+			(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)
 						)
@@ -183,13 +185,17 @@ const push = async (
 					const uniqueID = Math.floor(Math.random() * 2 ** 52)
 							.toString(36)
 							.padStart(11, "0"),
-						filePath = resolve(sourceDirectory, dirent.name),
-						{ script: minifiedCode } = await processScript(
-							await readFile(filePath, { encoding: "utf-8" }),
-							{ minify, scriptUser: !0, scriptName, uniqueID, filePath, mangleNames, forceQuineCheats }
-						),
+						{ script: minifiedCode } = await processScript(await readFile(path, { encoding: "utf-8" }), {
+							minify,
+							scriptUser: !0,
+							scriptName,
+							uniqueID,
+							filePath: path,
+							mangleNames,
+							forceQuineCheats
+						}),
 						info = {
-							file: dirent.name,
+							file: name,
 							users: usersToPushTo,
 							minLength: countHackmudCharacters(minifiedCode),
 							error: void 0

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":
 						{

package/watch.js

@@ -1,9 +1,10 @@
 import { Cache } from "@samual/lib/Cache"
 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 { readdir, readFile, writeFile } from "fs/promises"
+import { readFile, writeFile } from "fs/promises"
 import { extname, basename, resolve } from "path"
 import { supportedExtensions } from "./constants.js"
 import { generateTypeDeclaration } from "./generateTypeDeclaration.js"
@@ -43,7 +44,7 @@ import "./processScript/preprocess.js"
 import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
-const watch = async (
+async function watch(
 	sourceDirectory,
 	hackmudDirectory,
 	{
@@ -55,7 +56,7 @@ const watch = async (
 		onReady,
 		forceQuineCheats
 	} = {}
-) => {
+) {
 	if (!scripts.length) throw Error("scripts option was an empty array")
 	const scriptNamesToUsers = new Cache(_scriptName => new Set()),
 		wildScriptUsers = new Set(),
@@ -91,26 +92,24 @@ const watch = async (
 				return
 			const scriptNamesToUsersToSkip = new Cache(_scriptName => [])
 			await Promise.all(
-				(await readdir(sourceDirectory, { withFileTypes: !0 })).map(async dirent => {
-					if (dirent.isDirectory())
-						for (const file of await readdir(resolve(sourceDirectory, dirent.name), {
-							withFileTypes: !0
-						})) {
-							if (!file.isFile()) continue
-							const fileExtension = extname(file.name)
-							supportedExtensions.includes(fileExtension) &&
-								scriptNamesToUsersToSkip.get(basename(file.name, fileExtension)).push(dirent.name)
-						}
+				(await readDirectoryWithStats(sourceDirectory)).map(async ({ stats, name, path }) => {
+					if (stats.isDirectory())
+						for (const child of await readDirectoryWithStats(path))
+							if (child.stats.isFile()) {
+								const fileExtension = extname(child.name)
+								supportedExtensions.includes(fileExtension) &&
+									scriptNamesToUsersToSkip.get(basename(child.name, fileExtension)).push(name)
+							}
 				})
 			)
 			const usersToPushToSet = new Set()
 			if (pushEverything || wildUserScripts.has(scriptName)) {
-				for (const dirent of await readdir(resolve(sourceDirectory), { withFileTypes: !0 }))
-					dirent.isDirectory() && usersToPushToSet.add(dirent.name)
-				for (const dirent of await readdir(resolve(hackmudDirectory), { withFileTypes: !0 }))
-					dirent.isDirectory() ?
-						usersToPushToSet.add(dirent.name)
-					:	dirent.isFile() && dirent.name.endsWith(".key") && usersToPushToSet.add(dirent.name.slice(0, -4))
+				for (const { stats, name } of await readDirectoryWithStats(sourceDirectory))
+					stats.isDirectory() && usersToPushToSet.add(name)
+				for (const { stats, name } of await readDirectoryWithStats(hackmudDirectory))
+					stats.isDirectory() ?
+						usersToPushToSet.add(name)
+					:	stats.isFile() && name.endsWith(".key") && usersToPushToSet.add(name.slice(0, -4))
 				for (const users of scriptNamesToUsers.values()) for (const user of users) usersToPushToSet.add(user)
 			}
 			for (const user of wildScriptUsers) usersToPushToSet.add(user)
@@ -136,7 +135,7 @@ const watch = async (
 					forceQuineCheats
 				}))
 			} catch (error) {
-				assert(error instanceof Error)
+				assert(error instanceof Error, "src/watch.ts:141:36")
 				onPush?.({ file: path, users: [], minLength: 0, error })
 				return
 			}
@@ -181,7 +180,7 @@ const watch = async (
 				forceQuineCheats
 			}))
 		} catch (error) {
-			assert(error instanceof Error)
+			assert(error instanceof Error, "src/watch.ts:177:35")
 			onPush?.({ file: path, users: [], minLength: 0, error })
 			return
 		}
@@ -196,7 +195,7 @@ const watch = async (
 		try {
 			await writeFile(typeDeclarationPath, typeDeclaration)
 		} catch (error) {
-			assert(error instanceof Error)
+			assert(error instanceof Error, "src/watch.ts:210:35")
 			if ("EISDIR" != error.code) throw error
 			typeDeclarationPath = resolve(typeDeclarationPath, "player.d.ts")
 			await writeFile(typeDeclarationPath, typeDeclaration)

package/generateTypeDeclaration.d.ts

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

package/processScript/index.d.ts

@@ -1,40 +0,0 @@
-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 const 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/processScript/minify.d.ts

@@ -1,24 +0,0 @@
-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 const minify: (file: File, { uniqueID, mangleNames, forceQuineCheats, autocomplete }?: LaxPartial<MinifyOptions>) => Promise<string>;
-export default minify;

package/processScript/preprocess.d.ts

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

package/processScript/transform.d.ts

@@ -1,24 +0,0 @@
-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 const transform: (file: File, sourceCode: string, { uniqueID, scriptUser, scriptName, seclevel }?: Partial<TransformOptions>) => {
-    file: File;
-    seclevel: number;
-};
-export default transform;

package/pull.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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 const pull: (sourceFolderPath: string, hackmudPath: string, script: string) => Promise<void>;
-export default pull;

package/push.d.ts

@@ -1,37 +0,0 @@
-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 const push: (sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: LaxPartial<PushOptions>) => Promise<Info[]>;
-export default push;