diff --git a/src/Corporation/data/Constants.ts b/src/Corporation/data/Constants.ts
index c83e3e0d7..5c4fa3f0d 100644
--- a/src/Corporation/data/Constants.ts
+++ b/src/Corporation/data/Constants.ts
@@ -26,6 +26,10 @@ export const CorporationConstants: {
   BaseMaxProducts: number;
   AllCorporationStates: string[];
   AllMaterials: string[];
+  AllIndustryTypes: string[];
+  AllUnlocks: string[];
+  AllUpgrades: string[];
+  AllResearch: string[];
   FundingRoundShares: number[];
   FundingRoundMultiplier: number[];
   AvgProfitLength: number;
@@ -82,6 +86,70 @@ export const CorporationConstants: {
     "AI Cores",
     "Real Estate",
   ],
+  AllIndustryTypes: [
+    "Energy",
+    "Utilities",
+    "Agriculture",
+    "Fishing",
+    "Mining",
+    "Food",
+    "Tobacco",
+    "Chemical",
+    "Pharmaceutical",
+    "Hardware",
+    "Robotics",
+    "Software",
+    "Healthcare",
+    "RealEstate",
+  ],
+  AllUnlocks: [
+    "Export",
+    "Smart Supply",
+    "Market Research - Demand",
+    "Market Data - Competition",
+    "VeChain",
+    "Shady Accounting",
+    "Government Partnership",
+    "Warehouse API",
+    "Office API",
+  ],
+  AllUpgrades: [
+    "Smart Factories",
+    "Smart Storage",
+    "DreamSense",
+    "Wilson Analytics",
+    "Nuoptimal Nootropic Injector Implants",
+    "Speech Processor Implants",
+    "Neural Accelerators",
+    "FocusWires",
+    "ABC SalesBots",
+    "Project Insight",
+  ],
+  AllResearch: [
+    "Hi-Tech R&D Laboratory",
+    "AutoBrew",
+    "AutoPartyManager",
+    "Automatic Drug Administration",
+    "Bulk Purchasing",
+    "CPH4 Injections",
+    "Drones",
+    "Drones - Assembly",
+    "Drones - Transport",
+    "Go-Juice",
+    "HRBuddy-Recruitment",
+    "HRBuddy-Training",
+    "JoyWire",
+    "Market-TA.I",
+    "Market-TA.II",
+    "Overclock",
+    "Self-Correcting Assemblers",
+    "Sti.mu",
+    "sudo.Assist",
+    "uPgrade: Capacity.I",
+    "uPgrade: Capacity.II",
+    "uPgrade: Dashboard",
+    "uPgrade: Fulcrum",
+  ],
   FundingRoundShares: [0.1, 0.35, 0.25, 0.2],
   FundingRoundMultiplier: [4, 3, 3, 2.5],
 
diff --git a/src/Corporation/ui/IndustryOffice.tsx b/src/Corporation/ui/IndustryOffice.tsx
index 17760f36b..87509efce 100644
--- a/src/Corporation/ui/IndustryOffice.tsx
+++ b/src/Corporation/ui/IndustryOffice.tsx
@@ -459,7 +459,7 @@ export function IndustryOffice(props: IProps): React.ReactElement {
           {!division.hasResearch("AutoBrew") && (
             <>
               <Tooltip
-                title={<Typography>Throw an office party to increase your employee's morale and happiness</Typography>}
+                title={<Typography>Provide your employees with coffee, increasing their energy by 5%</Typography>}
               >
                 <span>
                   <Button
diff --git a/src/Infiltration/ui/BribeGame.tsx b/src/Infiltration/ui/BribeGame.tsx
index 6fdc85246..2a550aeef 100644
--- a/src/Infiltration/ui/BribeGame.tsx
+++ b/src/Infiltration/ui/BribeGame.tsx
@@ -151,7 +151,7 @@ const positive = [
   "patient",
   "dynamic",
   "loyal",
-  "based",
+  "straightforward",
 ];
 
 const negative = [
diff --git a/src/Netscript/APIWrapper.ts b/src/Netscript/APIWrapper.ts
index 6844f45f5..3e1522e90 100644
--- a/src/Netscript/APIWrapper.ts
+++ b/src/Netscript/APIWrapper.ts
@@ -1,22 +1,15 @@
 import { getRamCost } from "./RamCostGenerator";
-import type { IPort } from "../NetscriptPort";
-import type { BaseServer } from "../Server/BaseServer";
 import type { WorkerScript } from "./WorkerScript";
-import { makeRuntimeRejectMsg } from "../NetscriptEvaluator";
 import { Player } from "../Player";
-import { CityName } from "../Locations/data/CityNames";
-import { BasicHGWOptions } from "../ScriptEditor/NetscriptDefinitions";
-import { IPlayer } from "../PersonObjects/IPlayer";
-import { Server } from "../Server/Server";
-import { FormulaGang } from "../Gang/formulas/formulas";
-import { INetscriptHelper, ScriptIdentifier } from "../NetscriptFunctions/INetscriptHelper";
-import { GangMember } from "../Gang/GangMember";
-import { GangMemberTask } from "../Gang/GangMemberTask";
+import { helpers } from "./NetscriptHelpers";
 import { ScriptArg } from "./ScriptArg";
+import { NSEnums } from "src/ScriptEditor/NetscriptDefinitions";
+import { NSFull } from "src/NetscriptFunctions";
 
 type ExternalFunction = (...args: unknown[]) => unknown;
-export type ExternalAPI = {
-  [string: string]: ExternalAPI | ExternalFunction;
+
+export type ExternalAPILayer = {
+  [key: string]: ExternalAPILayer | ExternalFunction | ScriptArg[];
 };
 
 type InternalFunction<F extends (...args: unknown[]) => unknown> = (ctx: NetscriptContext) => F;
@@ -24,48 +17,23 @@ type InternalFunction<F extends (...args: unknown[]) => unknown> = (ctx: Netscri
 export type InternalAPI<API> = {
   [Property in keyof API]: API[Property] extends ExternalFunction
     ? InternalFunction<API[Property]>
+    : API[Property] extends NSEnums
+    ? NSEnums
+    : API[Property] extends ScriptArg[]
+    ? ScriptArg[]
     : API[Property] extends object
     ? InternalAPI<API[Property]>
     : never;
 };
 
-type WrappedNetscriptFunction = (...args: unknown[]) => unknown;
-type WrappedNetscriptAPI = {
-  readonly [string: string]: WrappedNetscriptAPI | WrappedNetscriptFunction;
-};
-
 export type NetscriptContext = {
-  makeRuntimeErrorMsg: (message: string) => string;
-  log: (message: () => string) => void;
   workerScript: WorkerScript;
   function: string;
-  helper: WrappedNetscriptHelpers;
-};
-
-type WrappedNetscriptHelpers = {
-  makeRuntimeErrorMsg: (msg: string) => string;
-  string: (argName: string, v: unknown) => string;
-  number: (argName: string, v: unknown) => number;
-  ustring: (argName: string, v: unknown) => string | undefined;
-  unumber: (argName: string, v: unknown) => number | undefined;
-  scriptArgs(args: unknown): ScriptArg[];
-  scriptIdentifier: (fn: unknown, hostname: unknown, args: unknown) => ScriptIdentifier;
-  city: (argName: string, v: unknown) => CityName;
-  boolean: (v: unknown) => boolean;
-  getServer: (hostname: string) => BaseServer;
-  checkSingularityAccess: () => void;
-  hack: (hostname: string, manual: boolean, { threads: requestedThreads, stock }?: BasicHGWOptions) => Promise<number>;
-  getValidPort: (port: number) => IPort;
-  player(p: unknown): IPlayer;
-  server(s: unknown): Server;
-  gang(g: unknown): FormulaGang;
-  gangMember: (m: unknown) => GangMember;
-  gangTask: (t: unknown) => GangMemberTask;
+  functionPath: string;
 };
 
 function wrapFunction(
-  helpers: INetscriptHelper,
-  wrappedAPI: ExternalAPI,
+  wrappedAPI: ExternalAPILayer,
   workerScript: WorkerScript,
   func: (_ctx: NetscriptContext) => (...args: unknown[]) => unknown,
   ...tree: string[]
@@ -73,44 +41,19 @@ function wrapFunction(
   const functionPath = tree.join(".");
   const functionName = tree.pop();
   if (typeof functionName !== "string") {
-    throw makeRuntimeRejectMsg(workerScript, "Failure occured while wrapping netscript api");
+    throw helpers.makeRuntimeRejectMsg(workerScript, "Failure occured while wrapping netscript api");
   }
   const ctx = {
-    makeRuntimeErrorMsg: (message: string) => {
-      return helpers.makeRuntimeErrorMsg(functionPath, message);
-    },
-    log: (message: () => string) => {
-      workerScript.log(functionPath, message);
-    },
     workerScript,
     function: functionName,
-    helper: {
-      makeRuntimeErrorMsg: (msg: string) => helpers.makeRuntimeErrorMsg(functionPath, msg),
-      string: (argName: string, v: unknown) => helpers.string(functionPath, argName, v),
-      number: (argName: string, v: unknown) => helpers.number(functionPath, argName, v),
-      ustring: (argName: string, v: unknown) => helpers.ustring(functionPath, argName, v),
-      unumber: (argName: string, v: unknown) => helpers.unumber(functionPath, argName, v),
-      scriptArgs: (v: unknown) => helpers.scriptArgs(functionPath, v),
-      scriptIdentifier: (fn: unknown, hostname: unknown, args: unknown) =>
-        helpers.scriptIdentifier(functionPath, fn, hostname, args),
-      city: (argName: string, v: unknown) => helpers.city(functionPath, argName, v),
-      boolean: helpers.boolean,
-      getServer: (hostname: string) => helpers.getServer(hostname, ctx),
-      checkSingularityAccess: () => helpers.checkSingularityAccess(functionName),
-      hack: (hostname: string, manual: boolean, extra?: BasicHGWOptions) => helpers.hack(ctx, hostname, manual, extra),
-      getValidPort: (port: number) => helpers.getValidPort(functionPath, port),
-      player: (p: unknown) => helpers.player(functionPath, p),
-      server: (s: unknown) => helpers.server(functionPath, s),
-      gang: (g: unknown) => helpers.gang(functionPath, g),
-      gangMember: (m: unknown) => helpers.gangMember(functionPath, m),
-      gangTask: (t: unknown) => helpers.gangTask(functionPath, t),
-    },
+    functionPath,
   };
   function wrappedFunction(...args: unknown[]): unknown {
-    helpers.updateDynamicRam(ctx.function, getRamCost(Player, ...tree, ctx.function));
+    helpers.checkEnvFlags(ctx);
+    helpers.updateDynamicRam(ctx, getRamCost(Player, ...tree, ctx.function));
     return func(ctx)(...args);
   }
-  const parent = getNestedProperty(wrappedAPI, ...tree);
+  const parent = getNestedProperty(wrappedAPI, tree);
   Object.defineProperty(parent, functionName, {
     value: wrappedFunction,
     writable: true,
@@ -118,20 +61,25 @@ function wrapFunction(
   });
 }
 
-export function wrapAPI(
-  helpers: INetscriptHelper,
-  wrappedAPI: ExternalAPI,
+export function wrapAPI(workerScript: WorkerScript, namespace: object, args: ScriptArg[]): NSFull {
+  const wrappedAPI = wrapAPILayer({}, workerScript, namespace);
+  wrappedAPI.args = args;
+  return wrappedAPI as unknown as NSFull;
+}
+
+export function wrapAPILayer(
+  wrappedAPI: ExternalAPILayer,
   workerScript: WorkerScript,
   namespace: object,
   ...tree: string[]
-): WrappedNetscriptAPI {
+) {
   for (const [key, value] of Object.entries(namespace)) {
     if (typeof value === "function") {
-      wrapFunction(helpers, wrappedAPI, workerScript, value, ...tree, key);
+      wrapFunction(wrappedAPI, workerScript, value, ...tree, key);
     } else if (Array.isArray(value)) {
-      setNestedProperty(wrappedAPI, value, key);
+      setNestedProperty(wrappedAPI, value.slice(), key);
     } else if (typeof value === "object") {
-      wrapAPI(helpers, wrappedAPI, workerScript, value, ...tree, key);
+      wrapAPILayer(wrappedAPI, workerScript, value, ...tree, key);
     } else {
       setNestedProperty(wrappedAPI, value, ...tree, key);
     }
@@ -139,28 +87,21 @@ export function wrapAPI(
   return wrappedAPI;
 }
 
-// TODO: This doesn't even work properly.
-function setNestedProperty(root: object, value: unknown, ...tree: string[]): void {
+function setNestedProperty(root: any, value: unknown, ...tree: string[]): void {
   let target = root;
   const key = tree.pop();
-  if (!key) {
-    throw new Error("Failure occured while wrapping netscript api (setNestedProperty)");
+  if (!key) throw new Error("Failure occured while wrapping netscript api (setNestedProperty)");
+  for (const branch of tree) {
+    target[branch] ??= {};
+    target = target[branch];
   }
-  for (let branch of Object.values(target)) {
-    if (branch === undefined) {
-      branch = {};
-    }
-    target = branch;
-  }
-  Object.assign(target, { [key]: value });
+  target[key] = value;
 }
 
-function getNestedProperty(root: any, ...tree: string[]): unknown {
+function getNestedProperty(root: any, tree: string[]): unknown {
   let target = root;
   for (const branch of tree) {
-    if (target[branch] === undefined) {
-      target[branch] = {};
-    }
+    target[branch] ??= {};
     target = target[branch];
   }
   return target;
diff --git a/src/Netscript/Environment.ts b/src/Netscript/Environment.ts
index 919d593ab..6985ec043 100644
--- a/src/Netscript/Environment.ts
+++ b/src/Netscript/Environment.ts
@@ -10,6 +10,12 @@ export class Environment {
    */
   stopFlag = false;
 
+  /**
+   * The currently running function
+   */
+
+  runningFn = "";
+
   /**
    * Environment variables (currently only Netscript functions)
    */
diff --git a/src/Netscript/NetscriptHelpers.ts b/src/Netscript/NetscriptHelpers.ts
new file mode 100644
index 000000000..7752c6eac
--- /dev/null
+++ b/src/Netscript/NetscriptHelpers.ts
@@ -0,0 +1,665 @@
+import { NetscriptContext } from "./APIWrapper";
+import { WorkerScript } from "./WorkerScript";
+import { GetAllServers, GetServer } from "../Server/AllServers";
+import { Player } from "../Player";
+import { ScriptDeath } from "./ScriptDeath";
+import { isString } from "../utils/helpers/isString";
+import { numeralWrapper } from "../ui/numeralFormat";
+import { ScriptArg } from "./ScriptArg";
+import { CityName } from "../Locations/data/CityNames";
+import { BasicHGWOptions } from "src/ScriptEditor/NetscriptDefinitions";
+import { Server } from "../Server/Server";
+import {
+  calculateHackingChance,
+  calculateHackingExpGain,
+  calculateHackingTime,
+  calculatePercentMoneyHacked,
+} from "../Hacking";
+import { netscriptCanHack } from "../Hacking/netscriptCanHack";
+import { convertTimeMsToTimeElapsedString } from "../utils/StringHelperFunctions";
+import { BitNodeMultipliers } from "../BitNode/BitNodeMultipliers";
+import { CONSTANTS } from "../Constants";
+import { influenceStockThroughServerHack } from "../StockMarket/PlayerInfluencing";
+import { IPort } from "../NetscriptPort";
+import { NetscriptPorts } from "../NetscriptWorker";
+import { IPlayer } from "../PersonObjects/IPlayer";
+import { FormulaGang } from "../Gang/formulas/formulas";
+import { GangMember } from "../Gang/GangMember";
+import { GangMemberTask } from "../Gang/GangMemberTask";
+import { RunningScript } from "../Script/RunningScript";
+import { toNative } from "../NetscriptFunctions/toNative";
+import { ScriptIdentifier } from "./ScriptIdentifier";
+import { findRunningScript, findRunningScriptByPid } from "../Script/ScriptHelpers";
+import { RunningScript as IRunningScript } from "../ScriptEditor/NetscriptDefinitions";
+import { arrayToString } from "../utils/helpers/arrayToString";
+import { HacknetServer } from "../Hacknet/HacknetServer";
+import { BaseServer } from "../Server/BaseServer";
+
+export const helpers = {
+  string,
+  number,
+  scriptArgs,
+  argsToString,
+  isScriptErrorMessage,
+  makeRuntimeRejectMsg,
+  makeRuntimeErrorMsg,
+  resolveNetscriptRequestedThreads,
+  checkEnvFlags,
+  checkSingularityAccess,
+  netscriptDelay,
+  updateDynamicRam,
+  city,
+  getServer,
+  scriptIdentifier,
+  hack,
+  getValidPort,
+  player,
+  server,
+  gang,
+  gangMember,
+  gangTask,
+  log,
+  getFunctionNames,
+  getRunningScript,
+  getRunningScriptByArgs,
+  getCannotFindRunningScriptErrorMessage,
+  createPublicRunningScript,
+  failOnHacknetServer,
+};
+
+/** Convert a provided value v for argument argName to string. If it wasn't originally a string or number, throw. */
+function string(ctx: NetscriptContext, argName: string, v: unknown): string {
+  if (typeof v === "string") return v;
+  if (typeof v === "number") return v + ""; // cast to string;
+  throw makeRuntimeErrorMsg(ctx, `'${argName}' should be a string.`);
+}
+
+/** Convert provided value v for argument argName to number. Throw if could not convert to a non-NaN number. */
+function number(ctx: NetscriptContext, argName: string, v: unknown): number {
+  if (typeof v === "string") {
+    const x = parseFloat(v);
+    if (!isNaN(x)) return x; // otherwise it wasn't even a string representing a number.
+  } else if (typeof v === "number") {
+    if (isNaN(v)) throw makeRuntimeErrorMsg(ctx, `'${argName}' is NaN.`);
+    return v;
+  }
+  throw makeRuntimeErrorMsg(ctx, `'${argName}' should be a number.`);
+}
+
+/** Returns args back if it is a ScriptArg[]. Throws an error if it is not. */
+function scriptArgs(ctx: NetscriptContext, args: unknown) {
+  if (!isScriptArgs(args)) throw makeRuntimeErrorMsg(ctx, "'args' is not an array of script args");
+  return args;
+}
+
+/** Determines if the given msg string is an error created by makeRuntimeRejectMsg. */
+function isScriptErrorMessage(msg: string): boolean {
+  if (!isString(msg)) {
+    return false;
+  }
+  const splitMsg = msg.split("|DELIMITER|");
+  return splitMsg.length == 4;
+}
+
+/** Convert multiple arguments for tprint or print into a single string. */
+function argsToString(args: unknown[]): string {
+  let out = "";
+  for (let arg of args) {
+    if (arg === null) {
+      out += "null";
+      continue;
+    }
+    if (arg === undefined) {
+      out += "undefined";
+      continue;
+    }
+    arg = toNative(arg);
+    out += typeof arg === "object" ? JSON.stringify(arg) : `${arg}`;
+  }
+
+  return out;
+}
+
+/** Creates an error message string containing hostname, scriptname, and the error message msg */
+function makeRuntimeRejectMsg(workerScript: WorkerScript, msg: string): string {
+  for (const scriptUrl of workerScript.scriptRef.dependencies) {
+    msg = msg.replace(new RegExp(scriptUrl.url, "g"), scriptUrl.filename);
+  }
+
+  return "|DELIMITER|" + workerScript.hostname + "|DELIMITER|" + workerScript.name + "|DELIMITER|" + msg;
+}
+
+/** Creates an error message string with a stack trace. */
+function makeRuntimeErrorMsg(ctx: NetscriptContext, msg: string): string {
+  const errstack = new Error().stack;
+  if (errstack === undefined) throw new Error("how did we not throw an error?");
+  const stack = errstack.split("\n").slice(1);
+  const workerScript = ctx.workerScript;
+  const caller = ctx.function;
+  const scripts = workerScript.getServer().scripts;
+  const userstack = [];
+  for (const stackline of stack) {
+    let filename;
+    for (const script of scripts) {
+      if (script.url && stackline.includes(script.url)) {
+        filename = script.filename;
+      }
+      for (const dependency of script.dependencies) {
+        if (stackline.includes(dependency.url)) {
+          filename = dependency.filename;
+        }
+      }
+    }
+    if (!filename) continue;
+
+    interface ILine {
+      line: string;
+      func: string;
+    }
+
+    function parseChromeStackline(line: string): ILine | null {
+      const lineRe = /.*:(\d+):\d+.*/;
+      const funcRe = /.*at (.+) \(.*/;
+
+      const lineMatch = line.match(lineRe);
+      const funcMatch = line.match(funcRe);
+      if (lineMatch && funcMatch) {
+        return { line: lineMatch[1], func: funcMatch[1] };
+      }
+      return null;
+    }
+    let call = { line: "-1", func: "unknown" };
+    const chromeCall = parseChromeStackline(stackline);
+    if (chromeCall) {
+      call = chromeCall;
+    }
+
+    function parseFirefoxStackline(line: string): ILine | null {
+      const lineRe = /.*:(\d+):\d+$/;
+      const lineMatch = line.match(lineRe);
+
+      const lio = line.lastIndexOf("@");
+
+      if (lineMatch && lio !== -1) {
+        return { line: lineMatch[1], func: line.slice(0, lio) };
+      }
+      return null;
+    }
+
+    const firefoxCall = parseFirefoxStackline(stackline);
+    if (firefoxCall) {
+      call = firefoxCall;
+    }
+
+    userstack.push(`${filename}:L${call.line}@${call.func}`);
+  }
+
+  workerScript.log(caller, () => msg);
+  let rejectMsg = `${caller}: ${msg}`;
+  if (userstack.length !== 0) rejectMsg += `<br><br>Stack:<br>${userstack.join("<br>")}`;
+  return makeRuntimeRejectMsg(workerScript, rejectMsg);
+}
+
+/** Validate requested number of threads for h/g/w options */
+function resolveNetscriptRequestedThreads(ctx: NetscriptContext, requestedThreads?: number): number {
+  const threads = ctx.workerScript.scriptRef.threads;
+  if (!requestedThreads) {
+    return isNaN(threads) || threads < 1 ? 1 : threads;
+  }
+  const requestedThreadsAsInt = requestedThreads | 0;
+  if (isNaN(requestedThreads) || requestedThreadsAsInt < 1) {
+    throw makeRuntimeRejectMsg(
+      ctx.workerScript,
+      `Invalid thread count passed to ${ctx.function}: ${requestedThreads}. Threads must be a positive number.`,
+    );
+  }
+  if (requestedThreadsAsInt > threads) {
+    throw makeRuntimeRejectMsg(
+      ctx.workerScript,
+      `Too many threads requested by ${ctx.function}. Requested: ${requestedThreads}. Has: ${threads}.`,
+    );
+  }
+  return requestedThreadsAsInt;
+}
+
+/** Validate singularity access by throwing an error if the player does not have access. */
+function checkSingularityAccess(ctx: NetscriptContext): void {
+  if (Player.bitNodeN !== 4 && Player.sourceFileLvl(4) === 0) {
+    throw makeRuntimeErrorMsg(
+      ctx,
+      `This singularity function requires Source-File 4 to run. A power up you obtain later in the game.
+      It will be very obvious when and how you can obtain it.`,
+    );
+  }
+}
+
+/** Create an error if a script is dead or if concurrent ns function calls are made */
+function checkEnvFlags(ctx: NetscriptContext): void {
+  const ws = ctx.workerScript;
+  if (ws.env.stopFlag) throw new ScriptDeath(ws);
+  if (ws.env.runningFn && ctx.function !== "asleep") {
+    ws.errorMessage = makeRuntimeRejectMsg(
+      ws,
+      `Concurrent calls to Netscript functions are not allowed!
+      Did you forget to await hack(), grow(), or some other
+      promise-returning function?
+      Currently running: ${ws.env.runningFn} tried to run: ${ctx.function}`,
+    );
+    if (ws.delayReject) ws.delayReject(new ScriptDeath(ws));
+    throw new ScriptDeath(ws); //No idea if this is the right thing to throw
+  }
+}
+
+/** Set a timeout for performing a task, mark the script as busy in the meantime. */
+function netscriptDelay(ctx: NetscriptContext, time: number): Promise<void> {
+  const ws = ctx.workerScript;
+  return new Promise(function (resolve, reject) {
+    ws.delay = window.setTimeout(() => {
+      ws.delay = null;
+      ws.delayReject = undefined;
+      ws.env.runningFn = "";
+      if (ws.env.stopFlag) reject(new ScriptDeath(ws));
+      else resolve();
+    }, time);
+    ws.delayReject = reject;
+    ws.env.runningFn = ctx.function;
+  });
+}
+
+/** Adds to dynamic ram cost when calling new ns functions from a script */
+function updateDynamicRam(ctx: NetscriptContext, ramCost: number): void {
+  const ws = ctx.workerScript;
+  const fnName = ctx.function;
+  if (ws.dynamicLoadedFns[fnName]) return;
+  ws.dynamicLoadedFns[fnName] = true;
+
+  let threads = ws.scriptRef.threads;
+  if (typeof threads !== "number") {
+    console.warn(`WorkerScript detected NaN for threadcount for ${ws.name} on ${ws.hostname}`);
+    threads = 1;
+  }
+  ws.dynamicRamUsage += ramCost;
+  if (ws.dynamicRamUsage > 1.01 * ws.ramUsage) {
+    ws.errorMessage = makeRuntimeRejectMsg(
+      ws,
+      `Dynamic RAM usage calculated to be greater than initial RAM usage on fn: ${fnName}.
+      This is probably because you somehow circumvented the static RAM calculation.
+
+      Threads: ${threads}
+      Dynamic RAM Usage: ${numeralWrapper.formatRAM(ws.dynamicRamUsage)}
+      Static RAM Usage: ${numeralWrapper.formatRAM(ws.ramUsage)}
+
+      One of these could be the reason:
+      * Using eval() to get a reference to a ns function
+      &nbsp;&nbsp;const myScan = eval('ns.scan');
+
+      * Using map access to do the same
+      &nbsp;&nbsp;const myScan = ns['scan'];
+
+      Sorry :(`,
+    );
+  }
+}
+
+/** Validates the input v as being a CityName. Throws an error if it is not. */
+function city(ctx: NetscriptContext, argName: string, v: unknown): CityName {
+  if (typeof v !== "string") throw makeRuntimeErrorMsg(ctx, `${argName} should be a city name.`);
+  const s = v as CityName;
+  if (!Object.values(CityName).includes(s)) throw makeRuntimeErrorMsg(ctx, `${argName} should be a city name.`);
+  return s;
+}
+
+function scriptIdentifier(
+  ctx: NetscriptContext,
+  scriptID: unknown,
+  _hostname: unknown,
+  _args: unknown,
+): ScriptIdentifier {
+  const ws = ctx.workerScript;
+  // Provide the pid for the current script if no identifier provided
+  if (scriptID === undefined) return ws.pid;
+  if (typeof scriptID === "number") return scriptID;
+  if (typeof scriptID === "string") {
+    const hostname = _hostname === undefined ? ctx.workerScript.hostname : string(ctx, "hostname", _hostname);
+    const args = _args === undefined ? [] : scriptArgs(ctx, _args);
+    return {
+      scriptname: scriptID,
+      hostname,
+      args,
+    };
+  }
+  throw new Error("not implemented");
+}
+
+/**
+ * Gets the Server for a specific hostname/ip, throwing an error
+ * if the server doesn't exist.
+ * @param {NetscriptContext} ctx - Context from which getServer is being called. For logging purposes.
+ * @param {string} hostname - Hostname of the server
+ * @returns {BaseServer} The specified server as a BaseServer
+ */
+function getServer(ctx: NetscriptContext, hostname: string) {
+  const server = GetServer(hostname);
+  if (server == null) {
+    const str = hostname === "" ? "'' (empty string)" : "'" + hostname + "'";
+    throw makeRuntimeErrorMsg(ctx, `Invalid hostname: ${str}`);
+  }
+  return server;
+}
+
+function isScriptArgs(args: unknown): args is ScriptArg[] {
+  const isScriptArg = (arg: unknown) => typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean";
+  return Array.isArray(args) && args.every(isScriptArg);
+}
+
+async function hack(
+  ctx: NetscriptContext,
+  hostname: string,
+  manual: boolean,
+  { threads: requestedThreads, stock }: BasicHGWOptions = {},
+): Promise<number> {
+  const ws = ctx.workerScript;
+  const threads = helpers.resolveNetscriptRequestedThreads(ctx, requestedThreads);
+  const server = getServer(ctx, hostname);
+  if (!(server instanceof Server)) {
+    throw makeRuntimeErrorMsg(ctx, "Cannot be executed on this server.");
+  }
+
+  // Calculate the hacking time
+  const hackingTime = calculateHackingTime(server, Player); // This is in seconds
+
+  // No root access or skill level too low
+  const canHack = netscriptCanHack(server, Player);
+  if (!canHack.res) {
+    throw makeRuntimeErrorMsg(ctx, canHack.msg || "");
+  }
+
+  log(
+    ctx,
+    () =>
+      `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
+        hackingTime * 1000,
+        true,
+      )} (t=${numeralWrapper.formatThreads(threads)})`,
+  );
+
+  return helpers.netscriptDelay(ctx, hackingTime * 1000).then(function () {
+    const hackChance = calculateHackingChance(server, Player);
+    const rand = Math.random();
+    let expGainedOnSuccess = calculateHackingExpGain(server, Player) * threads;
+    const expGainedOnFailure = expGainedOnSuccess / 4;
+    if (rand < hackChance) {
+      // Success!
+      const percentHacked = calculatePercentMoneyHacked(server, Player);
+      let maxThreadNeeded = Math.ceil(1 / percentHacked);
+      if (isNaN(maxThreadNeeded)) {
+        // Server has a 'max money' of 0 (probably). We'll set this to an arbitrarily large value
+        maxThreadNeeded = 1e6;
+      }
+
+      let moneyDrained = Math.floor(server.moneyAvailable * percentHacked) * threads;
+
+      // Over-the-top safety checks
+      if (moneyDrained <= 0) {
+        moneyDrained = 0;
+        expGainedOnSuccess = expGainedOnFailure;
+      }
+      if (moneyDrained > server.moneyAvailable) {
+        moneyDrained = server.moneyAvailable;
+      }
+      server.moneyAvailable -= moneyDrained;
+      if (server.moneyAvailable < 0) {
+        server.moneyAvailable = 0;
+      }
+
+      let moneyGained = moneyDrained * BitNodeMultipliers.ScriptHackMoneyGain;
+      if (manual) {
+        moneyGained = moneyDrained * BitNodeMultipliers.ManualHackMoney;
+      }
+
+      Player.gainMoney(moneyGained, "hacking");
+      ws.scriptRef.onlineMoneyMade += moneyGained;
+      Player.scriptProdSinceLastAug += moneyGained;
+      ws.scriptRef.recordHack(server.hostname, moneyGained, threads);
+      Player.gainHackingExp(expGainedOnSuccess);
+      if (manual) Player.gainIntelligenceExp(0.005);
+      ws.scriptRef.onlineExpGained += expGainedOnSuccess;
+      log(
+        ctx,
+        () =>
+          `Successfully hacked '${server.hostname}' for ${numeralWrapper.formatMoney(
+            moneyGained,
+          )} and ${numeralWrapper.formatExp(expGainedOnSuccess)} exp (t=${numeralWrapper.formatThreads(threads)})`,
+      );
+      server.fortify(CONSTANTS.ServerFortifyAmount * Math.min(threads, maxThreadNeeded));
+      if (stock) {
+        influenceStockThroughServerHack(server, moneyDrained);
+      }
+      if (manual) {
+        server.backdoorInstalled = true;
+      }
+      return Promise.resolve(moneyGained);
+    } else {
+      // Player only gains 25% exp for failure?
+      Player.gainHackingExp(expGainedOnFailure);
+      ws.scriptRef.onlineExpGained += expGainedOnFailure;
+      log(
+        ctx,
+        () =>
+          `Failed to hack '${server.hostname}'. Gained ${numeralWrapper.formatExp(
+            expGainedOnFailure,
+          )} exp (t=${numeralWrapper.formatThreads(threads)})`,
+      );
+      return Promise.resolve(0);
+    }
+  });
+}
+
+function getValidPort(ctx: NetscriptContext, port: number): IPort {
+  if (isNaN(port)) {
+    throw makeRuntimeErrorMsg(
+      ctx,
+      `Invalid argument. Must be a port number between 1 and ${CONSTANTS.NumNetscriptPorts}, is ${port}`,
+    );
+  }
+  port = Math.round(port);
+  if (port < 1 || port > CONSTANTS.NumNetscriptPorts) {
+    throw makeRuntimeErrorMsg(
+      ctx,
+      `Trying to use an invalid port: ${port}. Only ports 1-${CONSTANTS.NumNetscriptPorts} are valid.`,
+    );
+  }
+  const iport = NetscriptPorts[port - 1];
+  if (iport == null || !(iport instanceof Object)) {
+    throw makeRuntimeErrorMsg(ctx, `Could not find port: ${port}. This is a bug. Report to dev.`);
+  }
+  return iport;
+}
+
+function player(ctx: NetscriptContext, p: unknown): IPlayer {
+  const fakePlayer = {
+    hp: undefined,
+    mults: undefined,
+    numPeopleKilled: undefined,
+    money: undefined,
+    city: undefined,
+    location: undefined,
+    bitNodeN: undefined,
+    totalPlaytime: undefined,
+    playtimeSinceLastAug: undefined,
+    playtimeSinceLastBitnode: undefined,
+    jobs: undefined,
+    factions: undefined,
+    tor: undefined,
+    inBladeburner: undefined,
+    hasCorporation: undefined,
+    entropy: undefined,
+  };
+  if (!roughlyIs(fakePlayer, p)) throw makeRuntimeErrorMsg(ctx, `player should be a Player.`);
+  return p as IPlayer;
+}
+
+function server(ctx: NetscriptContext, s: unknown): Server {
+  if (!roughlyIs(new Server(), s)) throw makeRuntimeErrorMsg(ctx, `server should be a Server.`);
+  return s as Server;
+}
+
+function roughlyIs(expect: object, actual: unknown): boolean {
+  if (typeof actual !== "object" || actual == null) return false;
+  const expects = Object.keys(expect);
+  const actuals = Object.keys(actual);
+  for (const expect of expects)
+    if (!actuals.includes(expect)) {
+      return false;
+    }
+  return true;
+}
+
+function gang(ctx: NetscriptContext, g: unknown): FormulaGang {
+  if (!roughlyIs({ respect: 0, territory: 0, wantedLevel: 0 }, g))
+    throw makeRuntimeErrorMsg(ctx, `gang should be a Gang.`);
+  return g as FormulaGang;
+}
+
+function gangMember(ctx: NetscriptContext, m: unknown): GangMember {
+  if (!roughlyIs(new GangMember(), m)) throw makeRuntimeErrorMsg(ctx, `member should be a GangMember.`);
+  return m as GangMember;
+}
+
+function gangTask(ctx: NetscriptContext, t: unknown): GangMemberTask {
+  if (!roughlyIs(new GangMemberTask("", "", false, false, {}), t))
+    throw makeRuntimeErrorMsg(ctx, `task should be a GangMemberTask.`);
+  return t as GangMemberTask;
+}
+
+function log(ctx: NetscriptContext, message: () => string) {
+  ctx.workerScript.log(ctx.functionPath, message);
+}
+
+/**
+ * Searches for and returns the RunningScript object for the specified script.
+ * If the 'fn' argument is not specified, this returns the current RunningScript.
+ * @param {string} fn - Filename of script
+ * @param {string} hostname - Hostname/ip of the server on which the script resides
+ * @param {any[]} scriptArgs - Running script's arguments
+ * @returns {RunningScript}
+ *      Running script identified by the parameters, or null if no such script
+ *      exists, or the current running script if the first argument 'fn'
+ *      is not specified.
+ */
+function getRunningScriptByArgs(
+  ctx: NetscriptContext,
+  fn: string,
+  hostname: string,
+  scriptArgs: ScriptArg[],
+): RunningScript | null {
+  if (!Array.isArray(scriptArgs)) {
+    throw helpers.makeRuntimeRejectMsg(
+      ctx.workerScript,
+      `Invalid scriptArgs argument passed into getRunningScript() from ${ctx.function}(). ` +
+        `This is probably a bug. Please report to game developer`,
+    );
+  }
+
+  if (fn != null && typeof fn === "string") {
+    // Get Logs of another script
+    if (hostname == null) {
+      hostname = ctx.workerScript.hostname;
+    }
+    const server = helpers.getServer(ctx, hostname);
+
+    return findRunningScript(fn, scriptArgs, server);
+  }
+
+  // If no arguments are specified, return the current RunningScript
+  return ctx.workerScript.scriptRef;
+}
+
+/** Provides an array of all function names on a nested object */
+function getFunctionNames(obj: object, prefix: string): string[] {
+  const functionNames: string[] = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "args") {
+      continue;
+    } else if (typeof value == "function") {
+      functionNames.push(prefix + key);
+    } else if (typeof value == "object") {
+      functionNames.push(...getFunctionNames(value, key + "."));
+    }
+  }
+  return functionNames;
+}
+
+function getRunningScriptByPid(pid: number): RunningScript | null {
+  for (const server of GetAllServers()) {
+    const runningScript = findRunningScriptByPid(pid, server);
+    if (runningScript) return runningScript;
+  }
+  return null;
+}
+
+function getRunningScript(ctx: NetscriptContext, ident: ScriptIdentifier): RunningScript | null {
+  if (typeof ident === "number") {
+    return getRunningScriptByPid(ident);
+  } else {
+    return getRunningScriptByArgs(ctx, ident.scriptname, ident.hostname, ident.args);
+  }
+}
+
+/**
+ * Helper function for getting the error log message when the user specifies
+ * a nonexistent running script
+ * @param {string} fn - Filename of script
+ * @param {string} hostname - Hostname/ip of the server on which the script resides
+ * @param {any[]} scriptArgs - Running script's arguments
+ * @returns {string} Error message to print to logs
+ */
+function getCannotFindRunningScriptErrorMessage(ident: ScriptIdentifier): string {
+  if (typeof ident === "number") return `Cannot find running script with pid: ${ident}`;
+
+  return `Cannot find running script ${ident.scriptname} on server ${ident.hostname} with args: ${arrayToString(
+    ident.args,
+  )}`;
+}
+
+/**
+ * Sanitizes a `RunningScript` to remove sensitive information, making it suitable for
+ * return through an NS function.
+ * @see NS.getRecentScripts
+ * @see NS.getRunningScript
+ * @param runningScript Existing, internal RunningScript
+ * @returns A sanitized, NS-facing copy of the RunningScript
+ */
+function createPublicRunningScript(runningScript: RunningScript): IRunningScript {
+  return {
+    args: runningScript.args.slice(),
+    filename: runningScript.filename,
+    logs: runningScript.logs.slice(),
+    offlineExpGained: runningScript.offlineExpGained,
+    offlineMoneyMade: runningScript.offlineMoneyMade,
+    offlineRunningTime: runningScript.offlineRunningTime,
+    onlineExpGained: runningScript.onlineExpGained,
+    onlineMoneyMade: runningScript.onlineMoneyMade,
+    onlineRunningTime: runningScript.onlineRunningTime,
+    pid: runningScript.pid,
+    ramUsage: runningScript.ramUsage,
+    server: runningScript.server,
+    threads: runningScript.threads,
+  };
+}
+
+/**
+ * Used to fail a function if the function's target is a Hacknet Server.
+ * This is used for functions that should run on normal Servers, but not Hacknet Servers
+ * @param {Server} server - Target server
+ * @param {string} callingFn - Name of calling function. For logging purposes
+ * @returns {boolean} True if the server is a Hacknet Server, false otherwise
+ */
+function failOnHacknetServer(ctx: NetscriptContext, server: BaseServer, callingFn = ""): boolean {
+  if (server instanceof HacknetServer) {
+    ctx.workerScript.log(callingFn, () => `Does not work on Hacknet Servers`);
+    return true;
+  } else {
+    return false;
+  }
+}
diff --git a/src/Netscript/RamCostGenerator.ts b/src/Netscript/RamCostGenerator.ts
index 46a1226ae..43c1b9498 100644
--- a/src/Netscript/RamCostGenerator.ts
+++ b/src/Netscript/RamCostGenerator.ts
@@ -346,6 +346,11 @@ const grafting = {
 };
 
 const corporation = {
+  getMaterialNames: 0,
+  getIndustryTypes: 0,
+  getUnlockables: 0,
+  getUpgradeNames: 0,
+  getResearchNames: 0,
   createCorporation: 0,
   hasUnlockUpgrade: 0,
   getUnlockUpgradeCost: 0,
diff --git a/src/Netscript/ScriptIdentifier.ts b/src/Netscript/ScriptIdentifier.ts
new file mode 100644
index 000000000..aad4e24c4
--- /dev/null
+++ b/src/Netscript/ScriptIdentifier.ts
@@ -0,0 +1,9 @@
+import { ScriptArg } from "./ScriptArg";
+
+export type ScriptIdentifier =  //This was previously in INetscriptHelper.ts, may move to its own file or a generic types file.
+  | number
+  | {
+      scriptname: string;
+      hostname: string;
+      args: ScriptArg[];
+    };
diff --git a/src/Netscript/killWorkerScript.ts b/src/Netscript/killWorkerScript.ts
index 2ad5f00bc..70b716a7a 100644
--- a/src/Netscript/killWorkerScript.ts
+++ b/src/Netscript/killWorkerScript.ts
@@ -10,7 +10,6 @@ import { WorkerScriptStartStopEventEmitter } from "./WorkerScriptStartStopEventE
 import { RunningScript } from "../Script/RunningScript";
 import { GetServer } from "../Server/AllServers";
 
-import { compareArrays } from "../utils/helpers/compareArrays";
 import { dialogBoxCreate } from "../ui/React/DialogBox";
 import { AddRecentScript } from "./RecentScripts";
 import { Player } from "../Player";
@@ -33,13 +32,8 @@ export function killWorkerScript(params: killScriptParams): boolean {
 
     // If for some reason that doesn't work, we'll try the old way
     for (const ws of workerScripts.values()) {
-      if (
-        ws.name == params.runningScript.filename &&
-        ws.hostname == params.hostname &&
-        compareArrays(ws.args, params.runningScript.args)
-      ) {
+      if (ws.scriptRef === params.runningScript) {
         stopAndCleanUpWorkerScript(ws);
-
         return true;
       }
     }
@@ -52,7 +46,6 @@ function killWorkerScriptByPid(pid: number): boolean {
   const ws = workerScripts.get(pid);
   if (ws instanceof WorkerScript) {
     stopAndCleanUpWorkerScript(ws);
-
     return true;
   }
 
@@ -86,7 +79,6 @@ function stopAndCleanUpWorkerScript(workerScript: WorkerScript): void {
  */
 function removeWorkerScript(workerScript: WorkerScript): void {
   const ip = workerScript.hostname;
-  const name = workerScript.name;
 
   // Get the server on which the script runs
   const server = GetServer(ip);
@@ -98,7 +90,7 @@ function removeWorkerScript(workerScript: WorkerScript): void {
   // Delete the RunningScript object from that server
   for (let i = 0; i < server.runningScripts.length; ++i) {
     const runningScript = server.runningScripts[i];
-    if (runningScript.filename === name && compareArrays(runningScript.args, workerScript.args)) {
+    if (runningScript === workerScript.scriptRef) {
       server.runningScripts.splice(i, 1);
       break;
     }
diff --git a/src/NetscriptEvaluator.ts b/src/NetscriptEvaluator.ts
deleted file mode 100644
index bde595160..000000000
--- a/src/NetscriptEvaluator.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { isString } from "./utils/helpers/isString";
-import { GetServer } from "./Server/AllServers";
-import { ScriptDeath } from "./Netscript/ScriptDeath";
-import { WorkerScript } from "./Netscript/WorkerScript";
-import { NetscriptContext } from "./Netscript/APIWrapper";
-
-export function netscriptDelay(time: number, workerScript: WorkerScript): Promise<void> {
-  // Cancel any pre-existing netscriptDelay'ed function call
-  // TODO: the rejection almost certainly ends up in the uncaught rejection handler.
-  //       Maybe reject with a stack-trace'd error message?
-  if (workerScript.delayReject) workerScript.delayReject();
-
-  return new Promise(function (resolve, reject) {
-    workerScript.delay = window.setTimeout(() => {
-      workerScript.delay = null;
-      workerScript.delayReject = undefined;
-      if (workerScript.env.stopFlag) reject(new ScriptDeath(workerScript));
-      else resolve();
-    }, time);
-    workerScript.delayReject = reject;
-  });
-}
-
-export function makeRuntimeRejectMsg(workerScript: WorkerScript, msg: string): string {
-  const server = GetServer(workerScript.hostname);
-  if (server == null) {
-    throw new Error(`WorkerScript constructed with invalid server ip: ${workerScript.hostname}`);
-  }
-
-  for (const scriptUrl of workerScript.scriptRef.dependencies) {
-    // Return just the original msg if it's nullish so that we don't get a workerscript error
-    msg = msg?.replace(new RegExp(scriptUrl.url, "g"), scriptUrl.filename) ?? msg;
-  }
-
-  return "|DELIMITER|" + server.hostname + "|DELIMITER|" + workerScript.name + "|DELIMITER|" + msg;
-}
-
-export function resolveNetscriptRequestedThreads(ctx: NetscriptContext, requestedThreads?: number): number {
-  const threads = ctx.workerScript.scriptRef.threads;
-  if (!requestedThreads) {
-    return isNaN(threads) || threads < 1 ? 1 : threads;
-  }
-  const requestedThreadsAsInt = requestedThreads | 0;
-  if (isNaN(requestedThreads) || requestedThreadsAsInt < 1) {
-    throw makeRuntimeRejectMsg(
-      ctx.workerScript,
-      `Invalid thread count passed to ${ctx.function}: ${requestedThreads}. Threads must be a positive number.`,
-    );
-  }
-  if (requestedThreadsAsInt > threads) {
-    throw makeRuntimeRejectMsg(
-      ctx.workerScript,
-      `Too many threads requested by ${ctx.function}. Requested: ${requestedThreads}. Has: ${threads}.`,
-    );
-  }
-  return requestedThreadsAsInt;
-}
-
-export function isScriptErrorMessage(msg: string): boolean {
-  if (!isString(msg)) {
-    return false;
-  }
-  const splitMsg = msg.split("|DELIMITER|");
-  return splitMsg.length == 4;
-}
diff --git a/src/NetscriptFunctions.ts b/src/NetscriptFunctions.ts
index eefec8927..2c617b4b6 100644
--- a/src/NetscriptFunctions.ts
+++ b/src/NetscriptFunctions.ts
@@ -1,12 +1,8 @@
 import $ from "jquery";
 import { vsprintf, sprintf } from "sprintf-js";
-
 import { WorkerScriptStartStopEventEmitter } from "./Netscript/WorkerScriptStartStopEventEmitter";
-
 import { BitNodeMultipliers } from "./BitNode/BitNodeMultipliers";
-
 import { CONSTANTS } from "./Constants";
-
 import {
   calculateHackingChance,
   calculateHackingExpGain,
@@ -15,22 +11,14 @@ import {
   calculateGrowTime,
   calculateWeakenTime,
 } from "./Hacking";
-
-import { netscriptCanGrow, netscriptCanHack, netscriptCanWeaken } from "./Hacking/netscriptCanHack";
-
-import { HacknetServer } from "./Hacknet/HacknetServer";
-
+import { netscriptCanGrow, netscriptCanWeaken } from "./Hacking/netscriptCanHack";
 import { Terminal } from "./Terminal";
-
 import { Player } from "./Player";
 import { Programs } from "./Programs/Programs";
 import { Script } from "./Script/Script";
-import { findRunningScript, findRunningScriptByPid } from "./Script/ScriptHelpers";
 import { isScriptFilename } from "./Script/isScriptFilename";
 import { PromptEvent } from "./ui/React/PromptManager";
-
-import { GetServer, GetAllServers, DeleteServer, AddToAllServers, createUniqueRandomIp } from "./Server/AllServers";
-import { RunningScript } from "./Script/RunningScript";
+import { GetServer, DeleteServer, AddToAllServers, createUniqueRandomIp } from "./Server/AllServers";
 import {
   getServerOnNetwork,
   numCycleForGrowth,
@@ -40,26 +28,19 @@ import {
 } from "./Server/ServerHelpers";
 import { getPurchaseServerCost, getPurchaseServerLimit, getPurchaseServerMaxRam } from "./Server/ServerPurchases";
 import { Server } from "./Server/Server";
-import { influenceStockThroughServerHack, influenceStockThroughServerGrow } from "./StockMarket/PlayerInfluencing";
-
+import { influenceStockThroughServerGrow } from "./StockMarket/PlayerInfluencing";
 import { isValidFilePath, removeLeadingSlash } from "./Terminal/DirectoryHelpers";
 import { TextFile, getTextFile, createTextFile } from "./TextFile";
-
 import { NetscriptPorts, runScriptFromScript } from "./NetscriptWorker";
 import { killWorkerScript } from "./Netscript/killWorkerScript";
 import { workerScripts } from "./Netscript/WorkerScripts";
 import { WorkerScript } from "./Netscript/WorkerScript";
-import { makeRuntimeRejectMsg, netscriptDelay, resolveNetscriptRequestedThreads } from "./NetscriptEvaluator";
-
+import { helpers } from "./Netscript/NetscriptHelpers";
 import { numeralWrapper } from "./ui/numeralFormat";
 import { convertTimeMsToTimeElapsedString } from "./utils/StringHelperFunctions";
-
 import { LogBoxEvents, LogBoxCloserEvents } from "./ui/React/LogBoxManager";
 import { arrayToString } from "./utils/helpers/arrayToString";
 import { isString } from "./utils/helpers/isString";
-import { FormulaGang as FormulaGang } from "./Gang/formulas/formulas";
-
-import { BaseServer } from "./Server/BaseServer";
 import { NetscriptGang } from "./NetscriptFunctions/Gang";
 import { NetscriptSleeve } from "./NetscriptFunctions/Sleeve";
 import { NetscriptExtra } from "./NetscriptFunctions/Extra";
@@ -74,15 +55,9 @@ import { NetscriptFormulas } from "./NetscriptFunctions/Formulas";
 import { NetscriptStockMarket } from "./NetscriptFunctions/StockMarket";
 import { NetscriptGrafting } from "./NetscriptFunctions/Grafting";
 import { IPort } from "./NetscriptPort";
-
 import {
-  NS as INS,
+  NS,
   Player as INetscriptPlayer,
-  Gang as IGang,
-  Bladeburner as IBladeburner,
-  Stanek as IStanek,
-  Infiltration as IInfiltration,
-  RunningScript as IRunningScript,
   RecentScript as IRecentScript,
   BasicHGWOptions,
   ProcessInfo,
@@ -91,12 +66,9 @@ import {
   BitNodeMultipliers as IBNMults,
   Server as IServerDef,
   RunningScript as IRunningScriptDef,
-  // ToastVariant,
 } from "./ScriptEditor/NetscriptDefinitions";
 import { NetscriptSingularity } from "./NetscriptFunctions/Singularity";
 
-import { toNative } from "./NetscriptFunctions/toNative";
-
 import { dialogBoxCreate } from "./ui/React/DialogBox";
 import { SnackbarEvents, ToastVariant } from "./ui/React/Snackbar";
 import { checkEnum } from "./utils/helpers/checkEnum";
@@ -105,2441 +77,1942 @@ import { Flags } from "./NetscriptFunctions/Flags";
 import { calculateIntelligenceBonus } from "./PersonObjects/formulas/intelligence";
 import { CalculateShareMult, StartSharing } from "./NetworkShare/Share";
 import { recentScripts } from "./Netscript/RecentScripts";
-import { CityName } from "./Locations/data/CityNames";
 import { InternalAPI, NetscriptContext, wrapAPI } from "./Netscript/APIWrapper";
-import { INetscriptHelper, ScriptIdentifier } from "./NetscriptFunctions/INetscriptHelper";
-import { IPlayer } from "./PersonObjects/IPlayer";
-import { GangMember } from "./Gang/GangMember";
-import { GangMemberTask } from "./Gang/GangMemberTask";
-import { ScriptArg } from "./Netscript/ScriptArg";
+import { INetscriptExtra } from "./NetscriptFunctions/Extra";
 
-interface NS extends INS {
-  [key: string]: any;
-  gang: IGang;
-  bladeburner: IBladeburner;
-  stanek: IStanek;
-  infiltration: IInfiltration;
+export type NSFull = NS & INetscriptExtra;
+
+export function NetscriptFunctions(workerScript: WorkerScript): NSFull {
+  return wrapAPI(workerScript, ns, workerScript.args.slice());
 }
 
-export function NetscriptFunctions(workerScript: WorkerScript): NS {
-  const updateDynamicRam = function (fnName: string, ramCost: number): void {
-    if (workerScript.dynamicLoadedFns[fnName]) {
-      return;
-    }
-    workerScript.dynamicLoadedFns[fnName] = true;
+const base: InternalAPI<NS> = {
+  args: [],
+  enums: {
+    toast: ToastVariant,
+  },
 
-    let threads = workerScript.scriptRef.threads;
-    if (typeof threads !== "number") {
-      console.warn(`WorkerScript detected NaN for threadcount for ${workerScript.name} on ${workerScript.hostname}`);
-      threads = 1;
-    }
-    workerScript.dynamicRamUsage += ramCost;
-    if (workerScript.dynamicRamUsage > 1.01 * workerScript.ramUsage) {
-      throw makeRuntimeRejectMsg(
-        workerScript,
-        `Dynamic RAM usage calculated to be greater than initial RAM usage on fn: ${fnName}.
-        This is probably because you somehow circumvented the static RAM calculation.
-
-        Threads: ${threads}
-        Dynamic RAM Usage: ${numeralWrapper.formatRAM(workerScript.dynamicRamUsage)}
-        Static RAM Usage: ${numeralWrapper.formatRAM(workerScript.ramUsage)}
-
-        One of these could be the reason:
-        * Using eval() to get a reference to a ns function
-        &nbsp;&nbsp;const myScan = eval('ns.scan');
-
-        * Using map access to do the same
-        &nbsp;&nbsp;const myScan = ns['scan'];
-
-        Sorry :(`,
-      );
-    }
-  };
-
-  /**
-   * Gets the Server for a specific hostname/ip, throwing an error
-   * if the server doesn't exist.
-   * @param {string} hostname - Hostname or IP of the server
-   * @param {string} callingFnName - Name of calling function. For logging purposes
-   * @returns {BaseServer} The specified server as a BaseServer
-   */
-  const safeGetServer = function (hostname: string, ctx: NetscriptContext): BaseServer {
-    const server = GetServer(hostname);
-    if (server == null) {
-      const str = hostname === "" ? "'' (empty string)" : "'" + hostname + "'";
-      throw ctx.makeRuntimeErrorMsg(`Invalid hostname: ${str}`);
-    }
-    return server;
-  };
-
-  /**
-   * Searches for and returns the RunningScript object for the specified script.
-   * If the 'fn' argument is not specified, this returns the current RunningScript.
-   * @param {string} fn - Filename of script
-   * @param {string} hostname - Hostname/ip of the server on which the script resides
-   * @param {any[]} scriptArgs - Running script's arguments
-   * @returns {RunningScript}
-   *      Running script identified by the parameters, or null if no such script
-   *      exists, or the current running script if the first argument 'fn'
-   *      is not specified.
-   */
-  const getRunningScriptByArgs = function (
-    ctx: NetscriptContext,
-    fn: string,
-    hostname: string,
-    scriptArgs: ScriptArg[],
-  ): RunningScript | null {
-    if (!Array.isArray(scriptArgs)) {
-      throw makeRuntimeRejectMsg(
-        workerScript,
-        `Invalid scriptArgs argument passed into getRunningScript() from ${ctx.function}(). ` +
-          `This is probably a bug. Please report to game developer`,
-      );
-    }
-
-    if (fn != null && typeof fn === "string") {
-      // Get Logs of another script
-      if (hostname == null) {
-        hostname = workerScript.hostname;
+  singularity: NetscriptSingularity(),
+  gang: NetscriptGang(),
+  bladeburner: NetscriptBladeburner(),
+  codingcontract: NetscriptCodingContract(),
+  sleeve: NetscriptSleeve(),
+  corporation: NetscriptCorporation(),
+  stanek: NetscriptStanek(),
+  infiltration: NetscriptInfiltration(),
+  ui: NetscriptUserInterface(),
+  formulas: NetscriptFormulas(),
+  stock: NetscriptStockMarket(),
+  grafting: NetscriptGrafting(),
+  hacknet: NetscriptHacknet(),
+  sprintf: () => sprintf,
+  vsprintf: () => vsprintf,
+  scan:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname): string[] => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      const out = [];
+      for (let i = 0; i < server.serversOnNetwork.length; i++) {
+        const s = getServerOnNetwork(server, i);
+        if (s === null) continue;
+        const entry = s.hostname;
+        if (entry === null) continue;
+        out.push(entry);
       }
-      const server = safeGetServer(hostname, ctx);
+      helpers.log(ctx, () => `returned ${server.serversOnNetwork.length} connections for ${server.hostname}`);
+      return out;
+    },
+  hack:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      return helpers.hack(ctx, hostname, false, { threads: requestedThreads, stock: stock });
+    },
+  hackAnalyzeThreads:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown, _hackAmount: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const hackAmount = helpers.number(ctx, "hackAmount", _hackAmount);
 
-      return findRunningScript(fn, scriptArgs, server);
-    }
-
-    // If no arguments are specified, return the current RunningScript
-    return workerScript.scriptRef;
-  };
-
-  const getRunningScriptByPid = function (pid: number): RunningScript | null {
-    for (const server of GetAllServers()) {
-      const runningScript = findRunningScriptByPid(pid, server);
-      if (runningScript) return runningScript;
-    }
-    return null;
-  };
-
-  const getRunningScript = (ctx: NetscriptContext, ident: ScriptIdentifier): RunningScript | null => {
-    if (typeof ident === "number") {
-      return getRunningScriptByPid(ident);
-    } else {
-      return getRunningScriptByArgs(ctx, ident.fn, ident.hostname, ident.args);
-    }
-  };
-
-  /**
-   * Sanitizes a `RunningScript` to remove sensitive information, making it suitable for
-   * return through an NS function.
-   * @see NS.getRecentScripts
-   * @see NS.getRunningScript
-   * @param runningScript Existing, internal RunningScript
-   * @returns A sanitized, NS-facing copy of the RunningScript
-   */
-  const createPublicRunningScript = function (runningScript: RunningScript): IRunningScript {
-    return {
-      args: runningScript.args.slice(),
-      filename: runningScript.filename,
-      logs: runningScript.logs.slice(),
-      offlineExpGained: runningScript.offlineExpGained,
-      offlineMoneyMade: runningScript.offlineMoneyMade,
-      offlineRunningTime: runningScript.offlineRunningTime,
-      onlineExpGained: runningScript.onlineExpGained,
-      onlineMoneyMade: runningScript.onlineMoneyMade,
-      onlineRunningTime: runningScript.onlineRunningTime,
-      pid: runningScript.pid,
-      ramUsage: runningScript.ramUsage,
-      server: runningScript.server,
-      threads: runningScript.threads,
-    };
-  };
-
-  /**
-   * Helper function for getting the error log message when the user specifies
-   * a nonexistent running script
-   * @param {string} fn - Filename of script
-   * @param {string} hostname - Hostname/ip of the server on which the script resides
-   * @param {any[]} scriptArgs - Running script's arguments
-   * @returns {string} Error message to print to logs
-   */
-  const getCannotFindRunningScriptErrorMessage = function (ident: ScriptIdentifier): string {
-    if (typeof ident === "number") return `Cannot find running script with pid: ${ident}`;
-
-    return `Cannot find running script ${ident.fn} on server ${ident.hostname} with args: ${arrayToString(ident.args)}`;
-  };
-
-  /**
-   * Used to fail a function if the function's target is a Hacknet Server.
-   * This is used for functions that should run on normal Servers, but not Hacknet Servers
-   * @param {Server} server - Target server
-   * @param {string} callingFn - Name of calling function. For logging purposes
-   * @returns {boolean} True if the server is a Hacknet Server, false otherwise
-   */
-  const failOnHacknetServer = function (server: BaseServer, callingFn = ""): boolean {
-    if (server instanceof HacknetServer) {
-      workerScript.log(callingFn, () => `Does not work on Hacknet Servers`);
-      return true;
-    } else {
-      return false;
-    }
-  };
-
-  const makeRuntimeErrorMsg = function (caller: string, msg: string): string {
-    const errstack = new Error().stack;
-    if (errstack === undefined) throw new Error("how did we not throw an error?");
-    const stack = errstack.split("\n").slice(1);
-    const scripts = workerScript.getServer().scripts;
-    const userstack = [];
-    for (const stackline of stack) {
-      let filename;
-      for (const script of scripts) {
-        if (script.url && stackline.includes(script.url)) {
-          filename = script.filename;
-        }
-        for (const dependency of script.dependencies) {
-          if (stackline.includes(dependency.url)) {
-            filename = dependency.filename;
-          }
-        }
+      // Check argument validity
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return -1;
       }
-      if (!filename) continue;
-
-      interface ILine {
-        line: string;
-        func: string;
-      }
-
-      function parseChromeStackline(line: string): ILine | null {
-        const lineRe = /.*:(\d+):\d+.*/;
-        const funcRe = /.*at (.+) \(.*/;
-
-        const lineMatch = line.match(lineRe);
-        const funcMatch = line.match(funcRe);
-        if (lineMatch && funcMatch) {
-          return { line: lineMatch[1], func: funcMatch[1] };
-        }
-        return null;
-      }
-      let call = { line: "-1", func: "unknown" };
-      const chromeCall = parseChromeStackline(stackline);
-      if (chromeCall) {
-        call = chromeCall;
-      }
-
-      function parseFirefoxStackline(line: string): ILine | null {
-        const lineRe = /.*:(\d+):\d+$/;
-        const lineMatch = line.match(lineRe);
-
-        const lio = line.lastIndexOf("@");
-
-        if (lineMatch && lio !== -1) {
-          return { line: lineMatch[1], func: line.slice(0, lio) };
-        }
-        return null;
-      }
-
-      const firefoxCall = parseFirefoxStackline(stackline);
-      if (firefoxCall) {
-        call = firefoxCall;
-      }
-
-      userstack.push(`${filename}:L${call.line}@${call.func}`);
-    }
-
-    workerScript.log(caller, () => msg);
-    let rejectMsg = `${caller}: ${msg}`;
-    if (userstack.length !== 0) rejectMsg += `<br><br>Stack:<br>${userstack.join("<br>")}`;
-    return makeRuntimeRejectMsg(workerScript, rejectMsg);
-  };
-
-  const checkSingularityAccess = function (func: string): void {
-    if (Player.bitNodeN !== 4) {
-      if (Player.sourceFileLvl(4) === 0) {
-        throw makeRuntimeErrorMsg(
-          func,
-          `This singularity function requires Source-File 4 to run. A power up you obtain later in the game. It will be very obvious when and how you can obtain it.`,
+      if (isNaN(hackAmount)) {
+        throw helpers.makeRuntimeErrorMsg(
+          ctx,
+          `Invalid hackAmount argument passed into hackAnalyzeThreads: ${hackAmount}. Must be numeric.`,
         );
       }
-    }
-  };
 
-  const hack = async function (
-    ctx: NetscriptContext,
-    hostname: string,
-    manual: boolean,
-    { threads: requestedThreads, stock }: BasicHGWOptions = {},
-  ): Promise<number> {
-    if (hostname === undefined) {
-      throw ctx.makeRuntimeErrorMsg("Takes 1 argument.");
-    }
-    const threads = resolveNetscriptRequestedThreads(ctx, requestedThreads);
-    const server = safeGetServer(hostname, ctx);
-    if (!(server instanceof Server)) {
-      throw ctx.makeRuntimeErrorMsg("Cannot be executed on this server.");
-    }
-
-    // Calculate the hacking time
-    const hackingTime = calculateHackingTime(server, Player); // This is in seconds
-
-    // No root access or skill level too low
-    const canHack = netscriptCanHack(server, Player);
-    if (!canHack.res) {
-      throw ctx.makeRuntimeErrorMsg(canHack.msg || "");
-    }
-
-    ctx.log(
-      () =>
-        `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
-          hackingTime * 1000,
-          true,
-        )} (t=${numeralWrapper.formatThreads(threads)})`,
-    );
-
-    return netscriptDelay(hackingTime * 1000, workerScript).then(function () {
-      const hackChance = calculateHackingChance(server, Player);
-      const rand = Math.random();
-      let expGainedOnSuccess = calculateHackingExpGain(server, Player) * threads;
-      const expGainedOnFailure = expGainedOnSuccess / 4;
-      if (rand < hackChance) {
-        // Success!
-        const percentHacked = calculatePercentMoneyHacked(server, Player);
-        let maxThreadNeeded = Math.ceil(1 / percentHacked);
-        if (isNaN(maxThreadNeeded)) {
-          // Server has a 'max money' of 0 (probably). We'll set this to an arbitrarily large value
-          maxThreadNeeded = 1e6;
-        }
-
-        let moneyDrained = Math.floor(server.moneyAvailable * percentHacked) * threads;
-
-        // Over-the-top safety checks
-        if (moneyDrained <= 0) {
-          moneyDrained = 0;
-          expGainedOnSuccess = expGainedOnFailure;
-        }
-        if (moneyDrained > server.moneyAvailable) {
-          moneyDrained = server.moneyAvailable;
-        }
-        server.moneyAvailable -= moneyDrained;
-        if (server.moneyAvailable < 0) {
-          server.moneyAvailable = 0;
-        }
-
-        let moneyGained = moneyDrained * BitNodeMultipliers.ScriptHackMoneyGain;
-        if (manual) {
-          moneyGained = moneyDrained * BitNodeMultipliers.ManualHackMoney;
-        }
-
-        Player.gainMoney(moneyGained, "hacking");
-        workerScript.scriptRef.onlineMoneyMade += moneyGained;
-        Player.scriptProdSinceLastAug += moneyGained;
-        workerScript.scriptRef.recordHack(server.hostname, moneyGained, threads);
-        Player.gainHackingExp(expGainedOnSuccess);
-        if (manual) Player.gainIntelligenceExp(0.005);
-        workerScript.scriptRef.onlineExpGained += expGainedOnSuccess;
-        ctx.log(
-          () =>
-            `Successfully hacked '${server.hostname}' for ${numeralWrapper.formatMoney(
-              moneyGained,
-            )} and ${numeralWrapper.formatExp(expGainedOnSuccess)} exp (t=${numeralWrapper.formatThreads(threads)})`,
-        );
-        server.fortify(CONSTANTS.ServerFortifyAmount * Math.min(threads, maxThreadNeeded));
-        if (stock) {
-          influenceStockThroughServerHack(server, moneyDrained);
-        }
-        if (manual) {
-          server.backdoorInstalled = true;
-        }
-        return Promise.resolve(moneyGained);
-      } else {
-        // Player only gains 25% exp for failure?
-        Player.gainHackingExp(expGainedOnFailure);
-        workerScript.scriptRef.onlineExpGained += expGainedOnFailure;
-        ctx.log(
-          () =>
-            `Failed to hack '${server.hostname}'. Gained ${numeralWrapper.formatExp(
-              expGainedOnFailure,
-            )} exp (t=${numeralWrapper.formatThreads(threads)})`,
-        );
-        return Promise.resolve(0);
+      if (hackAmount < 0 || hackAmount > server.moneyAvailable) {
+        return -1;
+      } else if (hackAmount === 0) {
+        return 0;
       }
-    });
-  };
 
-  const argsToString = function (args: unknown[]): string {
-    let out = "";
-    for (let arg of args) {
-      if (arg === null) {
-        out += "null";
-        continue;
+      const percentHacked = calculatePercentMoneyHacked(server, Player);
+
+      if (percentHacked === 0 || server.moneyAvailable === 0) {
+        return 0; // To prevent returning infinity below
       }
-      if (arg === undefined) {
-        out += "undefined";
-        continue;
+
+      return hackAmount / Math.floor(server.moneyAvailable * percentHacked);
+    },
+  hackAnalyze:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 0;
       }
-      arg = toNative(arg);
-      out += typeof arg === "object" ? JSON.stringify(arg) : `${arg}`;
-    }
 
-    return out;
-  };
-
-  const roughlyIs = (expect: object, actual: unknown): boolean => {
-    console.log(expect);
-    console.log(actual);
-
-    if (typeof actual !== "object" || actual == null) return false;
-    const expects = Object.keys(expect);
-    const actuals = Object.keys(actual);
-    for (const expect of expects)
-      if (!actuals.includes(expect)) {
-        console.log(expect);
-        return false;
-      }
-    return true;
-  };
-
-  const helperString = (funcName: string, argName: string, v: unknown): string => {
-    if (typeof v === "string") return v;
-    if (typeof v === "number") return v + ""; // cast to string;
-    throw makeRuntimeErrorMsg(funcName, `'${argName}' should be a string.`);
-  };
-  const helperNumber = (funcName: string, argName: string, v: unknown): number => {
-    if (typeof v === "string") {
-      const x = parseFloat(v);
-      if (!isNaN(x)) return x; // otherwise it wasn't even a string representing a number.
-    } else if (typeof v === "number") {
-      if (isNaN(v)) throw makeRuntimeErrorMsg(funcName, `'${argName}' is NaN.`);
-      return v;
-    }
-    throw makeRuntimeErrorMsg(funcName, `'${argName}' should be a number.`);
-  };
-
-  const isScriptArgs = (_args: unknown): _args is ScriptArg[] =>
-    Array.isArray(_args) &&
-    _args.every((a) => typeof a === "string" || typeof a === "number" || typeof a === "boolean");
-
-  const helperScriptArgs = (funcName: string, args: unknown): ScriptArg[] => {
-    if (!isScriptArgs(args)) throw makeRuntimeErrorMsg(funcName, "'args' is not an array of script args");
-    return args as ScriptArg[];
-  };
-
-  const helper: INetscriptHelper = {
-    updateDynamicRam: updateDynamicRam,
-    makeRuntimeErrorMsg: makeRuntimeErrorMsg,
-    string: helperString,
-    number: helperNumber,
-    ustring: (funcName: string, argName: string, v: unknown): string | undefined => {
-      if (v === undefined) return undefined;
-      return helperString(funcName, argName, v);
+      return calculatePercentMoneyHacked(server, Player);
     },
-    unumber: (funcName: string, argName: string, v: unknown): number | undefined => {
-      if (v === undefined) return undefined;
-      return helperNumber(funcName, argName, v);
-    },
-    scriptArgs: helperScriptArgs,
-    scriptIdentifier: (funcName: string, _fn: unknown, _hostname: unknown, _args: unknown): ScriptIdentifier => {
-      if (_fn === undefined) return workerScript.pid;
-      if (typeof _fn === "number") return _fn;
-      if (typeof _fn === "string") {
-        const hostname = _hostname != undefined ? helperString(funcName, "hostname", _hostname) : workerScript.hostname;
-        if (!isScriptArgs(_args)) throw makeRuntimeErrorMsg(funcName, "'args' is not an array of script args");
-        return {
-          fn: _fn,
-          hostname: hostname,
-          args: _args,
-        };
-      }
-      throw new Error("not implemented");
-    },
-    boolean: (v: unknown): boolean => {
-      return !!v; // Just convert it to boolean.
-    },
-    city: (funcName: string, argName: string, v: unknown): CityName => {
-      if (typeof v !== "string") throw makeRuntimeErrorMsg(funcName, `${argName} should be a city name.`);
-      const s = v as CityName;
-      if (!Object.values(CityName).includes(s))
-        throw makeRuntimeErrorMsg(funcName, `${argName} should be a city name.`);
-      return s;
-    },
-    getServer: safeGetServer,
-    checkSingularityAccess: checkSingularityAccess,
-    hack: hack,
-    getValidPort: (funcName: string, port: number): IPort => {
-      if (isNaN(port)) {
-        throw makeRuntimeErrorMsg(
-          funcName,
-          `Invalid argument. Must be a port number between 1 and ${CONSTANTS.NumNetscriptPorts}, is ${port}`,
-        );
-      }
-      port = Math.round(port);
-      if (port < 1 || port > CONSTANTS.NumNetscriptPorts) {
-        throw makeRuntimeErrorMsg(
-          funcName,
-          `Trying to use an invalid port: ${port}. Only ports 1-${CONSTANTS.NumNetscriptPorts} are valid.`,
-        );
-      }
-      const iport = NetscriptPorts[port - 1];
-      if (iport == null || !(iport instanceof Object)) {
-        throw makeRuntimeErrorMsg(funcName, `Could not find port: ${port}. This is a bug. Report to dev.`);
-      }
-      return iport;
-    },
-    player(funcName: string, p: unknown): IPlayer {
-      const fakePlayer = {
-        hp: undefined,
-        mults: undefined,
-        numPeopleKilled: undefined,
-        money: undefined,
-        city: undefined,
-        location: undefined,
-        bitNodeN: undefined,
-        totalPlaytime: undefined,
-        playtimeSinceLastAug: undefined,
-        playtimeSinceLastBitnode: undefined,
-        jobs: undefined,
-        factions: undefined,
-        tor: undefined,
-        inBladeburner: undefined,
-        hasCorporation: undefined,
-        entropy: undefined,
-      };
-      if (!roughlyIs(fakePlayer, p)) throw makeRuntimeErrorMsg(funcName, `player should be a Player.`);
-      return p as IPlayer;
-    },
-    server(funcName: string, s: unknown): Server {
-      if (!roughlyIs(new Server(), s)) throw makeRuntimeErrorMsg(funcName, `server should be a Server.`);
-      return s as Server;
-    },
-    gang(funcName: string, g: unknown): FormulaGang {
-      if (!roughlyIs({ respect: 0, territory: 0, wantedLevel: 0 }, g))
-        throw makeRuntimeErrorMsg(funcName, `gang should be a Gang.`);
-      return g as FormulaGang;
-    },
-    gangMember(funcName: string, m: unknown): GangMember {
-      if (!roughlyIs(new GangMember(), m)) throw makeRuntimeErrorMsg(funcName, `member should be a GangMember.`);
-      return m as GangMember;
-    },
-    gangTask(funcName: string, t: unknown): GangMemberTask {
-      if (!roughlyIs(new GangMemberTask("", "", false, false, {}), t))
-        throw makeRuntimeErrorMsg(funcName, `task should be a GangMemberTask.`);
-      return t as GangMemberTask;
-    },
-  };
-
-  const singularity = NetscriptSingularity(Player, workerScript);
-  const base: InternalAPI<INS> = {
-    args: workerScript.args as unknown as any,
-    enums: {
-      toast: ToastVariant,
-    } as unknown as any,
-
-    singularity: singularity,
-    gang: NetscriptGang(Player, workerScript),
-    bladeburner: NetscriptBladeburner(Player, workerScript),
-    codingcontract: NetscriptCodingContract(Player, workerScript),
-    sleeve: NetscriptSleeve(Player),
-    corporation: NetscriptCorporation(Player),
-    stanek: NetscriptStanek(Player, workerScript, helper),
-    infiltration: NetscriptInfiltration(Player),
-    ui: NetscriptUserInterface(),
-    formulas: NetscriptFormulas(Player, helper),
-    stock: NetscriptStockMarket(Player, workerScript),
-    grafting: NetscriptGrafting(Player),
-    hacknet: NetscriptHacknet(Player, workerScript),
-    sprintf: () => sprintf,
-    vsprintf: () => vsprintf,
-    scan:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname): string[] => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        const out = [];
-        for (let i = 0; i < server.serversOnNetwork.length; i++) {
-          const s = getServerOnNetwork(server, i);
-          if (s === null) continue;
-          const entry = s.hostname;
-          if (entry === null) continue;
-          out.push(entry);
-        }
-        ctx.log(() => `returned ${server.serversOnNetwork.length} connections for ${server.hostname}`);
-        return out;
-      },
-    hack:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        return hack(ctx, hostname, false, { threads: requestedThreads, stock: stock });
-      },
-    hackAnalyzeThreads:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown, _hackAmount: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const hackAmount = ctx.helper.number("hackAmount", _hackAmount);
-
-        // Check argument validity
-        const server = safeGetServer(hostname, ctx);
+  hackAnalyzeSecurity:
+    (ctx: NetscriptContext) =>
+    (_threads: unknown, _hostname?: unknown): number => {
+      let threads = helpers.number(ctx, "threads", _threads);
+      if (_hostname) {
+        const hostname = helpers.string(ctx, "hostname", _hostname);
+        const server = helpers.getServer(ctx, hostname);
         if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return -1;
-        }
-        if (isNaN(hackAmount)) {
-          throw ctx.makeRuntimeErrorMsg(
-            `Invalid hackAmount argument passed into hackAnalyzeThreads: ${hackAmount}. Must be numeric.`,
-          );
-        }
-
-        if (hackAmount < 0 || hackAmount > server.moneyAvailable) {
-          return -1;
-        } else if (hackAmount === 0) {
+          helpers.log(ctx, () => "Cannot be executed on this server.");
           return 0;
         }
 
         const percentHacked = calculatePercentMoneyHacked(server, Player);
 
-        if (percentHacked === 0 || server.moneyAvailable === 0) {
-          return 0; // To prevent returning infinity below
+        if (percentHacked > 0) {
+          // thread count is limited to the maximum number of threads needed
+          threads = Math.min(threads, Math.ceil(1 / percentHacked));
         }
+      }
 
-        return hackAmount / Math.floor(server.moneyAvailable * percentHacked);
-      },
-    hackAnalyze:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
+      return CONSTANTS.ServerFortifyAmount * threads;
+    },
+  hackAnalyzeChance:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
 
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 0;
-        }
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 0;
+      }
 
-        return calculatePercentMoneyHacked(server, Player);
-      },
-    hackAnalyzeSecurity:
-      (ctx: NetscriptContext) =>
-      (_threads: unknown, _hostname?: unknown): number => {
-        let threads = ctx.helper.number("threads", _threads);
-        if (_hostname) {
-          const hostname = ctx.helper.string("hostname", _hostname);
-          const server = safeGetServer(hostname, ctx);
-          if (!(server instanceof Server)) {
-            ctx.log(() => "Cannot be executed on this server.");
-            return 0;
-          }
-
-          const percentHacked = calculatePercentMoneyHacked(server, Player);
-
-          if (percentHacked > 0) {
-            // thread count is limited to the maximum number of threads needed
-            threads = Math.min(threads, Math.ceil(1 / percentHacked));
-          }
-        }
-
-        return CONSTANTS.ServerFortifyAmount * threads;
-      },
-    hackAnalyzeChance:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 0;
-        }
-
-        return calculateHackingChance(server, Player);
-      },
-    sleep:
-      (ctx: NetscriptContext) =>
-      async (_time: unknown = 0): Promise<true> => {
-        const time = ctx.helper.number("time", _time);
-        if (time === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Takes 1 argument.");
-        }
-        ctx.log(() => `Sleeping for ${time} milliseconds`);
-        return netscriptDelay(time, workerScript).then(function () {
-          return Promise.resolve(true);
-        });
-      },
-    asleep: (ctx: NetscriptContext) =>
-      function (_time: unknown = 0): Promise<true> {
-        const time = ctx.helper.number("time", _time);
-        ctx.log(() => `Sleeping for ${time} milliseconds`);
-        return new Promise((resolve) => setTimeout(() => resolve(true), time));
-      },
-    grow:
-      (ctx: NetscriptContext) =>
-      async (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const threads = resolveNetscriptRequestedThreads(ctx, requestedThreads ?? workerScript.scriptRef.threads);
-
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return Promise.resolve(0);
-        }
-
-        const host = GetServer(workerScript.hostname);
-        if (host === null) {
-          throw new Error("Workerscript host is null");
-        }
-
-        // No root access or skill level too low
-        const canHack = netscriptCanGrow(server);
-        if (!canHack.res) {
-          throw ctx.makeRuntimeErrorMsg(canHack.msg || "");
-        }
-
-        const growTime = calculateGrowTime(server, Player);
-        ctx.log(
-          () =>
-            `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
-              growTime * 1000,
-              true,
-            )} (t=${numeralWrapper.formatThreads(threads)}).`,
-        );
-        return netscriptDelay(growTime * 1000, workerScript).then(function () {
-          const moneyBefore = server.moneyAvailable <= 0 ? 1 : server.moneyAvailable;
-          processSingleServerGrowth(server, threads, Player, host.cpuCores);
-          const moneyAfter = server.moneyAvailable;
-          workerScript.scriptRef.recordGrow(server.hostname, threads);
-          const expGain = calculateHackingExpGain(server, Player) * threads;
-          const logGrowPercent = moneyAfter / moneyBefore - 1;
-          ctx.log(
-            () =>
-              `Available money on '${server.hostname}' grown by ${numeralWrapper.formatPercentage(
-                logGrowPercent,
-                6,
-              )}. Gained ${numeralWrapper.formatExp(expGain)} hacking exp (t=${numeralWrapper.formatThreads(
-                threads,
-              )}).`,
-          );
-          workerScript.scriptRef.onlineExpGained += expGain;
-          Player.gainHackingExp(expGain);
-          if (stock) {
-            influenceStockThroughServerGrow(server, moneyAfter - moneyBefore);
-          }
-          return Promise.resolve(moneyAfter / moneyBefore);
-        });
-      },
-    growthAnalyze:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown, _growth: unknown, _cores: unknown = 1): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const growth = ctx.helper.number("growth", _growth);
-        const cores = ctx.helper.number("cores", _cores);
-
-        // Check argument validity
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 0;
-        }
-        if (typeof growth !== "number" || isNaN(growth) || growth < 1 || !isFinite(growth)) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: growth must be numeric and >= 1, is ${growth}.`);
-        }
-
-        return numCycleForGrowth(server, Number(growth), Player, cores);
-      },
-    growthAnalyzeSecurity:
-      (ctx: NetscriptContext) =>
-      (_threads: unknown, _hostname?: unknown, _cores?: unknown): number => {
-        let threads = ctx.helper.number("threads", _threads);
-        if (_hostname) {
-          const cores = ctx.helper.number("cores", _cores) || 1;
-          const hostname = ctx.helper.string("hostname", _hostname);
-          const server = safeGetServer(hostname, ctx);
-
-          if (!(server instanceof Server)) {
-            ctx.log(() => "Cannot be executed on this server.");
-            return 0;
-          }
-
-          const maxThreadsNeeded = Math.ceil(
-            numCycleForGrowthCorrected(server, server.moneyMax, server.moneyAvailable, Player, cores),
-          );
-
-          threads = Math.min(threads, maxThreadsNeeded);
-        }
-
-        return 2 * CONSTANTS.ServerFortifyAmount * threads;
-      },
-    weaken:
-      (ctx: NetscriptContext) =>
-      async (_hostname: unknown, { threads: requestedThreads }: BasicHGWOptions = {}): Promise<number> => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const threads = resolveNetscriptRequestedThreads(ctx, requestedThreads ?? workerScript.scriptRef.threads);
-        if (hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Takes 1 argument.");
-        }
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return Promise.resolve(0);
-        }
-
-        // No root access or skill level too low
-        const canHack = netscriptCanWeaken(server);
-        if (!canHack.res) {
-          throw ctx.makeRuntimeErrorMsg(canHack.msg || "");
-        }
-
-        const weakenTime = calculateWeakenTime(server, Player);
-        ctx.log(
-          () =>
-            `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
-              weakenTime * 1000,
-              true,
-            )} (t=${numeralWrapper.formatThreads(threads)})`,
-        );
-        return netscriptDelay(weakenTime * 1000, workerScript).then(function () {
-          const host = GetServer(workerScript.hostname);
-          if (host === null) {
-            ctx.log(() => "Server is null, did it die?");
-            return Promise.resolve(0);
-          }
-          const coreBonus = 1 + (host.cpuCores - 1) / 16;
-          server.weaken(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
-          workerScript.scriptRef.recordWeaken(server.hostname, threads);
-          const expGain = calculateHackingExpGain(server, Player) * threads;
-          ctx.log(
-            () =>
-              `'${server.hostname}' security level weakened to ${
-                server.hackDifficulty
-              }. Gained ${numeralWrapper.formatExp(expGain)} hacking exp (t=${numeralWrapper.formatThreads(threads)})`,
-          );
-          workerScript.scriptRef.onlineExpGained += expGain;
-          Player.gainHackingExp(expGain);
-          return Promise.resolve(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
-        });
-      },
-    weakenAnalyze:
-      (ctx: NetscriptContext) =>
-      (_threads: unknown, _cores: unknown = 1): number => {
-        const threads = ctx.helper.number("threads", _threads);
-        const cores = ctx.helper.number("cores", _cores);
-        const coreBonus = 1 + (cores - 1) / 16;
-        return CONSTANTS.ServerWeakenAmount * threads * coreBonus * BitNodeMultipliers.ServerWeakenRate;
-      },
-    share: (ctx: NetscriptContext) => async (): Promise<void> => {
-      ctx.log(() => "Sharing this computer.");
-      const end = StartSharing(
-        workerScript.scriptRef.threads * calculateIntelligenceBonus(Player.skills.intelligence, 2),
-      );
-      return netscriptDelay(10000, workerScript).finally(function () {
-        ctx.log(() => "Finished sharing this computer.");
-        end();
+      return calculateHackingChance(server, Player);
+    },
+  sleep:
+    (ctx: NetscriptContext) =>
+    async (_time: unknown = 0): Promise<true> => {
+      const time = helpers.number(ctx, "time", _time);
+      if (time === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
+      }
+      helpers.log(ctx, () => `Sleeping for ${time} milliseconds`);
+      return helpers.netscriptDelay(ctx, time).then(function () {
+        return Promise.resolve(true);
       });
     },
-    getSharePower: () => (): number => {
-      return CalculateShareMult();
+  asleep: (ctx: NetscriptContext) =>
+    function (_time: unknown = 0): Promise<true> {
+      const time = helpers.number(ctx, "time", _time);
+      helpers.log(ctx, () => `Sleeping for ${time} milliseconds`);
+      return new Promise((resolve) => setTimeout(() => resolve(true), time));
     },
-    print:
-      (ctx: NetscriptContext) =>
-      (...args: unknown[]): void => {
-        if (args.length === 0) {
-          throw ctx.makeRuntimeErrorMsg("Takes at least 1 argument.");
-        }
-        workerScript.print(argsToString(args));
-      },
-    printf:
-      (ctx: NetscriptContext) =>
-      (_format: unknown, ...args: unknown[]): void => {
-        const format = ctx.helper.string("format", _format);
-        if (typeof format !== "string") {
-          throw ctx.makeRuntimeErrorMsg("First argument must be string for the format.");
-        }
-        workerScript.print(vsprintf(format, args));
-      },
-    tprint:
-      (ctx: NetscriptContext) =>
-      (...args: unknown[]): void => {
-        if (args.length === 0) {
-          throw ctx.makeRuntimeErrorMsg("Takes at least 1 argument.");
-        }
-        const str = argsToString(args);
-        if (str.startsWith("ERROR") || str.startsWith("FAIL")) {
-          Terminal.error(`${workerScript.scriptRef.filename}: ${str}`);
-          return;
-        }
-        if (str.startsWith("SUCCESS")) {
-          Terminal.success(`${workerScript.scriptRef.filename}: ${str}`);
-          return;
-        }
-        if (str.startsWith("WARN")) {
-          Terminal.warn(`${workerScript.scriptRef.filename}: ${str}`);
-          return;
-        }
-        if (str.startsWith("INFO")) {
-          Terminal.info(`${workerScript.scriptRef.filename}: ${str}`);
-          return;
-        }
-        Terminal.print(`${workerScript.scriptRef.filename}: ${str}`);
-      },
-    tprintf:
-      (ctx: NetscriptContext) =>
-      (_format: unknown, ...args: unknown[]): void => {
-        const format = ctx.helper.string("format", _format);
-        const str = vsprintf(format, args);
+  grow:
+    (ctx: NetscriptContext) =>
+    async (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const threads = helpers.resolveNetscriptRequestedThreads(
+        ctx,
+        requestedThreads ?? ctx.workerScript.scriptRef.threads,
+      );
 
-        if (str.startsWith("ERROR") || str.startsWith("FAIL")) {
-          Terminal.error(`${str}`);
-          return;
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return Promise.resolve(0);
+      }
+
+      const host = GetServer(ctx.workerScript.hostname);
+      if (host === null) {
+        throw new Error("Workerscript host is null");
+      }
+
+      // No root access or skill level too low
+      const canHack = netscriptCanGrow(server);
+      if (!canHack.res) {
+        throw helpers.makeRuntimeErrorMsg(ctx, canHack.msg || "");
+      }
+
+      const growTime = calculateGrowTime(server, Player);
+      helpers.log(
+        ctx,
+        () =>
+          `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
+            growTime * 1000,
+            true,
+          )} (t=${numeralWrapper.formatThreads(threads)}).`,
+      );
+      return helpers.netscriptDelay(ctx, growTime * 1000).then(function () {
+        const moneyBefore = server.moneyAvailable <= 0 ? 1 : server.moneyAvailable;
+        processSingleServerGrowth(server, threads, Player, host.cpuCores);
+        const moneyAfter = server.moneyAvailable;
+        ctx.workerScript.scriptRef.recordGrow(server.hostname, threads);
+        const expGain = calculateHackingExpGain(server, Player) * threads;
+        const logGrowPercent = moneyAfter / moneyBefore - 1;
+        helpers.log(
+          ctx,
+          () =>
+            `Available money on '${server.hostname}' grown by ${numeralWrapper.formatPercentage(
+              logGrowPercent,
+              6,
+            )}. Gained ${numeralWrapper.formatExp(expGain)} hacking exp (t=${numeralWrapper.formatThreads(threads)}).`,
+        );
+        ctx.workerScript.scriptRef.onlineExpGained += expGain;
+        Player.gainHackingExp(expGain);
+        if (stock) {
+          influenceStockThroughServerGrow(server, moneyAfter - moneyBefore);
         }
-        if (str.startsWith("SUCCESS")) {
-          Terminal.success(`${str}`);
-          return;
-        }
-        if (str.startsWith("WARN")) {
-          Terminal.warn(`${str}`);
-          return;
-        }
-        if (str.startsWith("INFO")) {
-          Terminal.info(`${str}`);
-          return;
-        }
-        Terminal.print(`${str}`);
-      },
-    clearLog: () => (): void => {
-      workerScript.scriptRef.clearLog();
+        return Promise.resolve(moneyAfter / moneyBefore);
+      });
     },
-    disableLog:
-      (ctx: NetscriptContext) =>
-      (_fn: unknown): void => {
-        const fn = ctx.helper.string("fn", _fn);
-        if (fn === "ALL") {
-          for (const fn of Object.keys(possibleLogs)) {
-            workerScript.disableLogs[fn] = true;
-          }
-          ctx.log(() => `Disabled logging for all functions`);
-        } else if (possibleLogs[fn] === undefined) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${fn}.`);
-        } else {
-          workerScript.disableLogs[fn] = true;
-          ctx.log(() => `Disabled logging for ${fn}`);
-        }
-      },
-    enableLog:
-      (ctx: NetscriptContext) =>
-      (_fn: unknown): void => {
-        const fn = ctx.helper.string("fn", _fn);
-        if (fn === "ALL") {
-          for (const fn of Object.keys(possibleLogs)) {
-            delete workerScript.disableLogs[fn];
-          }
-          ctx.log(() => `Enabled logging for all functions`);
-        } else if (possibleLogs[fn] === undefined) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${fn}.`);
-        }
-        delete workerScript.disableLogs[fn];
-        ctx.log(() => `Enabled logging for ${fn}`);
-      },
-    isLogEnabled:
-      (ctx: NetscriptContext) =>
-      (_fn: unknown): boolean => {
-        const fn = ctx.helper.string("fn", _fn);
-        if (possibleLogs[fn] === undefined) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${fn}.`);
-        }
-        return !workerScript.disableLogs[fn];
-      },
-    getScriptLogs:
-      (ctx: NetscriptContext) =>
-      (fn: unknown, hostname: unknown, ...scriptArgs: unknown[]): string[] => {
-        const ident = ctx.helper.scriptIdentifier(fn, hostname, scriptArgs);
-        const runningScriptObj = getRunningScript(ctx, ident);
-        if (runningScriptObj == null) {
-          ctx.log(() => getCannotFindRunningScriptErrorMessage(ident));
-          return [];
-        }
+  growthAnalyze:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown, _growth: unknown, _cores: unknown = 1): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const growth = helpers.number(ctx, "growth", _growth);
+      const cores = helpers.number(ctx, "cores", _cores);
 
-        return runningScriptObj.logs.slice();
-      },
-    tail:
-      (ctx: NetscriptContext) =>
-      (fn: unknown, hostname: unknown, ...scriptArgs: unknown[]): void => {
-        const ident = ctx.helper.scriptIdentifier(fn, hostname, scriptArgs);
-        const runningScriptObj = getRunningScript(ctx, ident);
-        if (runningScriptObj == null) {
-          ctx.log(() => getCannotFindRunningScriptErrorMessage(ident));
-          return;
-        }
+      // Check argument validity
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 0;
+      }
+      if (typeof growth !== "number" || isNaN(growth) || growth < 1 || !isFinite(growth)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: growth must be numeric and >= 1, is ${growth}.`);
+      }
 
-        LogBoxEvents.emit(runningScriptObj);
-      },
+      return numCycleForGrowth(server, Number(growth), Player, cores);
+    },
+  growthAnalyzeSecurity:
+    (ctx: NetscriptContext) =>
+    (_threads: unknown, _hostname?: unknown, _cores?: unknown): number => {
+      let threads = helpers.number(ctx, "threads", _threads);
+      if (_hostname) {
+        const cores = helpers.number(ctx, "cores", _cores) || 1;
+        const hostname = helpers.string(ctx, "hostname", _hostname);
+        const server = helpers.getServer(ctx, hostname);
 
-    closeTail:
-      (ctx: NetscriptContext) =>
-      (_pid: unknown = workerScript.scriptRef.pid): void => {
-        const pid = ctx.helper.number("pid", _pid);
-        //Emit an event to tell the game to close the tail window if it exists
-        LogBoxCloserEvents.emit(pid);
-      },
-    nuke:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-
-        const server = safeGetServer(hostname, ctx);
         if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return false;
-        }
-        if (server.hasAdminRights) {
-          ctx.log(() => `Already have root access to '${server.hostname}'.`);
-          return true;
-        }
-        if (!Player.hasProgram(Programs.NukeProgram.name)) {
-          throw ctx.makeRuntimeErrorMsg("You do not have the NUKE.exe virus!");
-        }
-        if (server.openPortCount < server.numOpenPortsRequired) {
-          throw ctx.makeRuntimeErrorMsg("Not enough ports opened to use NUKE.exe virus.");
-        }
-        server.hasAdminRights = true;
-        ctx.log(() => `Executed NUKE.exe virus on '${server.hostname}' to gain root access.`);
-        return true;
-      },
-    brutessh:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return false;
-        }
-        if (!Player.hasProgram(Programs.BruteSSHProgram.name)) {
-          throw ctx.makeRuntimeErrorMsg("You do not have the BruteSSH.exe program!");
-        }
-        if (!server.sshPortOpen) {
-          ctx.log(() => `Executed BruteSSH.exe on '${server.hostname}' to open SSH port (22).`);
-          server.sshPortOpen = true;
-          ++server.openPortCount;
-        } else {
-          ctx.log(() => `SSH Port (22) already opened on '${server.hostname}'.`);
-        }
-        return true;
-      },
-    ftpcrack:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        if (hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Takes 1 argument.");
-        }
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return false;
-        }
-        if (!Player.hasProgram(Programs.FTPCrackProgram.name)) {
-          throw ctx.makeRuntimeErrorMsg("You do not have the FTPCrack.exe program!");
-        }
-        if (!server.ftpPortOpen) {
-          ctx.log(() => `Executed FTPCrack.exe on '${server.hostname}' to open FTP port (21).`);
-          server.ftpPortOpen = true;
-          ++server.openPortCount;
-        } else {
-          ctx.log(() => `FTP Port (21) already opened on '${server.hostname}'.`);
-        }
-        return true;
-      },
-    relaysmtp:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        if (hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Takes 1 argument.");
-        }
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return false;
-        }
-        if (!Player.hasProgram(Programs.RelaySMTPProgram.name)) {
-          throw ctx.makeRuntimeErrorMsg("You do not have the relaySMTP.exe program!");
-        }
-        if (!server.smtpPortOpen) {
-          ctx.log(() => `Executed relaySMTP.exe on '${server.hostname}' to open SMTP port (25).`);
-          server.smtpPortOpen = true;
-          ++server.openPortCount;
-        } else {
-          ctx.log(() => `SMTP Port (25) already opened on '${server.hostname}'.`);
-        }
-        return true;
-      },
-    httpworm:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        if (hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Takes 1 argument");
-        }
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return false;
-        }
-        if (!Player.hasProgram(Programs.HTTPWormProgram.name)) {
-          throw ctx.makeRuntimeErrorMsg("You do not have the HTTPWorm.exe program!");
-        }
-        if (!server.httpPortOpen) {
-          ctx.log(() => `Executed HTTPWorm.exe on '${server.hostname}' to open HTTP port (80).`);
-          server.httpPortOpen = true;
-          ++server.openPortCount;
-        } else {
-          ctx.log(() => `HTTP Port (80) already opened on '${server.hostname}'.`);
-        }
-        return true;
-      },
-    sqlinject:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        if (hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Takes 1 argument.");
-        }
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return false;
-        }
-        if (!Player.hasProgram(Programs.SQLInjectProgram.name)) {
-          throw ctx.makeRuntimeErrorMsg("You do not have the SQLInject.exe program!");
-        }
-        if (!server.sqlPortOpen) {
-          ctx.log(() => `Executed SQLInject.exe on '${server.hostname}' to open SQL port (1433).`);
-          server.sqlPortOpen = true;
-          ++server.openPortCount;
-        } else {
-          ctx.log(() => `SQL Port (1433) already opened on '${server.hostname}'.`);
-        }
-        return true;
-      },
-    run:
-      (ctx: NetscriptContext) =>
-      (_scriptname: unknown, _threads: unknown = 1, ..._args: unknown[]): number => {
-        const scriptname = ctx.helper.string("scriptname", _scriptname);
-        const threads = ctx.helper.number("threads", _threads);
-        const args = ctx.helper.scriptArgs(_args);
-        if (scriptname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Usage: run(scriptname, [numThreads], [arg1], [arg2]...)");
-        }
-        if (isNaN(threads) || threads <= 0) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid thread count. Must be numeric and > 0, is ${threads}`);
-        }
-        const scriptServer = GetServer(workerScript.hostname);
-        if (scriptServer == null) {
-          throw ctx.makeRuntimeErrorMsg("Could not find server. This is a bug. Report to dev.");
+          helpers.log(ctx, () => "Cannot be executed on this server.");
+          return 0;
         }
 
-        return runScriptFromScript(Player, "run", scriptServer, scriptname, args, workerScript, threads);
-      },
-    exec:
-      (ctx: NetscriptContext) =>
-      (_scriptname: unknown, _hostname: unknown, _threads: unknown = 1, ..._args: unknown[]): number => {
-        const scriptname = ctx.helper.string("scriptname", _scriptname);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const threads = ctx.helper.number("threads", _threads);
-        const args = ctx.helper.scriptArgs(_args);
-        if (scriptname === undefined || hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Usage: exec(scriptname, server, [numThreads], [arg1], [arg2]...)");
+        const maxThreadsNeeded = Math.ceil(
+          numCycleForGrowthCorrected(server, server.moneyMax, server.moneyAvailable, Player, cores),
+        );
+
+        threads = Math.min(threads, maxThreadsNeeded);
+      }
+
+      return 2 * CONSTANTS.ServerFortifyAmount * threads;
+    },
+  weaken:
+    (ctx: NetscriptContext) =>
+    async (_hostname: unknown, { threads: requestedThreads }: BasicHGWOptions = {}): Promise<number> => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const threads = helpers.resolveNetscriptRequestedThreads(
+        ctx,
+        requestedThreads ?? ctx.workerScript.scriptRef.threads,
+      );
+      if (hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
+      }
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return Promise.resolve(0);
+      }
+
+      // No root access or skill level too low
+      const canHack = netscriptCanWeaken(server);
+      if (!canHack.res) {
+        throw helpers.makeRuntimeErrorMsg(ctx, canHack.msg || "");
+      }
+
+      const weakenTime = calculateWeakenTime(server, Player);
+      helpers.log(
+        ctx,
+        () =>
+          `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
+            weakenTime * 1000,
+            true,
+          )} (t=${numeralWrapper.formatThreads(threads)})`,
+      );
+      return helpers.netscriptDelay(ctx, weakenTime * 1000).then(function () {
+        const host = GetServer(ctx.workerScript.hostname);
+        if (host === null) {
+          helpers.log(ctx, () => "Server is null, did it die?");
+          return Promise.resolve(0);
         }
-        if (isNaN(threads) || threads <= 0) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid thread count. Must be numeric and > 0, is ${threads}`);
+        const coreBonus = 1 + (host.cpuCores - 1) / 16;
+        server.weaken(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
+        ctx.workerScript.scriptRef.recordWeaken(server.hostname, threads);
+        const expGain = calculateHackingExpGain(server, Player) * threads;
+        helpers.log(
+          ctx,
+          () =>
+            `'${server.hostname}' security level weakened to ${
+              server.hackDifficulty
+            }. Gained ${numeralWrapper.formatExp(expGain)} hacking exp (t=${numeralWrapper.formatThreads(threads)})`,
+        );
+        ctx.workerScript.scriptRef.onlineExpGained += expGain;
+        Player.gainHackingExp(expGain);
+        return Promise.resolve(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
+      });
+    },
+  weakenAnalyze:
+    (ctx: NetscriptContext) =>
+    (_threads: unknown, _cores: unknown = 1): number => {
+      const threads = helpers.number(ctx, "threads", _threads);
+      const cores = helpers.number(ctx, "cores", _cores);
+      const coreBonus = 1 + (cores - 1) / 16;
+      return CONSTANTS.ServerWeakenAmount * threads * coreBonus * BitNodeMultipliers.ServerWeakenRate;
+    },
+  share: (ctx: NetscriptContext) => async (): Promise<void> => {
+    helpers.log(ctx, () => "Sharing this computer.");
+    const end = StartSharing(
+      ctx.workerScript.scriptRef.threads * calculateIntelligenceBonus(Player.skills.intelligence, 2),
+    );
+    return helpers.netscriptDelay(ctx, 10000).finally(function () {
+      helpers.log(ctx, () => "Finished sharing this computer.");
+      end();
+    });
+  },
+  getSharePower: () => (): number => {
+    return CalculateShareMult();
+  },
+  print:
+    (ctx: NetscriptContext) =>
+    (...args: unknown[]): void => {
+      if (args.length === 0) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes at least 1 argument.");
+      }
+      ctx.workerScript.print(helpers.argsToString(args));
+    },
+  printf:
+    (ctx: NetscriptContext) =>
+    (_format: unknown, ...args: unknown[]): void => {
+      const format = helpers.string(ctx, "format", _format);
+      if (typeof format !== "string") {
+        throw helpers.makeRuntimeErrorMsg(ctx, "First argument must be string for the format.");
+      }
+      ctx.workerScript.print(vsprintf(format, args));
+    },
+  tprint:
+    (ctx: NetscriptContext) =>
+    (...args: unknown[]): void => {
+      if (args.length === 0) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes at least 1 argument.");
+      }
+      const str = helpers.argsToString(args);
+      if (str.startsWith("ERROR") || str.startsWith("FAIL")) {
+        Terminal.error(`${ctx.workerScript.scriptRef.filename}: ${str}`);
+        return;
+      }
+      if (str.startsWith("SUCCESS")) {
+        Terminal.success(`${ctx.workerScript.scriptRef.filename}: ${str}`);
+        return;
+      }
+      if (str.startsWith("WARN")) {
+        Terminal.warn(`${ctx.workerScript.scriptRef.filename}: ${str}`);
+        return;
+      }
+      if (str.startsWith("INFO")) {
+        Terminal.info(`${ctx.workerScript.scriptRef.filename}: ${str}`);
+        return;
+      }
+      Terminal.print(`${ctx.workerScript.scriptRef.filename}: ${str}`);
+    },
+  tprintf:
+    (ctx: NetscriptContext) =>
+    (_format: unknown, ...args: unknown[]): void => {
+      const format = helpers.string(ctx, "format", _format);
+      const str = vsprintf(format, args);
+
+      if (str.startsWith("ERROR") || str.startsWith("FAIL")) {
+        Terminal.error(`${str}`);
+        return;
+      }
+      if (str.startsWith("SUCCESS")) {
+        Terminal.success(`${str}`);
+        return;
+      }
+      if (str.startsWith("WARN")) {
+        Terminal.warn(`${str}`);
+        return;
+      }
+      if (str.startsWith("INFO")) {
+        Terminal.info(`${str}`);
+        return;
+      }
+      Terminal.print(`${str}`);
+    },
+  clearLog: (ctx: NetscriptContext) => (): void => {
+    ctx.workerScript.scriptRef.clearLog();
+  },
+  disableLog:
+    (ctx: NetscriptContext) =>
+    (_fn: unknown): void => {
+      const fn = helpers.string(ctx, "fn", _fn);
+      if (fn === "ALL") {
+        for (const fn of Object.keys(possibleLogs)) {
+          ctx.workerScript.disableLogs[fn] = true;
         }
-        const server = safeGetServer(hostname, ctx);
-        return runScriptFromScript(Player, "exec", server, scriptname, args, workerScript, threads);
-      },
-    spawn:
-      (ctx: NetscriptContext) =>
-      (_scriptname: unknown, _threads: unknown = 1, ..._args: unknown[]): void => {
-        const scriptname = ctx.helper.string("scriptname", _scriptname);
-        const threads = ctx.helper.number("threads", _threads);
-        const args = ctx.helper.scriptArgs(_args);
-        if (!scriptname || !threads) {
-          throw ctx.makeRuntimeErrorMsg("Usage: spawn(scriptname, threads)");
-        }
-
-        const spawnDelay = 10;
-        setTimeout(() => {
-          if (isNaN(threads) || threads <= 0) {
-            throw ctx.makeRuntimeErrorMsg(`Invalid thread count. Must be numeric and > 0, is ${threads}`);
-          }
-          const scriptServer = GetServer(workerScript.hostname);
-          if (scriptServer == null) {
-            throw ctx.makeRuntimeErrorMsg("Could not find server. This is a bug. Report to dev");
-          }
-
-          return runScriptFromScript(Player, "spawn", scriptServer, scriptname, args, workerScript, threads);
-        }, spawnDelay * 1e3);
-
-        ctx.log(() => `Will execute '${scriptname}' in ${spawnDelay} seconds`);
-
-        workerScript.running = false; // Prevent workerScript from "finishing execution naturally"
-        if (killWorkerScript(workerScript)) {
-          ctx.log(() => "Exiting...");
-        }
-      },
-    kill:
-      (ctx: NetscriptContext) =>
-      (filename: unknown, hostname: unknown, ...scriptArgs: unknown[]): boolean => {
-        const ident = ctx.helper.scriptIdentifier(filename, hostname, scriptArgs);
-        let res;
-        const killByPid = typeof ident === "number";
-        if (killByPid) {
-          // Kill by pid
-          res = killWorkerScript(ident);
-        } else {
-          // Kill by filename/hostname
-          if (filename === undefined || hostname === undefined) {
-            throw ctx.makeRuntimeErrorMsg("Usage: kill(scriptname, server, [arg1], [arg2]...)");
-          }
-
-          const server = safeGetServer(ident.hostname, ctx);
-          const runningScriptObj = getRunningScriptByArgs(ctx, ident.fn, ident.hostname, ident.args);
-          if (runningScriptObj == null) {
-            ctx.log(() => getCannotFindRunningScriptErrorMessage(ident));
-            return false;
-          }
-
-          res = killWorkerScript({ runningScript: runningScriptObj, hostname: server.hostname });
-        }
-
-        if (res) {
-          if (killByPid) {
-            ctx.log(() => `Killing script with PID ${ident}`);
-          } else {
-            ctx.log(() => `Killing '${filename}' on '${hostname}' with args: ${arrayToString(scriptArgs)}.`);
-          }
-          return true;
-        } else {
-          if (killByPid) {
-            ctx.log(() => `No script with PID ${ident}`);
-          } else {
-            ctx.log(() => `No such script '${filename}' on '${hostname}' with args: ${arrayToString(scriptArgs)}`);
-          }
-          return false;
-        }
-      },
-    killall:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname, _safetyguard: unknown = true): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const safetyguard = helper.boolean(_safetyguard);
-        if (hostname === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Usage: killall(hostname, [safetyguard boolean])");
-        }
-        const server = safeGetServer(hostname, ctx);
-
-        let scriptsKilled = 0;
-
-        for (let i = server.runningScripts.length - 1; i >= 0; --i) {
-          if (safetyguard === true && server.runningScripts[i].pid == workerScript.pid) continue;
-          killWorkerScript({ runningScript: server.runningScripts[i], hostname: server.hostname });
-          ++scriptsKilled;
-        }
-        WorkerScriptStartStopEventEmitter.emit();
-        ctx.log(() => `Killing all scripts on '${server.hostname}'. May take a few minutes for the scripts to die.`);
-
-        return scriptsKilled > 0;
-      },
-    exit: (ctx: NetscriptContext) => (): void => {
-      workerScript.running = false; // Prevent workerScript from "finishing execution naturally"
-      if (killWorkerScript(workerScript)) {
-        ctx.log(() => "Exiting...");
+        helpers.log(ctx, () => `Disabled logging for all functions`);
+      } else if (possibleLogs[fn] === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${fn}.`);
       } else {
-        ctx.log(() => "Failed. This is a bug. Report to dev.");
+        ctx.workerScript.disableLogs[fn] = true;
+        helpers.log(ctx, () => `Disabled logging for ${fn}`);
       }
     },
-    scp:
-      (ctx: NetscriptContext) =>
-      async (
-        _scriptname: unknown,
-        _destination: unknown,
-        _source: unknown = workerScript.hostname,
-      ): Promise<boolean> => {
-        const destination = ctx.helper.string("destination", _destination);
-        const source = ctx.helper.string("source", _source);
-        if (Array.isArray(_scriptname)) {
-          // Recursively call scp on all elements of array
-          const scripts: string[] = _scriptname;
-          if (scripts.length === 0) {
-            throw ctx.makeRuntimeErrorMsg("No scripts to copy");
-          }
-          let res = true;
-          await Promise.all(
-            scripts.map(async function (script) {
-              if (!(await NetscriptFunctions(workerScript).scp(script, destination, source))) {
-                res = false;
-              }
-            }),
-          );
-          return Promise.resolve(res);
+  enableLog:
+    (ctx: NetscriptContext) =>
+    (_fn: unknown): void => {
+      const fn = helpers.string(ctx, "fn", _fn);
+      if (fn === "ALL") {
+        for (const fn of Object.keys(possibleLogs)) {
+          delete ctx.workerScript.disableLogs[fn];
         }
-
-        const scriptName = ctx.helper.string("scriptName", _scriptname);
-
-        // Invalid file type
-        if (!isValidFilePath(scriptName)) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid filename: '${scriptName}'`);
-        }
-
-        // Invalid file name
-        if (!scriptName.endsWith(".lit") && !isScriptFilename(scriptName) && !scriptName.endsWith("txt")) {
-          throw ctx.makeRuntimeErrorMsg("Only works for scripts, .lit and .txt files");
-        }
-
-        const destServer = safeGetServer(destination, ctx);
-        const currServ = safeGetServer(source, ctx);
-
-        // Scp for lit files
-        if (scriptName.endsWith(".lit")) {
-          let found = false;
-          for (let i = 0; i < currServ.messages.length; ++i) {
-            if (currServ.messages[i] == scriptName) {
-              found = true;
-              break;
-            }
-          }
-
-          if (!found) {
-            ctx.log(() => `File '${scriptName}' does not exist.`);
-            return Promise.resolve(false);
-          }
-
-          for (let i = 0; i < destServer.messages.length; ++i) {
-            if (destServer.messages[i] === scriptName) {
-              ctx.log(() => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
-              return Promise.resolve(true); // Already exists
-            }
-          }
-          destServer.messages.push(scriptName);
-          ctx.log(() => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
-          return Promise.resolve(true);
-        }
-
-        // Scp for text files
-        if (scriptName.endsWith(".txt")) {
-          let txtFile;
-          for (let i = 0; i < currServ.textFiles.length; ++i) {
-            if (currServ.textFiles[i].fn === scriptName) {
-              txtFile = currServ.textFiles[i];
-              break;
-            }
-          }
-          if (txtFile === undefined) {
-            ctx.log(() => `File '${scriptName}' does not exist.`);
-            return Promise.resolve(false);
-          }
-
-          for (let i = 0; i < destServer.textFiles.length; ++i) {
-            if (destServer.textFiles[i].fn === scriptName) {
-              // Overwrite
-              destServer.textFiles[i].text = txtFile.text;
-              ctx.log(() => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
-              return Promise.resolve(true);
-            }
-          }
-          const newFile = new TextFile(txtFile.fn, txtFile.text);
-          destServer.textFiles.push(newFile);
-          ctx.log(() => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
-          return Promise.resolve(true);
-        }
-
-        // Scp for script files
-        let sourceScript = null;
-        for (let i = 0; i < currServ.scripts.length; ++i) {
-          if (scriptName == currServ.scripts[i].filename) {
-            sourceScript = currServ.scripts[i];
-            break;
-          }
-        }
-        if (sourceScript == null) {
-          ctx.log(() => `File '${scriptName}' does not exist.`);
-          return Promise.resolve(false);
-        }
-
-        // Overwrite script if it already exists
-        for (let i = 0; i < destServer.scripts.length; ++i) {
-          if (scriptName == destServer.scripts[i].filename) {
-            ctx.log(() => `WARNING: File '${scriptName}' overwritten on '${destServer?.hostname}'`);
-            const oldScript = destServer.scripts[i];
-            // If it's the exact same file don't actually perform the
-            // copy to avoid recompiling uselessly. Players tend to scp
-            // liberally.
-            if (oldScript.code === sourceScript.code) return Promise.resolve(true);
-            oldScript.code = sourceScript.code;
-            oldScript.ramUsage = sourceScript.ramUsage;
-            oldScript.markUpdated();
-            return Promise.resolve(true);
-          }
-        }
-
-        // Create new script if it does not already exist
-        const newScript = new Script(Player, scriptName);
-        newScript.code = sourceScript.code;
-        newScript.ramUsage = sourceScript.ramUsage;
-        newScript.server = destServer.hostname;
-        destServer.scripts.push(newScript);
-        ctx.log(() => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
-        return new Promise((resolve) => {
-          if (destServer === null) {
-            resolve(false);
-            return;
-          }
-          newScript.updateRamUsage(Player, destServer.scripts).then(() => resolve(true));
-        });
-      },
-    ls:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown, _grep: unknown = ""): string[] => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const grep = ctx.helper.string("grep", _grep);
-
-        const server = safeGetServer(hostname, ctx);
-
-        // Get the grep filter, if one exists
-        let filter = "";
-        if (_grep !== undefined) {
-          filter = grep.toString();
-        }
-
-        const allFiles = [];
-        for (let i = 0; i < server.programs.length; i++) {
-          if (filter) {
-            if (server.programs[i].includes(filter)) {
-              allFiles.push(server.programs[i]);
-            }
-          } else {
-            allFiles.push(server.programs[i]);
-          }
-        }
-        for (let i = 0; i < server.scripts.length; i++) {
-          if (filter) {
-            if (server.scripts[i].filename.includes(filter)) {
-              allFiles.push(server.scripts[i].filename);
-            }
-          } else {
-            allFiles.push(server.scripts[i].filename);
-          }
-        }
-        for (let i = 0; i < server.messages.length; i++) {
-          if (filter) {
-            const msg = server.messages[i];
-            if (msg.includes(filter)) {
-              allFiles.push(msg);
-            }
-          } else {
-            allFiles.push(server.messages[i]);
-          }
-        }
-
-        for (let i = 0; i < server.textFiles.length; i++) {
-          if (filter) {
-            if (server.textFiles[i].fn.includes(filter)) {
-              allFiles.push(server.textFiles[i].fn);
-            }
-          } else {
-            allFiles.push(server.textFiles[i].fn);
-          }
-        }
-
-        for (let i = 0; i < server.contracts.length; ++i) {
-          if (filter) {
-            if (server.contracts[i].fn.includes(filter)) {
-              allFiles.push(server.contracts[i].fn);
-            }
-          } else {
-            allFiles.push(server.contracts[i].fn);
-          }
-        }
-
-        // Sort the files alphabetically then print each
-        allFiles.sort();
-        return allFiles;
-      },
-    getRecentScripts: () => (): IRecentScript[] => {
-      return recentScripts.map((rs) => ({
-        timeOfDeath: rs.timeOfDeath,
-        ...createPublicRunningScript(rs.runningScript),
-      }));
+        helpers.log(ctx, () => `Enabled logging for all functions`);
+      } else if (possibleLogs[fn] === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${fn}.`);
+      }
+      delete ctx.workerScript.disableLogs[fn];
+      helpers.log(ctx, () => `Enabled logging for ${fn}`);
     },
-    ps:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname): ProcessInfo[] => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        const processes = [];
-        for (const script of server.runningScripts) {
-          processes.push({
-            filename: script.filename,
-            threads: script.threads,
-            args: script.args.slice(),
-            pid: script.pid,
-          });
-        }
-        return processes;
-      },
-    hasRootAccess:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
+  isLogEnabled:
+    (ctx: NetscriptContext) =>
+    (_fn: unknown): boolean => {
+      const fn = helpers.string(ctx, "fn", _fn);
+      if (possibleLogs[fn] === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${fn}.`);
+      }
+      return !ctx.workerScript.disableLogs[fn];
+    },
+  getScriptLogs:
+    (ctx: NetscriptContext) =>
+    (scriptID: unknown, hostname: unknown, ...scriptArgs: unknown[]): string[] => {
+      const ident = helpers.scriptIdentifier(ctx, scriptID, hostname, scriptArgs);
+      const runningScriptObj = helpers.getRunningScript(ctx, ident);
+      if (runningScriptObj == null) {
+        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
+        return [];
+      }
 
-        const server = safeGetServer(hostname, ctx);
-        return server.hasAdminRights;
-      },
-    getHostname: (ctx: NetscriptContext) => (): string => {
-      const scriptServer = GetServer(workerScript.hostname);
+      return runningScriptObj.logs.slice();
+    },
+  tail:
+    (ctx: NetscriptContext) =>
+    (scriptID: unknown, hostname: unknown, ...scriptArgs: unknown[]): void => {
+      const ident = helpers.scriptIdentifier(ctx, scriptID, hostname, scriptArgs);
+      const runningScriptObj = helpers.getRunningScript(ctx, ident);
+      if (runningScriptObj == null) {
+        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
+        return;
+      }
+
+      LogBoxEvents.emit(runningScriptObj);
+    },
+
+  closeTail:
+    (ctx: NetscriptContext) =>
+    (_pid: unknown = ctx.workerScript.scriptRef.pid): void => {
+      const pid = helpers.number(ctx, "pid", _pid);
+      //Emit an event to tell the game to close the tail window if it exists
+      LogBoxCloserEvents.emit(pid);
+    },
+  nuke:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return false;
+      }
+      if (server.hasAdminRights) {
+        helpers.log(ctx, () => `Already have root access to '${server.hostname}'.`);
+        return true;
+      }
+      if (!Player.hasProgram(Programs.NukeProgram.name)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the NUKE.exe virus!");
+      }
+      if (server.openPortCount < server.numOpenPortsRequired) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Not enough ports opened to use NUKE.exe virus.");
+      }
+      server.hasAdminRights = true;
+      helpers.log(ctx, () => `Executed NUKE.exe virus on '${server.hostname}' to gain root access.`);
+      return true;
+    },
+  brutessh:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return false;
+      }
+      if (!Player.hasProgram(Programs.BruteSSHProgram.name)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the BruteSSH.exe program!");
+      }
+      if (!server.sshPortOpen) {
+        helpers.log(ctx, () => `Executed BruteSSH.exe on '${server.hostname}' to open SSH port (22).`);
+        server.sshPortOpen = true;
+        ++server.openPortCount;
+      } else {
+        helpers.log(ctx, () => `SSH Port (22) already opened on '${server.hostname}'.`);
+      }
+      return true;
+    },
+  ftpcrack:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      if (hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
+      }
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return false;
+      }
+      if (!Player.hasProgram(Programs.FTPCrackProgram.name)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the FTPCrack.exe program!");
+      }
+      if (!server.ftpPortOpen) {
+        helpers.log(ctx, () => `Executed FTPCrack.exe on '${server.hostname}' to open FTP port (21).`);
+        server.ftpPortOpen = true;
+        ++server.openPortCount;
+      } else {
+        helpers.log(ctx, () => `FTP Port (21) already opened on '${server.hostname}'.`);
+      }
+      return true;
+    },
+  relaysmtp:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      if (hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
+      }
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return false;
+      }
+      if (!Player.hasProgram(Programs.RelaySMTPProgram.name)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the relaySMTP.exe program!");
+      }
+      if (!server.smtpPortOpen) {
+        helpers.log(ctx, () => `Executed relaySMTP.exe on '${server.hostname}' to open SMTP port (25).`);
+        server.smtpPortOpen = true;
+        ++server.openPortCount;
+      } else {
+        helpers.log(ctx, () => `SMTP Port (25) already opened on '${server.hostname}'.`);
+      }
+      return true;
+    },
+  httpworm:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      if (hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument");
+      }
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return false;
+      }
+      if (!Player.hasProgram(Programs.HTTPWormProgram.name)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the HTTPWorm.exe program!");
+      }
+      if (!server.httpPortOpen) {
+        helpers.log(ctx, () => `Executed HTTPWorm.exe on '${server.hostname}' to open HTTP port (80).`);
+        server.httpPortOpen = true;
+        ++server.openPortCount;
+      } else {
+        helpers.log(ctx, () => `HTTP Port (80) already opened on '${server.hostname}'.`);
+      }
+      return true;
+    },
+  sqlinject:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      if (hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
+      }
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return false;
+      }
+      if (!Player.hasProgram(Programs.SQLInjectProgram.name)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the SQLInject.exe program!");
+      }
+      if (!server.sqlPortOpen) {
+        helpers.log(ctx, () => `Executed SQLInject.exe on '${server.hostname}' to open SQL port (1433).`);
+        server.sqlPortOpen = true;
+        ++server.openPortCount;
+      } else {
+        helpers.log(ctx, () => `SQL Port (1433) already opened on '${server.hostname}'.`);
+      }
+      return true;
+    },
+  run:
+    (ctx: NetscriptContext) =>
+    (_scriptname: unknown, _threads: unknown = 1, ..._args: unknown[]): number => {
+      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
+      const threads = helpers.number(ctx, "threads", _threads);
+      const args = helpers.scriptArgs(ctx, _args);
+      if (scriptname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: run(scriptname, [numThreads], [arg1], [arg2]...)");
+      }
+      if (isNaN(threads) || threads <= 0) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid thread count. Must be numeric and > 0, is ${threads}`);
+      }
+      const scriptServer = GetServer(ctx.workerScript.hostname);
       if (scriptServer == null) {
-        throw ctx.makeRuntimeErrorMsg("Could not find server. This is a bug. Report to dev.");
+        throw helpers.makeRuntimeErrorMsg(ctx, "Could not find server. This is a bug. Report to dev.");
       }
-      return scriptServer.hostname;
+
+      return runScriptFromScript(Player, "run", scriptServer, scriptname, args, ctx.workerScript, threads);
     },
-    getHackingLevel: (ctx: NetscriptContext) => (): number => {
-      Player.updateSkillLevels();
-      ctx.log(() => `returned ${Player.skills.hacking}`);
-      return Player.skills.hacking;
-    },
-    getHackingMultipliers: () => (): HackingMultipliers => {
-      return {
-        chance: Player.mults.hacking_chance,
-        speed: Player.mults.hacking_speed,
-        money: Player.mults.hacking_money,
-        growth: Player.mults.hacking_grow,
-      };
-    },
-    getHacknetMultipliers: () => (): HacknetMultipliers => {
-      return {
-        production: Player.mults.hacknet_node_money,
-        purchaseCost: Player.mults.hacknet_node_purchase_cost,
-        ramCost: Player.mults.hacknet_node_ram_cost,
-        coreCost: Player.mults.hacknet_node_core_cost,
-        levelCost: Player.mults.hacknet_node_level_cost,
-      };
-    },
-    getBitNodeMultipliers: (ctx: NetscriptContext) => (): IBNMults => {
-      if (Player.sourceFileLvl(5) <= 0 && Player.bitNodeN !== 5) {
-        throw ctx.makeRuntimeErrorMsg("Requires Source-File 5 to run.");
+  exec:
+    (ctx: NetscriptContext) =>
+    (_scriptname: unknown, _hostname: unknown, _threads: unknown = 1, ..._args: unknown[]): number => {
+      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const threads = helpers.number(ctx, "threads", _threads);
+      const args = helpers.scriptArgs(ctx, _args);
+      if (scriptname === undefined || hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: exec(scriptname, server, [numThreads], [arg1], [arg2]...)");
       }
-      const copy = Object.assign({}, BitNodeMultipliers);
-      return copy;
+      if (isNaN(threads) || threads <= 0) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid thread count. Must be numeric and > 0, is ${threads}`);
+      }
+      const server = helpers.getServer(ctx, hostname);
+      return runScriptFromScript(Player, "exec", server, scriptname, args, ctx.workerScript, threads);
     },
-    getServer:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname): IServerDef => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        const copy = Object.assign({}, server) as Server;
-        // These fields should be hidden.
-        copy.contracts = [];
-        copy.messages = [];
-        copy.runningScripts = [];
-        copy.scripts = [];
-        copy.textFiles = [];
-        copy.programs = [];
-        copy.serversOnNetwork = [];
-        if (!copy.baseDifficulty) copy.baseDifficulty = 0;
-        if (!copy.hackDifficulty) copy.hackDifficulty = 0;
-        if (!copy.minDifficulty) copy.minDifficulty = 0;
-        if (!copy.moneyAvailable) copy.moneyAvailable = 0;
-        if (!copy.moneyMax) copy.moneyMax = 0;
-        if (!copy.numOpenPortsRequired) copy.numOpenPortsRequired = 0;
-        if (!copy.openPortCount) copy.openPortCount = 0;
-        if (!copy.requiredHackingSkill) copy.requiredHackingSkill = 0;
-        if (!copy.serverGrowth) copy.serverGrowth = 0;
-        return copy;
-      },
-    getServerMoneyAvailable:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 0;
-        }
-        if (failOnHacknetServer(server, "getServerMoneyAvailable")) {
-          return 0;
-        }
-        if (server.hostname == "home") {
-          // Return player's money
-          ctx.log(() => `returned player's money: ${numeralWrapper.formatMoney(Player.money)}`);
-          return Player.money;
-        }
-        ctx.log(() => `returned ${numeralWrapper.formatMoney(server.moneyAvailable)} for '${server.hostname}'`);
-        return server.moneyAvailable;
-      },
-    getServerSecurityLevel:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 1;
-        }
-        if (failOnHacknetServer(server, "getServerSecurityLevel")) {
-          return 1;
-        }
-        ctx.log(
-          () => `returned ${numeralWrapper.formatServerSecurity(server.hackDifficulty)} for '${server.hostname}'`,
-        );
-        return server.hackDifficulty;
-      },
-    getServerBaseSecurityLevel:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        ctx.log(() => `getServerBaseSecurityLevel is deprecated because it's not useful.`);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 1;
-        }
-        if (failOnHacknetServer(server, "getServerBaseSecurityLevel")) {
-          return 1;
-        }
-        ctx.log(
-          () => `returned ${numeralWrapper.formatServerSecurity(server.baseDifficulty)} for '${server.hostname}'`,
-        );
-        return server.baseDifficulty;
-      },
-    getServerMinSecurityLevel:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 1;
-        }
-        if (failOnHacknetServer(server, "getServerMinSecurityLevel")) {
-          return 1;
-        }
-        ctx.log(() => `returned ${numeralWrapper.formatServerSecurity(server.minDifficulty)} for ${server.hostname}`);
-        return server.minDifficulty;
-      },
-    getServerRequiredHackingLevel:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 1;
-        }
-        if (failOnHacknetServer(server, "getServerRequiredHackingLevel")) {
-          return 1;
-        }
-        ctx.log(() => `returned ${numeralWrapper.formatSkill(server.requiredHackingSkill)} for '${server.hostname}'`);
-        return server.requiredHackingSkill;
-      },
-    getServerMaxMoney:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 0;
-        }
-        if (failOnHacknetServer(server, "getServerMaxMoney")) {
-          return 0;
-        }
-        ctx.log(() => `returned ${numeralWrapper.formatMoney(server.moneyMax)} for '${server.hostname}'`);
-        return server.moneyMax;
-      },
-    getServerGrowth:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 1;
-        }
-        if (failOnHacknetServer(server, "getServerGrowth")) {
-          return 1;
-        }
-        ctx.log(() => `returned ${server.serverGrowth} for '${server.hostname}'`);
-        return server.serverGrowth;
-      },
-    getServerNumPortsRequired:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "Cannot be executed on this server.");
-          return 5;
-        }
-        if (failOnHacknetServer(server, "getServerNumPortsRequired")) {
-          return 5;
-        }
-        ctx.log(() => `returned ${server.numOpenPortsRequired} for '${server.hostname}'`);
-        return server.numOpenPortsRequired;
-      },
-    getServerRam:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): [number, number] => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        ctx.log(() => `getServerRam is deprecated in favor of getServerMaxRam / getServerUsedRam`);
-        const server = safeGetServer(hostname, ctx);
-        ctx.log(
-          () => `returned [${numeralWrapper.formatRAM(server.maxRam)}, ${numeralWrapper.formatRAM(server.ramUsed)}]`,
-        );
-        return [server.maxRam, server.ramUsed];
-      },
-    getServerMaxRam:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        ctx.log(() => `returned ${numeralWrapper.formatRAM(server.maxRam)}`);
-        return server.maxRam;
-      },
-    getServerUsedRam:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        ctx.log(() => `returned ${numeralWrapper.formatRAM(server.ramUsed)}`);
-        return server.ramUsed;
-      },
-    serverExists:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown): boolean => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        return GetServer(hostname) !== null;
-      },
-    fileExists:
-      (ctx: NetscriptContext) =>
-      (_filename: unknown, _hostname: unknown = workerScript.hostname): boolean => {
-        const filename = ctx.helper.string("filename", _filename);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        if (filename === undefined) {
-          throw ctx.makeRuntimeErrorMsg("Usage: fileExists(scriptname, [server])");
-        }
-        const server = safeGetServer(hostname, ctx);
-        for (let i = 0; i < server.scripts.length; ++i) {
-          if (filename == server.scripts[i].filename) {
-            return true;
-          }
-        }
-        for (let i = 0; i < server.programs.length; ++i) {
-          if (filename.toLowerCase() == server.programs[i].toLowerCase()) {
-            return true;
-          }
-        }
-        for (let i = 0; i < server.messages.length; ++i) {
-          if (filename.toLowerCase() === server.messages[i].toLowerCase()) {
-            return true;
-          }
-        }
-        const txtFile = getTextFile(filename, server);
-        return txtFile != null;
-      },
-    isRunning:
-      (ctx: NetscriptContext) =>
-      (fn: unknown, hostname: unknown, ...scriptArgs: unknown[]): boolean => {
-        const ident = ctx.helper.scriptIdentifier(fn, hostname, scriptArgs);
-        return getRunningScript(ctx, ident) !== null;
-      },
-    getPurchasedServerLimit: () => (): number => {
-      return getPurchaseServerLimit();
-    },
-    getPurchasedServerMaxRam: () => (): number => {
-      return getPurchaseServerMaxRam();
-    },
-    getPurchasedServerCost:
-      (ctx: NetscriptContext) =>
-      (_ram: unknown): number => {
-        const ram = ctx.helper.number("ram", _ram);
+  spawn:
+    (ctx: NetscriptContext) =>
+    (_scriptname: unknown, _threads: unknown = 1, ..._args: unknown[]): void => {
+      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
+      const threads = helpers.number(ctx, "threads", _threads);
+      const args = helpers.scriptArgs(ctx, _args);
+      if (!scriptname || !threads) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: spawn(scriptname, threads)");
+      }
 
-        const cost = getPurchaseServerCost(ram);
-        if (cost === Infinity) {
-          ctx.log(() => `Invalid argument: ram='${ram}'`);
-          return Infinity;
+      const spawnDelay = 10;
+      setTimeout(() => {
+        if (isNaN(threads) || threads <= 0) {
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid thread count. Must be numeric and > 0, is ${threads}`);
+        }
+        const scriptServer = GetServer(ctx.workerScript.hostname);
+        if (scriptServer == null) {
+          throw helpers.makeRuntimeErrorMsg(ctx, "Could not find server. This is a bug. Report to dev");
         }
 
-        return cost;
-      },
-    purchaseServer:
-      (ctx: NetscriptContext) =>
-      (_name: unknown, _ram: unknown): string => {
-        const name = ctx.helper.string("name", _name);
-        const ram = ctx.helper.number("ram", _ram);
-        let hostnameStr = String(name);
-        hostnameStr = hostnameStr.replace(/\s+/g, "");
-        if (hostnameStr == "") {
-          ctx.log(() => `Invalid argument: hostname='${hostnameStr}'`);
-          return "";
+        return runScriptFromScript(Player, "spawn", scriptServer, scriptname, args, ctx.workerScript, threads);
+      }, spawnDelay * 1e3);
+
+      helpers.log(ctx, () => `Will execute '${scriptname}' in ${spawnDelay} seconds`);
+
+      ctx.workerScript.running = false; // Prevent workerScript from "finishing execution naturally"
+      if (killWorkerScript(ctx.workerScript)) {
+        helpers.log(ctx, () => "Exiting...");
+      }
+    },
+  kill:
+    (ctx: NetscriptContext) =>
+    (scriptID: unknown, hostname: unknown, ...scriptArgs: unknown[]): boolean => {
+      const ident = helpers.scriptIdentifier(ctx, scriptID, hostname, scriptArgs);
+      let res;
+      const killByPid = typeof ident === "number";
+      if (killByPid) {
+        // Kill by pid
+        res = killWorkerScript(ident);
+      } else {
+        // Kill by filename/hostname
+        if (scriptID === undefined || hostname === undefined) {
+          throw helpers.makeRuntimeErrorMsg(ctx, "Usage: kill(scriptname, server, [arg1], [arg2]...)");
         }
 
-        if (Player.purchasedServers.length >= getPurchaseServerLimit()) {
-          ctx.log(
-            () =>
-              `You have reached the maximum limit of ${getPurchaseServerLimit()} servers. You cannot purchase any more.`,
+        const server = helpers.getServer(ctx, ident.hostname);
+        const runningScriptObj = helpers.getRunningScriptByArgs(ctx, ident.scriptname, ident.hostname, ident.args);
+        if (runningScriptObj == null) {
+          helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
+          return false;
+        }
+
+        res = killWorkerScript({ runningScript: runningScriptObj, hostname: server.hostname });
+      }
+
+      if (res) {
+        if (killByPid) {
+          helpers.log(ctx, () => `Killing script with PID ${ident}`);
+        } else {
+          helpers.log(ctx, () => `Killing '${scriptID}' on '${hostname}' with args: ${arrayToString(scriptArgs)}.`);
+        }
+        return true;
+      } else {
+        if (killByPid) {
+          helpers.log(ctx, () => `No script with PID ${ident}`);
+        } else {
+          helpers.log(
+            ctx,
+            () => `No such script '${scriptID}' on '${hostname}' with args: ${arrayToString(scriptArgs)}`,
           );
-          return "";
         }
+        return false;
+      }
+    },
+  killall:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname, _safetyguard: unknown = true): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const safetyguard = !!_safetyguard;
+      if (hostname === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: killall(hostname, [safetyguard boolean])");
+      }
+      const server = helpers.getServer(ctx, hostname);
 
-        const cost = getPurchaseServerCost(ram);
-        if (cost === Infinity) {
-          if (ram > getPurchaseServerMaxRam()) {
-            ctx.log(() => `Invalid argument: ram='${ram}' must not be greater than getPurchaseServerMaxRam`);
-          } else {
-            ctx.log(() => `Invalid argument: ram='${ram}' must be a positive power of 2`);
-          }
+      let scriptsKilled = 0;
 
-          return "";
+      for (let i = server.runningScripts.length - 1; i >= 0; --i) {
+        if (safetyguard === true && server.runningScripts[i].pid == ctx.workerScript.pid) continue;
+        killWorkerScript({ runningScript: server.runningScripts[i], hostname: server.hostname });
+        ++scriptsKilled;
+      }
+      WorkerScriptStartStopEventEmitter.emit();
+      helpers.log(
+        ctx,
+        () => `Killing all scripts on '${server.hostname}'. May take a few minutes for the scripts to die.`,
+      );
+
+      return scriptsKilled > 0;
+    },
+  exit: (ctx: NetscriptContext) => (): void => {
+    ctx.workerScript.running = false; // Prevent workerScript from "finishing execution naturally"
+    if (killWorkerScript(ctx.workerScript)) {
+      helpers.log(ctx, () => "Exiting...");
+    } else {
+      helpers.log(ctx, () => "Failed. This is a bug. Report to dev.");
+    }
+  },
+  scp:
+    (ctx: NetscriptContext) =>
+    async (
+      _scriptname: unknown,
+      _destination: unknown,
+      _source: unknown = ctx.workerScript.hostname,
+    ): Promise<boolean> => {
+      const destination = helpers.string(ctx, "destination", _destination);
+      const source = helpers.string(ctx, "source", _source);
+      if (Array.isArray(_scriptname)) {
+        // Recursively call scp on all elements of array
+        const scripts: string[] = _scriptname;
+        if (scripts.length === 0) {
+          throw helpers.makeRuntimeErrorMsg(ctx, "No scripts to copy");
         }
-
-        if (Player.money < cost) {
-          ctx.log(() => `Not enough money to purchase server. Need ${numeralWrapper.formatMoney(cost)}`);
-          return "";
-        }
-        const newServ = safetlyCreateUniqueServer({
-          ip: createUniqueRandomIp(),
-          hostname: hostnameStr,
-          organizationName: "",
-          isConnectedTo: false,
-          adminRights: true,
-          purchasedByPlayer: true,
-          maxRam: ram,
-        });
-        AddToAllServers(newServ);
-
-        Player.purchasedServers.push(newServ.hostname);
-        const homeComputer = Player.getHomeComputer();
-        homeComputer.serversOnNetwork.push(newServ.hostname);
-        newServ.serversOnNetwork.push(homeComputer.hostname);
-        Player.loseMoney(cost, "servers");
-        ctx.log(
-          () => `Purchased new server with hostname '${newServ.hostname}' for ${numeralWrapper.formatMoney(cost)}`,
+        let res = true;
+        await Promise.all(
+          scripts.map(async function (script) {
+            if (!(await NetscriptFunctions(ctx.workerScript).scp(script, destination, source))) {
+              res = false;
+            }
+          }),
         );
-        return newServ.hostname;
-      },
-    deleteServer:
-      (ctx: NetscriptContext) =>
-      (_name: unknown): boolean => {
-        const name = ctx.helper.string("name", _name);
-        let hostnameStr = String(name);
-        hostnameStr = hostnameStr.replace(/\s\s+/g, "");
-        const server = GetServer(hostnameStr);
-        if (!(server instanceof Server)) {
-          ctx.log(() => `Invalid argument: hostname='${hostnameStr}'`);
-          return false;
-        }
+        return Promise.resolve(res);
+      }
 
-        if (!server.purchasedByPlayer || server.hostname === "home") {
-          ctx.log(() => "Cannot delete non-purchased server.");
-          return false;
-        }
+      const scriptName = helpers.string(ctx, "scriptName", _scriptname);
 
-        const hostname = server.hostname;
+      // Invalid file type
+      if (!isValidFilePath(scriptName)) {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: '${scriptName}'`);
+      }
 
-        // Can't delete server you're currently connected to
-        if (server.isConnectedTo) {
-          ctx.log(() => "You are currently connected to the server you are trying to delete.");
-          return false;
-        }
+      // Invalid file name
+      if (!scriptName.endsWith(".lit") && !isScriptFilename(scriptName) && !scriptName.endsWith("txt")) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Only works for scripts, .lit and .txt files");
+      }
 
-        // A server cannot delete itself
-        if (hostname === workerScript.hostname) {
-          ctx.log(() => "Cannot delete the server this script is running on.");
-          return false;
-        }
+      const destServer = helpers.getServer(ctx, destination);
+      const currServ = helpers.getServer(ctx, source);
 
-        // Delete all scripts running on server
-        if (server.runningScripts.length > 0) {
-          ctx.log(() => `Cannot delete server '${hostname}' because it still has scripts running.`);
-          return false;
-        }
-
-        // Delete from player's purchasedServers array
+      // Scp for lit files
+      if (scriptName.endsWith(".lit")) {
         let found = false;
-        for (let i = 0; i < Player.purchasedServers.length; ++i) {
-          if (hostname == Player.purchasedServers[i]) {
+        for (let i = 0; i < currServ.messages.length; ++i) {
+          if (currServ.messages[i] == scriptName) {
             found = true;
-            Player.purchasedServers.splice(i, 1);
             break;
           }
         }
 
         if (!found) {
-          ctx.log(() => `Could not identify server ${hostname} as a purchased server. This is a bug. Report to dev.`);
-          return false;
-        }
-
-        // Delete from all servers
-        DeleteServer(hostname);
-
-        // Delete from home computer
-        found = false;
-        const homeComputer = Player.getHomeComputer();
-        for (let i = 0; i < homeComputer.serversOnNetwork.length; ++i) {
-          if (hostname == homeComputer.serversOnNetwork[i]) {
-            homeComputer.serversOnNetwork.splice(i, 1);
-            ctx.log(() => `Deleted server '${hostnameStr}`);
-            return true;
-          }
-        }
-        // Wasn't found on home computer
-        ctx.log(() => `Could not find server ${hostname} as a purchased server. This is a bug. Report to dev.`);
-        return false;
-      },
-    getPurchasedServers: () => (): string[] => {
-      const res: string[] = [];
-      Player.purchasedServers.forEach(function (hostname) {
-        res.push(hostname);
-      });
-      return res;
-    },
-    writePort:
-      (ctx: NetscriptContext) =>
-      (_port: unknown, data: unknown = ""): Promise<any> => {
-        const port = ctx.helper.number("port", _port);
-        if (typeof data !== "string" && typeof data !== "number") {
-          throw ctx.makeRuntimeErrorMsg(`Trying to write invalid data to a port: only strings and numbers are valid.`);
-        }
-        const iport = helper.getValidPort("writePort", port);
-        return Promise.resolve(iport.write(data));
-      },
-    write:
-      (ctx: NetscriptContext) =>
-      (_port: unknown, data: unknown = "", _mode: unknown = "a"): Promise<void> => {
-        const port = ctx.helper.string("port", _port);
-        const mode = ctx.helper.string("mode", _mode);
-        if (isString(port)) {
-          // Write to script or text file
-          let fn = port;
-          if (!isValidFilePath(fn)) {
-            throw ctx.makeRuntimeErrorMsg(`Invalid filepath: ${fn}`);
-          }
-
-          if (fn.lastIndexOf("/") === 0) {
-            fn = removeLeadingSlash(fn);
-          }
-
-          // Coerce 'data' to be a string
-          try {
-            data = String(data);
-          } catch (e: unknown) {
-            throw ctx.makeRuntimeErrorMsg(
-              `Invalid data (${String(e)}). Data being written must be convertible to a string`,
-            );
-          }
-
-          const server = workerScript.getServer();
-          if (server == null) {
-            throw ctx.makeRuntimeErrorMsg("Error getting Server. This is a bug. Report to dev.");
-          }
-          if (isScriptFilename(fn)) {
-            // Write to script
-            let script = workerScript.getScriptOnServer(fn, server);
-            if (script == null) {
-              // Create a new script
-              script = new Script(Player, fn, String(data), server.hostname, server.scripts);
-              server.scripts.push(script);
-              return script.updateRamUsage(Player, server.scripts);
-            }
-            mode === "w" ? (script.code = String(data)) : (script.code += data);
-            return script.updateRamUsage(Player, server.scripts);
-          } else {
-            // Write to text file
-            const txtFile = getTextFile(fn, server);
-            if (txtFile == null) {
-              createTextFile(fn, String(data), server);
-              return Promise.resolve();
-            }
-            if (mode === "w") {
-              txtFile.write(String(data));
-            } else {
-              txtFile.append(String(data));
-            }
-          }
-          return Promise.resolve();
-        } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${port}`);
-        }
-      },
-    tryWritePort:
-      (ctx: NetscriptContext) =>
-      (_port: unknown, data: unknown = ""): Promise<any> => {
-        let port = ctx.helper.number("port", _port);
-        if (typeof data !== "string" && typeof data !== "number") {
-          throw makeRuntimeErrorMsg(
-            "tryWritePort",
-            `Trying to write invalid data to a port: only strings and numbers are valid.`,
-          );
-        }
-        if (!isNaN(port)) {
-          port = Math.round(port);
-          if (port < 1 || port > CONSTANTS.NumNetscriptPorts) {
-            throw makeRuntimeErrorMsg(
-              "tryWritePort",
-              `Invalid port: ${port}. Only ports 1-${CONSTANTS.NumNetscriptPorts} are valid.`,
-            );
-          }
-          const iport = NetscriptPorts[port - 1];
-          if (iport == null || !(iport instanceof Object)) {
-            throw ctx.makeRuntimeErrorMsg(`Could not find port: ${port}. This is a bug. Report to dev.`);
-          }
-          return Promise.resolve(iport.tryWrite(data));
-        } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${port}`);
-        }
-      },
-    readPort:
-      (ctx: NetscriptContext) =>
-      (_port: unknown): unknown => {
-        const port = ctx.helper.number("port", _port);
-        // Read from port
-        const iport = helper.getValidPort("readPort", port);
-        const x = iport.read();
-        return x;
-      },
-    read:
-      (ctx: NetscriptContext) =>
-      (_port: unknown): string => {
-        const port = ctx.helper.string("port", _port);
-        if (isString(port)) {
-          // Read from script or text file
-          const fn = port;
-          const server = GetServer(workerScript.hostname);
-          if (server == null) {
-            throw ctx.makeRuntimeErrorMsg("Error getting Server. This is a bug. Report to dev.");
-          }
-          if (isScriptFilename(fn)) {
-            // Read from script
-            const script = workerScript.getScriptOnServer(fn, server);
-            if (script == null) {
-              return "";
-            }
-            return script.code;
-          } else {
-            // Read from text file
-            const txtFile = getTextFile(fn, server);
-            if (txtFile !== null) {
-              return txtFile.text;
-            } else {
-              return "";
-            }
-          }
-        } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${port}`);
-        }
-      },
-    peek:
-      (ctx: NetscriptContext) =>
-      (_port: unknown): unknown => {
-        const port = ctx.helper.number("port", _port);
-        const iport = helper.getValidPort("peek", port);
-        const x = iport.peek();
-        return x;
-      },
-    clear:
-      (ctx: NetscriptContext) =>
-      (_file: unknown): void => {
-        const file = ctx.helper.string("file", _file);
-        if (isString(file)) {
-          // Clear text file
-          const fn = file;
-          const server = GetServer(workerScript.hostname);
-          if (server == null) {
-            throw ctx.makeRuntimeErrorMsg("Error getting Server. This is a bug. Report to dev.");
-          }
-          const txtFile = getTextFile(fn, server);
-          if (txtFile != null) {
-            txtFile.write("");
-          }
-        } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid argument: ${file}`);
-        }
-      },
-    clearPort:
-      (ctx: NetscriptContext) =>
-      (_port: unknown): void => {
-        const port = ctx.helper.number("port", _port);
-        // Clear port
-        const iport = helper.getValidPort("clearPort", port);
-        iport.clear();
-      },
-    getPortHandle:
-      (ctx: NetscriptContext) =>
-      (_port: unknown): IPort => {
-        const port = ctx.helper.number("port", _port);
-        const iport = helper.getValidPort("getPortHandle", port);
-        return iport;
-      },
-    rm:
-      (ctx: NetscriptContext) =>
-      (_fn: unknown, _hostname: unknown = workerScript.hostname): boolean => {
-        const fn = ctx.helper.string("fn", _fn);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const s = safeGetServer(hostname, ctx);
-
-        const status = s.removeFile(fn);
-        if (!status.res) {
-          ctx.log(() => status.msg + "");
-        }
-
-        return status.res;
-      },
-    scriptRunning:
-      (ctx: NetscriptContext) =>
-      (_scriptname: unknown, _hostname: unknown): boolean => {
-        const scriptname = ctx.helper.string("scriptname", _scriptname);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        for (let i = 0; i < server.runningScripts.length; ++i) {
-          if (server.runningScripts[i].filename == scriptname) {
-            return true;
-          }
-        }
-        return false;
-      },
-    scriptKill:
-      (ctx: NetscriptContext) =>
-      (_scriptname: unknown, _hostname: unknown): boolean => {
-        const scriptname = ctx.helper.string("scriptname", _scriptname);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        let suc = false;
-        for (let i = 0; i < server.runningScripts.length; i++) {
-          if (server.runningScripts[i].filename == scriptname) {
-            killWorkerScript({ runningScript: server.runningScripts[i], hostname: server.hostname });
-            suc = true;
-            i--;
-          }
-        }
-        return suc;
-      },
-    getScriptName: () => (): string => {
-      return workerScript.name;
-    },
-    getScriptRam:
-      (ctx: NetscriptContext) =>
-      (_scriptname: unknown, _hostname: unknown = workerScript.hostname): number => {
-        const scriptname = ctx.helper.string("scriptname", _scriptname);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        for (let i = 0; i < server.scripts.length; ++i) {
-          if (server.scripts[i].filename == scriptname) {
-            return server.scripts[i].ramUsage;
-          }
-        }
-        return 0;
-      },
-    getRunningScript:
-      (ctx: NetscriptContext) =>
-      (fn: unknown, hostname: unknown, ...args: unknown[]): IRunningScriptDef | null => {
-        const ident = ctx.helper.scriptIdentifier(fn, hostname, args);
-        const runningScript = getRunningScript(ctx, ident);
-        if (runningScript === null) return null;
-        return createPublicRunningScript(runningScript);
-      },
-    getHackTime:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "invalid for this kind of server");
-          return Infinity;
-        }
-        if (failOnHacknetServer(server, "getHackTime")) {
-          return Infinity;
-        }
-
-        return calculateHackingTime(server, Player) * 1000;
-      },
-    getGrowTime:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "invalid for this kind of server");
-          return Infinity;
-        }
-        if (failOnHacknetServer(server, "getGrowTime")) {
-          return Infinity;
-        }
-
-        return calculateGrowTime(server, Player) * 1000;
-      },
-    getWeakenTime:
-      (ctx: NetscriptContext) =>
-      (_hostname: unknown = workerScript.hostname): number => {
-        const hostname = ctx.helper.string("hostname", _hostname);
-        const server = safeGetServer(hostname, ctx);
-        if (!(server instanceof Server)) {
-          ctx.log(() => "invalid for this kind of server");
-          return Infinity;
-        }
-        if (failOnHacknetServer(server, "getWeakenTime")) {
-          return Infinity;
-        }
-
-        return calculateWeakenTime(server, Player) * 1000;
-      },
-    getTotalScriptIncome: () => (): [number, number] => {
-      // First element is total income of all currently running scripts
-      let total = 0;
-      for (const script of workerScripts.values()) {
-        total += script.scriptRef.onlineMoneyMade / script.scriptRef.onlineRunningTime;
-      }
-
-      return [total, Player.scriptProdSinceLastAug / (Player.playtimeSinceLastAug / 1000)];
-    },
-    getScriptIncome:
-      (ctx: NetscriptContext) =>
-      (fn: unknown, hostname: unknown, ...args: unknown[]): number => {
-        const ident = ctx.helper.scriptIdentifier(fn, hostname, args);
-        const runningScript = getRunningScript(ctx, ident);
-        if (runningScript == null) {
-          ctx.log(() => getCannotFindRunningScriptErrorMessage(ident));
-          return -1;
-        }
-        return runningScript.onlineMoneyMade / runningScript.onlineRunningTime;
-      },
-    getTotalScriptExpGain: () => (): number => {
-      let total = 0;
-      for (const ws of workerScripts.values()) {
-        total += ws.scriptRef.onlineExpGained / ws.scriptRef.onlineRunningTime;
-      }
-      return total;
-    },
-    getScriptExpGain:
-      (ctx: NetscriptContext) =>
-      (fn: unknown, hostname: unknown, ...args: unknown[]): number => {
-        const ident = ctx.helper.scriptIdentifier(fn, hostname, args);
-        const runningScript = getRunningScript(ctx, ident);
-        if (runningScript == null) {
-          ctx.log(() => getCannotFindRunningScriptErrorMessage(ident));
-          return -1;
-        }
-        return runningScript.onlineExpGained / runningScript.onlineRunningTime;
-      },
-    nFormat:
-      (ctx: NetscriptContext) =>
-      (_n: unknown, _format: unknown): string => {
-        const n = ctx.helper.number("n", _n);
-        const format = ctx.helper.string("format", _format);
-        if (isNaN(n)) {
-          return "";
-        }
-
-        return numeralWrapper.format(n, format);
-      },
-    tFormat:
-      (ctx: NetscriptContext) =>
-      (_milliseconds: unknown, _milliPrecision: unknown = false): string => {
-        const milliseconds = ctx.helper.number("milliseconds", _milliseconds);
-        const milliPrecision = helper.boolean(_milliPrecision);
-        return convertTimeMsToTimeElapsedString(milliseconds, milliPrecision);
-      },
-    getTimeSinceLastAug: () => (): number => {
-      return Player.playtimeSinceLastAug;
-    },
-    alert:
-      (ctx: NetscriptContext) =>
-      (_message: unknown): void => {
-        const message = ctx.helper.string("message", _message);
-        dialogBoxCreate(message);
-      },
-    toast:
-      (ctx: NetscriptContext) =>
-      (_message: unknown, _variant: unknown = ToastVariant.SUCCESS, _duration: unknown = 2000): void => {
-        const message = ctx.helper.string("message", _message);
-        const variant = ctx.helper.string("variant", _variant);
-        const duration = ctx.helper.number("duration", _duration);
-        if (!checkEnum(ToastVariant, variant))
-          throw new Error(`variant must be one of ${Object.values(ToastVariant).join(", ")}`);
-        SnackbarEvents.emit(message, variant, duration);
-      },
-    prompt:
-      (ctx: NetscriptContext) =>
-      (_txt: unknown, options?: { type?: string; options?: string[] }): Promise<boolean | string> => {
-        const txt = ctx.helper.string("txt", _txt);
-
-        return new Promise(function (resolve) {
-          PromptEvent.emit({
-            txt: txt,
-            options,
-            resolve: resolve,
-          });
-        });
-      },
-    wget:
-      (ctx: NetscriptContext) =>
-      async (_url: unknown, _target: unknown, _hostname: unknown = workerScript.hostname): Promise<boolean> => {
-        const url = ctx.helper.string("url", _url);
-        const target = ctx.helper.string("target", _target);
-        const hostname = ctx.helper.string("hostname", _hostname);
-        if (!isScriptFilename(target) && !target.endsWith(".txt")) {
-          ctx.log(() => `Invalid target file: '${target}'. Must be a script or text file.`);
+          helpers.log(ctx, () => `File '${scriptName}' does not exist.`);
           return Promise.resolve(false);
         }
-        const s = safeGetServer(hostname, ctx);
-        return new Promise(function (resolve) {
-          $.get(
-            url,
-            function (data) {
-              let res;
-              if (isScriptFilename(target)) {
-                res = s.writeToScriptFile(Player, target, data);
-              } else {
-                res = s.writeToTextFile(target, data);
-              }
-              if (!res.success) {
-                ctx.log(() => "Failed.");
-                return resolve(false);
-              }
-              if (res.overwritten) {
-                ctx.log(() => `Successfully retrieved content and overwrote '${target}' on '${hostname}'`);
-                return resolve(true);
-              }
-              ctx.log(() => `Successfully retrieved content to new file '${target}' on '${hostname}'`);
-              return resolve(true);
-            },
-            "text",
-          ).fail(function (e) {
-            ctx.log(() => JSON.stringify(e));
-            return resolve(false);
-          });
-        });
-      },
-    getFavorToDonate: () => (): number => {
-      return Math.floor(CONSTANTS.BaseFavorToDonate * BitNodeMultipliers.RepToDonateToFaction);
-    },
-    getPlayer: () => (): INetscriptPlayer => {
-      const data = {
-        hp: Player.hp,
-        skills: Player.skills,
-        exp: Player.exp,
-        hacking_chance_mult: Player.mults.hacking_chance,
-        mults: JSON.parse(JSON.stringify(Player.mults)),
-        numPeopleKilled: Player.numPeopleKilled,
-        money: Player.money,
-        city: Player.city,
-        location: Player.location,
-        bitNodeN: Player.bitNodeN,
-        totalPlaytime: Player.totalPlaytime,
-        playtimeSinceLastAug: Player.playtimeSinceLastAug,
-        playtimeSinceLastBitnode: Player.playtimeSinceLastBitnode,
-        jobs: {},
-        factions: Player.factions.slice(),
-        tor: Player.hasTorRouter(),
-        inBladeburner: Player.inBladeburner(),
-        hasCorporation: Player.hasCorporation(),
-        entropy: Player.entropy,
-      };
-      Object.assign(data.jobs, Player.jobs);
-      return data;
-    },
-    atExit:
-      (ctx: NetscriptContext) =>
-      (f: unknown): void => {
-        if (typeof f !== "function") {
-          throw ctx.makeRuntimeErrorMsg("argument should be function");
+
+        for (let i = 0; i < destServer.messages.length; ++i) {
+          if (destServer.messages[i] === scriptName) {
+            helpers.log(ctx, () => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
+            return Promise.resolve(true); // Already exists
+          }
         }
-        workerScript.atExit = () => {
-          f();
-        }; // Wrap the user function to prevent WorkerScript leaking as 'this'
-      },
-    mv:
-      (ctx: NetscriptContext) =>
-      (_host: unknown, _source: unknown, _destination: unknown): void => {
-        const host = ctx.helper.string("host", _host);
-        const source = ctx.helper.string("source", _source);
-        const destination = ctx.helper.string("destination", _destination);
+        destServer.messages.push(scriptName);
+        helpers.log(ctx, () => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
+        return Promise.resolve(true);
+      }
 
-        if (!isValidFilePath(source)) throw ctx.makeRuntimeErrorMsg(`Invalid filename: '${source}'`);
-        if (!isValidFilePath(destination)) throw ctx.makeRuntimeErrorMsg(`Invalid filename: '${destination}'`);
+      // Scp for text files
+      if (scriptName.endsWith(".txt")) {
+        let txtFile;
+        for (let i = 0; i < currServ.textFiles.length; ++i) {
+          if (currServ.textFiles[i].fn === scriptName) {
+            txtFile = currServ.textFiles[i];
+            break;
+          }
+        }
+        if (txtFile === undefined) {
+          helpers.log(ctx, () => `File '${scriptName}' does not exist.`);
+          return Promise.resolve(false);
+        }
 
-        const source_is_txt = source.endsWith(".txt");
-        const dest_is_txt = destination.endsWith(".txt");
+        for (let i = 0; i < destServer.textFiles.length; ++i) {
+          if (destServer.textFiles[i].fn === scriptName) {
+            // Overwrite
+            destServer.textFiles[i].text = txtFile.text;
+            helpers.log(ctx, () => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
+            return Promise.resolve(true);
+          }
+        }
+        const newFile = new TextFile(txtFile.fn, txtFile.text);
+        destServer.textFiles.push(newFile);
+        helpers.log(ctx, () => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
+        return Promise.resolve(true);
+      }
 
-        if (!isScriptFilename(source) && !source_is_txt)
-          throw ctx.makeRuntimeErrorMsg(`'mv' can only be used on scripts and text files (.txt)`);
-        if (source_is_txt != dest_is_txt)
-          throw ctx.makeRuntimeErrorMsg(`Source and destination files must have the same type`);
+      // Scp for script files
+      let sourceScript = null;
+      for (let i = 0; i < currServ.scripts.length; ++i) {
+        if (scriptName == currServ.scripts[i].filename) {
+          sourceScript = currServ.scripts[i];
+          break;
+        }
+      }
+      if (sourceScript == null) {
+        helpers.log(ctx, () => `File '${scriptName}' does not exist.`);
+        return Promise.resolve(false);
+      }
 
-        if (source === destination) {
+      // Overwrite script if it already exists
+      for (let i = 0; i < destServer.scripts.length; ++i) {
+        if (scriptName == destServer.scripts[i].filename) {
+          helpers.log(ctx, () => `WARNING: File '${scriptName}' overwritten on '${destServer?.hostname}'`);
+          const oldScript = destServer.scripts[i];
+          // If it's the exact same file don't actually perform the
+          // copy to avoid recompiling uselessly. Players tend to scp
+          // liberally.
+          if (oldScript.code === sourceScript.code) return Promise.resolve(true);
+          oldScript.code = sourceScript.code;
+          oldScript.ramUsage = sourceScript.ramUsage;
+          oldScript.markUpdated();
+          return Promise.resolve(true);
+        }
+      }
+
+      // Create new script if it does not already exist
+      const newScript = new Script(Player, scriptName);
+      newScript.code = sourceScript.code;
+      newScript.ramUsage = sourceScript.ramUsage;
+      newScript.server = destServer.hostname;
+      destServer.scripts.push(newScript);
+      helpers.log(ctx, () => `File '${scriptName}' copied over to '${destServer?.hostname}'.`);
+      return new Promise((resolve) => {
+        if (destServer === null) {
+          resolve(false);
           return;
         }
+        newScript.updateRamUsage(Player, destServer.scripts).then(() => resolve(true));
+      });
+    },
+  ls:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown, _grep: unknown = ""): string[] => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const grep = helpers.string(ctx, "grep", _grep);
 
-        // This will throw if the server is not found, we do not need to validate result.
-        const destServer: BaseServer | null = safeGetServer(host, ctx);
+      const server = helpers.getServer(ctx, hostname);
 
-        if (!source_is_txt && destServer.isRunning(source))
-          throw ctx.makeRuntimeErrorMsg(`Cannot use 'mv' on a script that is running`);
-
-        interface File {
-          filename: string;
-        }
-
-        const files = source_is_txt ? destServer.textFiles : destServer.scripts;
-        let source_file: File | null = null;
-        let dest_file: File | null = null;
-
-        for (let i = 0; i < files.length; ++i) {
-          const file = files[i];
-          if (file.filename === source) {
-            source_file = file;
-          } else if (file.filename === destination) {
-            dest_file = file;
-          }
-        }
-
-        if (source_file == null) throw ctx.makeRuntimeErrorMsg(`Source file ${source} does not exist`);
-
-        if (dest_file != null) {
-          if (dest_file instanceof TextFile && source_file instanceof TextFile) {
-            dest_file.text = source_file.text;
-          } else if (dest_file instanceof Script && source_file instanceof Script) {
-            dest_file.code = source_file.code;
-            dest_file.markUpdated();
-          }
-
-          destServer.removeFile(source);
-        } else {
-          source_file.filename = destination;
-          if (source_file instanceof Script) {
-            source_file.markUpdated();
-          }
-        }
-      },
-    flags: Flags(workerScript.args.map((a) => String(a))),
-  };
-
-  // add undocumented functions
-  const ns = {
-    ...base,
-    ...NetscriptExtra(Player),
-  };
-  function getFunctionNames(obj: object, prefix: string): string[] {
-    const functionNames: string[] = [];
-    for (const [key, value] of Object.entries(obj)) {
-      if (key === "args") {
-        continue;
-      } else if (typeof value == "function") {
-        functionNames.push(prefix + key);
-      } else if (typeof value == "object") {
-        functionNames.push(...getFunctionNames(value, key + "."));
+      // Get the grep filter, if one exists
+      let filter = "";
+      if (_grep !== undefined) {
+        filter = grep.toString();
       }
+
+      const allFiles = [];
+      for (let i = 0; i < server.programs.length; i++) {
+        if (filter) {
+          if (server.programs[i].includes(filter)) {
+            allFiles.push(server.programs[i]);
+          }
+        } else {
+          allFiles.push(server.programs[i]);
+        }
+      }
+      for (let i = 0; i < server.scripts.length; i++) {
+        if (filter) {
+          if (server.scripts[i].filename.includes(filter)) {
+            allFiles.push(server.scripts[i].filename);
+          }
+        } else {
+          allFiles.push(server.scripts[i].filename);
+        }
+      }
+      for (let i = 0; i < server.messages.length; i++) {
+        if (filter) {
+          const msg = server.messages[i];
+          if (msg.includes(filter)) {
+            allFiles.push(msg);
+          }
+        } else {
+          allFiles.push(server.messages[i]);
+        }
+      }
+
+      for (let i = 0; i < server.textFiles.length; i++) {
+        if (filter) {
+          if (server.textFiles[i].fn.includes(filter)) {
+            allFiles.push(server.textFiles[i].fn);
+          }
+        } else {
+          allFiles.push(server.textFiles[i].fn);
+        }
+      }
+
+      for (let i = 0; i < server.contracts.length; ++i) {
+        if (filter) {
+          if (server.contracts[i].fn.includes(filter)) {
+            allFiles.push(server.contracts[i].fn);
+          }
+        } else {
+          allFiles.push(server.contracts[i].fn);
+        }
+      }
+
+      // Sort the files alphabetically then print each
+      allFiles.sort();
+      return allFiles;
+    },
+  getRecentScripts: () => (): IRecentScript[] => {
+    return recentScripts.map((rs) => ({
+      timeOfDeath: rs.timeOfDeath,
+      ...helpers.createPublicRunningScript(rs.runningScript),
+    }));
+  },
+  ps:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname): ProcessInfo[] => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      const processes = [];
+      for (const script of server.runningScripts) {
+        processes.push({
+          filename: script.filename,
+          threads: script.threads,
+          args: script.args.slice(),
+          pid: script.pid,
+        });
+      }
+      return processes;
+    },
+  hasRootAccess:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+
+      const server = helpers.getServer(ctx, hostname);
+      return server.hasAdminRights;
+    },
+  getHostname: (ctx: NetscriptContext) => (): string => {
+    const scriptServer = GetServer(ctx.workerScript.hostname);
+    if (scriptServer == null) {
+      throw helpers.makeRuntimeErrorMsg(ctx, "Could not find server. This is a bug. Report to dev.");
     }
-    return functionNames;
-  }
+    return scriptServer.hostname;
+  },
+  getHackingLevel: (ctx: NetscriptContext) => (): number => {
+    Player.updateSkillLevels();
+    helpers.log(ctx, () => `returned ${Player.skills.hacking}`);
+    return Player.skills.hacking;
+  },
+  getHackingMultipliers: () => (): HackingMultipliers => {
+    return {
+      chance: Player.mults.hacking_chance,
+      speed: Player.mults.hacking_speed,
+      money: Player.mults.hacking_money,
+      growth: Player.mults.hacking_grow,
+    };
+  },
+  getHacknetMultipliers: () => (): HacknetMultipliers => {
+    return {
+      production: Player.mults.hacknet_node_money,
+      purchaseCost: Player.mults.hacknet_node_purchase_cost,
+      ramCost: Player.mults.hacknet_node_ram_cost,
+      coreCost: Player.mults.hacknet_node_core_cost,
+      levelCost: Player.mults.hacknet_node_level_cost,
+    };
+  },
+  getBitNodeMultipliers: (ctx: NetscriptContext) => (): IBNMults => {
+    if (Player.sourceFileLvl(5) <= 0 && Player.bitNodeN !== 5) {
+      throw helpers.makeRuntimeErrorMsg(ctx, "Requires Source-File 5 to run.");
+    }
+    const copy = Object.assign({}, BitNodeMultipliers);
+    return copy;
+  },
+  getServer:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname): IServerDef => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      const copy = Object.assign({}, server) as Server;
+      // These fields should be hidden.
+      copy.contracts = [];
+      copy.messages = [];
+      copy.runningScripts = [];
+      copy.scripts = [];
+      copy.textFiles = [];
+      copy.programs = [];
+      copy.serversOnNetwork = [];
+      if (!copy.baseDifficulty) copy.baseDifficulty = 0;
+      if (!copy.hackDifficulty) copy.hackDifficulty = 0;
+      if (!copy.minDifficulty) copy.minDifficulty = 0;
+      if (!copy.moneyAvailable) copy.moneyAvailable = 0;
+      if (!copy.moneyMax) copy.moneyMax = 0;
+      if (!copy.numOpenPortsRequired) copy.numOpenPortsRequired = 0;
+      if (!copy.openPortCount) copy.openPortCount = 0;
+      if (!copy.requiredHackingSkill) copy.requiredHackingSkill = 0;
+      if (!copy.serverGrowth) copy.serverGrowth = 0;
+      return copy;
+    },
+  getServerMoneyAvailable:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 0;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerMoneyAvailable")) {
+        return 0;
+      }
+      if (server.hostname == "home") {
+        // Return player's money
+        helpers.log(ctx, () => `returned player's money: ${numeralWrapper.formatMoney(Player.money)}`);
+        return Player.money;
+      }
+      helpers.log(ctx, () => `returned ${numeralWrapper.formatMoney(server.moneyAvailable)} for '${server.hostname}'`);
+      return server.moneyAvailable;
+    },
+  getServerSecurityLevel:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 1;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerSecurityLevel")) {
+        return 1;
+      }
+      helpers.log(
+        ctx,
+        () => `returned ${numeralWrapper.formatServerSecurity(server.hackDifficulty)} for '${server.hostname}'`,
+      );
+      return server.hackDifficulty;
+    },
+  getServerBaseSecurityLevel:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      helpers.log(ctx, () => `getServerBaseSecurityLevel is deprecated because it's not useful.`);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 1;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerBaseSecurityLevel")) {
+        return 1;
+      }
+      helpers.log(
+        ctx,
+        () => `returned ${numeralWrapper.formatServerSecurity(server.baseDifficulty)} for '${server.hostname}'`,
+      );
+      return server.baseDifficulty;
+    },
+  getServerMinSecurityLevel:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 1;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerMinSecurityLevel")) {
+        return 1;
+      }
+      helpers.log(
+        ctx,
+        () => `returned ${numeralWrapper.formatServerSecurity(server.minDifficulty)} for ${server.hostname}`,
+      );
+      return server.minDifficulty;
+    },
+  getServerRequiredHackingLevel:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 1;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerRequiredHackingLevel")) {
+        return 1;
+      }
+      helpers.log(
+        ctx,
+        () => `returned ${numeralWrapper.formatSkill(server.requiredHackingSkill)} for '${server.hostname}'`,
+      );
+      return server.requiredHackingSkill;
+    },
+  getServerMaxMoney:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 0;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerMaxMoney")) {
+        return 0;
+      }
+      helpers.log(ctx, () => `returned ${numeralWrapper.formatMoney(server.moneyMax)} for '${server.hostname}'`);
+      return server.moneyMax;
+    },
+  getServerGrowth:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 1;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerGrowth")) {
+        return 1;
+      }
+      helpers.log(ctx, () => `returned ${server.serverGrowth} for '${server.hostname}'`);
+      return server.serverGrowth;
+    },
+  getServerNumPortsRequired:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "Cannot be executed on this server.");
+        return 5;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getServerNumPortsRequired")) {
+        return 5;
+      }
+      helpers.log(ctx, () => `returned ${server.numOpenPortsRequired} for '${server.hostname}'`);
+      return server.numOpenPortsRequired;
+    },
+  getServerRam:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): [number, number] => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      helpers.log(ctx, () => `getServerRam is deprecated in favor of getServerMaxRam / getServerUsedRam`);
+      const server = helpers.getServer(ctx, hostname);
+      helpers.log(
+        ctx,
+        () => `returned [${numeralWrapper.formatRAM(server.maxRam)}, ${numeralWrapper.formatRAM(server.ramUsed)}]`,
+      );
+      return [server.maxRam, server.ramUsed];
+    },
+  getServerMaxRam:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      helpers.log(ctx, () => `returned ${numeralWrapper.formatRAM(server.maxRam)}`);
+      return server.maxRam;
+    },
+  getServerUsedRam:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      helpers.log(ctx, () => `returned ${numeralWrapper.formatRAM(server.ramUsed)}`);
+      return server.ramUsed;
+    },
+  serverExists:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown): boolean => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      return GetServer(hostname) !== null;
+    },
+  fileExists:
+    (ctx: NetscriptContext) =>
+    (_filename: unknown, _hostname: unknown = ctx.workerScript.hostname): boolean => {
+      const filename = helpers.string(ctx, "filename", _filename);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      if (filename === undefined) {
+        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: fileExists(scriptname, [server])");
+      }
+      const server = helpers.getServer(ctx, hostname);
+      for (let i = 0; i < server.scripts.length; ++i) {
+        if (filename == server.scripts[i].filename) {
+          return true;
+        }
+      }
+      for (let i = 0; i < server.programs.length; ++i) {
+        if (filename.toLowerCase() == server.programs[i].toLowerCase()) {
+          return true;
+        }
+      }
+      for (let i = 0; i < server.messages.length; ++i) {
+        if (filename.toLowerCase() === server.messages[i].toLowerCase()) {
+          return true;
+        }
+      }
+      const txtFile = getTextFile(filename, server);
+      return txtFile != null;
+    },
+  isRunning:
+    (ctx: NetscriptContext) =>
+    (fn: unknown, hostname: unknown, ...scriptArgs: unknown[]): boolean => {
+      const ident = helpers.scriptIdentifier(ctx, fn, hostname, scriptArgs);
+      return helpers.getRunningScript(ctx, ident) !== null;
+    },
+  getPurchasedServerLimit: () => (): number => {
+    return getPurchaseServerLimit();
+  },
+  getPurchasedServerMaxRam: () => (): number => {
+    return getPurchaseServerMaxRam();
+  },
+  getPurchasedServerCost:
+    (ctx: NetscriptContext) =>
+    (_ram: unknown): number => {
+      const ram = helpers.number(ctx, "ram", _ram);
 
-  const possibleLogs = Object.fromEntries([...getFunctionNames(ns, "")].map((a) => [a, true]));
+      const cost = getPurchaseServerCost(ram);
+      if (cost === Infinity) {
+        helpers.log(ctx, () => `Invalid argument: ram='${ram}'`);
+        return Infinity;
+      }
 
-  const wrappedNS = wrapAPI(helper, {}, workerScript, ns) as unknown as INS;
-  (wrappedNS as any).args = ns.args;
-  (wrappedNS as any).enums = ns.enums;
-  return wrappedNS;
-}
+      return cost;
+    },
+  purchaseServer:
+    (ctx: NetscriptContext) =>
+    (_name: unknown, _ram: unknown): string => {
+      const name = helpers.string(ctx, "name", _name);
+      const ram = helpers.number(ctx, "ram", _ram);
+      let hostnameStr = String(name);
+      hostnameStr = hostnameStr.replace(/\s+/g, "");
+      if (hostnameStr == "") {
+        helpers.log(ctx, () => `Invalid argument: hostname='${hostnameStr}'`);
+        return "";
+      }
+
+      if (Player.purchasedServers.length >= getPurchaseServerLimit()) {
+        helpers.log(
+          ctx,
+          () =>
+            `You have reached the maximum limit of ${getPurchaseServerLimit()} servers. You cannot purchase any more.`,
+        );
+        return "";
+      }
+
+      const cost = getPurchaseServerCost(ram);
+      if (cost === Infinity) {
+        if (ram > getPurchaseServerMaxRam()) {
+          helpers.log(ctx, () => `Invalid argument: ram='${ram}' must not be greater than getPurchaseServerMaxRam`);
+        } else {
+          helpers.log(ctx, () => `Invalid argument: ram='${ram}' must be a positive power of 2`);
+        }
+
+        return "";
+      }
+
+      if (Player.money < cost) {
+        helpers.log(ctx, () => `Not enough money to purchase server. Need ${numeralWrapper.formatMoney(cost)}`);
+        return "";
+      }
+      const newServ = safetlyCreateUniqueServer({
+        ip: createUniqueRandomIp(),
+        hostname: hostnameStr,
+        organizationName: "",
+        isConnectedTo: false,
+        adminRights: true,
+        purchasedByPlayer: true,
+        maxRam: ram,
+      });
+      AddToAllServers(newServ);
+
+      Player.purchasedServers.push(newServ.hostname);
+      const homeComputer = Player.getHomeComputer();
+      homeComputer.serversOnNetwork.push(newServ.hostname);
+      newServ.serversOnNetwork.push(homeComputer.hostname);
+      Player.loseMoney(cost, "servers");
+      helpers.log(
+        ctx,
+        () => `Purchased new server with hostname '${newServ.hostname}' for ${numeralWrapper.formatMoney(cost)}`,
+      );
+      return newServ.hostname;
+    },
+  deleteServer:
+    (ctx: NetscriptContext) =>
+    (_name: unknown): boolean => {
+      const name = helpers.string(ctx, "name", _name);
+      let hostnameStr = String(name);
+      hostnameStr = hostnameStr.replace(/\s\s+/g, "");
+      const server = GetServer(hostnameStr);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => `Invalid argument: hostname='${hostnameStr}'`);
+        return false;
+      }
+
+      if (!server.purchasedByPlayer || server.hostname === "home") {
+        helpers.log(ctx, () => "Cannot delete non-purchased server.");
+        return false;
+      }
+
+      const hostname = server.hostname;
+
+      // Can't delete server you're currently connected to
+      if (server.isConnectedTo) {
+        helpers.log(ctx, () => "You are currently connected to the server you are trying to delete.");
+        return false;
+      }
+
+      // A server cannot delete itself
+      if (hostname === ctx.workerScript.hostname) {
+        helpers.log(ctx, () => "Cannot delete the server this script is running on.");
+        return false;
+      }
+
+      // Delete all scripts running on server
+      if (server.runningScripts.length > 0) {
+        helpers.log(ctx, () => `Cannot delete server '${hostname}' because it still has scripts running.`);
+        return false;
+      }
+
+      // Delete from player's purchasedServers array
+      let found = false;
+      for (let i = 0; i < Player.purchasedServers.length; ++i) {
+        if (hostname == Player.purchasedServers[i]) {
+          found = true;
+          Player.purchasedServers.splice(i, 1);
+          break;
+        }
+      }
+
+      if (!found) {
+        helpers.log(
+          ctx,
+          () => `Could not identify server ${hostname} as a purchased server. This is a bug. Report to dev.`,
+        );
+        return false;
+      }
+
+      // Delete from all servers
+      DeleteServer(hostname);
+
+      // Delete from home computer
+      found = false;
+      const homeComputer = Player.getHomeComputer();
+      for (let i = 0; i < homeComputer.serversOnNetwork.length; ++i) {
+        if (hostname == homeComputer.serversOnNetwork[i]) {
+          homeComputer.serversOnNetwork.splice(i, 1);
+          helpers.log(ctx, () => `Deleted server '${hostnameStr}`);
+          return true;
+        }
+      }
+      // Wasn't found on home computer
+      helpers.log(ctx, () => `Could not find server ${hostname} as a purchased server. This is a bug. Report to dev.`);
+      return false;
+    },
+  getPurchasedServers: () => (): string[] => {
+    const res: string[] = [];
+    Player.purchasedServers.forEach(function (hostname) {
+      res.push(hostname);
+    });
+    return res;
+  },
+  writePort:
+    (ctx: NetscriptContext) =>
+    (_port: unknown, data: unknown = ""): Promise<any> => {
+      const port = helpers.number(ctx, "port", _port);
+      if (typeof data !== "string" && typeof data !== "number") {
+        throw helpers.makeRuntimeErrorMsg(
+          ctx,
+          `Trying to write invalid data to a port: only strings and numbers are valid.`,
+        );
+      }
+      const iport = helpers.getValidPort(ctx, port);
+      return Promise.resolve(iport.write(data));
+    },
+  write:
+    (ctx: NetscriptContext) =>
+    (_port: unknown, data: unknown = "", _mode: unknown = "a"): Promise<void> => {
+      const port = helpers.string(ctx, "port", _port);
+      const mode = helpers.string(ctx, "mode", _mode);
+      if (isString(port)) {
+        // Write to script or text file
+        let fn = port;
+        if (!isValidFilePath(fn)) {
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filepath: ${fn}`);
+        }
+
+        if (fn.lastIndexOf("/") === 0) {
+          fn = removeLeadingSlash(fn);
+        }
+
+        // Coerce 'data' to be a string
+        try {
+          data = String(data);
+        } catch (e: unknown) {
+          throw helpers.makeRuntimeErrorMsg(
+            ctx,
+            `Invalid data (${String(e)}). Data being written must be convertible to a string`,
+          );
+        }
+
+        const server = ctx.workerScript.getServer();
+        if (server == null) {
+          throw helpers.makeRuntimeErrorMsg(ctx, "Error getting Server. This is a bug. Report to dev.");
+        }
+        if (isScriptFilename(fn)) {
+          // Write to script
+          let script = ctx.workerScript.getScriptOnServer(fn, server);
+          if (script == null) {
+            // Create a new script
+            script = new Script(Player, fn, String(data), server.hostname, server.scripts);
+            server.scripts.push(script);
+            return script.updateRamUsage(Player, server.scripts);
+          }
+          mode === "w" ? (script.code = String(data)) : (script.code += data);
+          return script.updateRamUsage(Player, server.scripts);
+        } else {
+          // Write to text file
+          const txtFile = getTextFile(fn, server);
+          if (txtFile == null) {
+            createTextFile(fn, String(data), server);
+            return Promise.resolve();
+          }
+          if (mode === "w") {
+            txtFile.write(String(data));
+          } else {
+            txtFile.append(String(data));
+          }
+        }
+        return Promise.resolve();
+      } else {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${port}`);
+      }
+    },
+  tryWritePort:
+    (ctx: NetscriptContext) =>
+    (_port: unknown, data: unknown = ""): Promise<any> => {
+      let port = helpers.number(ctx, "port", _port);
+      if (typeof data !== "string" && typeof data !== "number") {
+        throw helpers.makeRuntimeErrorMsg(
+          ctx,
+          `Trying to write invalid data to a port: only strings and numbers are valid.`,
+        );
+      }
+      if (!isNaN(port)) {
+        port = Math.round(port);
+        if (port < 1 || port > CONSTANTS.NumNetscriptPorts) {
+          throw helpers.makeRuntimeErrorMsg(
+            ctx,
+            `Invalid port: ${port}. Only ports 1-${CONSTANTS.NumNetscriptPorts} are valid.`,
+          );
+        }
+        const iport = NetscriptPorts[port - 1];
+        if (iport == null || !(iport instanceof Object)) {
+          throw helpers.makeRuntimeErrorMsg(ctx, `Could not find port: ${port}. This is a bug. Report to dev.`);
+        }
+        return Promise.resolve(iport.tryWrite(data));
+      } else {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${port}`);
+      }
+    },
+  readPort:
+    (ctx: NetscriptContext) =>
+    (_port: unknown): unknown => {
+      const port = helpers.number(ctx, "port", _port);
+      // Read from port
+      const iport = helpers.getValidPort(ctx, port);
+      const x = iport.read();
+      return x;
+    },
+  read:
+    (ctx: NetscriptContext) =>
+    (_port: unknown): string => {
+      const port = helpers.string(ctx, "port", _port);
+      if (isString(port)) {
+        // Read from script or text file
+        const fn = port;
+        const server = GetServer(ctx.workerScript.hostname);
+        if (server == null) {
+          throw helpers.makeRuntimeErrorMsg(ctx, "Error getting Server. This is a bug. Report to dev.");
+        }
+        if (isScriptFilename(fn)) {
+          // Read from script
+          const script = ctx.workerScript.getScriptOnServer(fn, server);
+          if (script == null) {
+            return "";
+          }
+          return script.code;
+        } else {
+          // Read from text file
+          const txtFile = getTextFile(fn, server);
+          if (txtFile !== null) {
+            return txtFile.text;
+          } else {
+            return "";
+          }
+        }
+      } else {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${port}`);
+      }
+    },
+  peek:
+    (ctx: NetscriptContext) =>
+    (_port: unknown): unknown => {
+      const port = helpers.number(ctx, "port", _port);
+      const iport = helpers.getValidPort(ctx, port);
+      const x = iport.peek();
+      return x;
+    },
+  clear:
+    (ctx: NetscriptContext) =>
+    (_file: unknown): void => {
+      const file = helpers.string(ctx, "file", _file);
+      if (isString(file)) {
+        // Clear text file
+        const fn = file;
+        const server = GetServer(ctx.workerScript.hostname);
+        if (server == null) {
+          throw helpers.makeRuntimeErrorMsg(ctx, "Error getting Server. This is a bug. Report to dev.");
+        }
+        const txtFile = getTextFile(fn, server);
+        if (txtFile != null) {
+          txtFile.write("");
+        }
+      } else {
+        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${file}`);
+      }
+    },
+  clearPort:
+    (ctx: NetscriptContext) =>
+    (_port: unknown): void => {
+      const port = helpers.number(ctx, "port", _port);
+      // Clear port
+      const iport = helpers.getValidPort(ctx, port);
+      iport.clear();
+    },
+  getPortHandle:
+    (ctx: NetscriptContext) =>
+    (_port: unknown): IPort => {
+      const port = helpers.number(ctx, "port", _port);
+      const iport = helpers.getValidPort(ctx, port);
+      return iport;
+    },
+  rm:
+    (ctx: NetscriptContext) =>
+    (_fn: unknown, _hostname: unknown = ctx.workerScript.hostname): boolean => {
+      const fn = helpers.string(ctx, "fn", _fn);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const s = helpers.getServer(ctx, hostname);
+
+      const status = s.removeFile(fn);
+      if (!status.res) {
+        helpers.log(ctx, () => status.msg + "");
+      }
+
+      return status.res;
+    },
+  scriptRunning:
+    (ctx: NetscriptContext) =>
+    (_scriptname: unknown, _hostname: unknown): boolean => {
+      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      for (let i = 0; i < server.runningScripts.length; ++i) {
+        if (server.runningScripts[i].filename == scriptname) {
+          return true;
+        }
+      }
+      return false;
+    },
+  scriptKill:
+    (ctx: NetscriptContext) =>
+    (_scriptname: unknown, _hostname: unknown): boolean => {
+      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      let suc = false;
+      for (let i = 0; i < server.runningScripts.length; i++) {
+        if (server.runningScripts[i].filename == scriptname) {
+          killWorkerScript({ runningScript: server.runningScripts[i], hostname: server.hostname });
+          suc = true;
+          i--;
+        }
+      }
+      return suc;
+    },
+  getScriptName: (ctx: NetscriptContext) => (): string => {
+    return ctx.workerScript.name;
+  },
+  getScriptRam:
+    (ctx: NetscriptContext) =>
+    (_scriptname: unknown, _hostname: unknown = ctx.workerScript.hostname): number => {
+      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      for (let i = 0; i < server.scripts.length; ++i) {
+        if (server.scripts[i].filename == scriptname) {
+          return server.scripts[i].ramUsage;
+        }
+      }
+      return 0;
+    },
+  getRunningScript:
+    (ctx: NetscriptContext) =>
+    (fn: unknown, hostname: unknown, ...args: unknown[]): IRunningScriptDef | null => {
+      const ident = helpers.scriptIdentifier(ctx, fn, hostname, args);
+      const runningScript = helpers.getRunningScript(ctx, ident);
+      if (runningScript === null) return null;
+      return helpers.createPublicRunningScript(runningScript);
+    },
+  getHackTime:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "invalid for this kind of server");
+        return Infinity;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getHackTime")) {
+        return Infinity;
+      }
+
+      return calculateHackingTime(server, Player) * 1000;
+    },
+  getGrowTime:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "invalid for this kind of server");
+        return Infinity;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getGrowTime")) {
+        return Infinity;
+      }
+
+      return calculateGrowTime(server, Player) * 1000;
+    },
+  getWeakenTime:
+    (ctx: NetscriptContext) =>
+    (_hostname: unknown = ctx.workerScript.hostname): number => {
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      const server = helpers.getServer(ctx, hostname);
+      if (!(server instanceof Server)) {
+        helpers.log(ctx, () => "invalid for this kind of server");
+        return Infinity;
+      }
+      if (helpers.failOnHacknetServer(ctx, server, "getWeakenTime")) {
+        return Infinity;
+      }
+
+      return calculateWeakenTime(server, Player) * 1000;
+    },
+  getTotalScriptIncome: () => (): [number, number] => {
+    // First element is total income of all currently running scripts
+    let total = 0;
+    for (const script of workerScripts.values()) {
+      total += script.scriptRef.onlineMoneyMade / script.scriptRef.onlineRunningTime;
+    }
+
+    return [total, Player.scriptProdSinceLastAug / (Player.playtimeSinceLastAug / 1000)];
+  },
+  getScriptIncome:
+    (ctx: NetscriptContext) =>
+    (fn: unknown, hostname: unknown, ...args: unknown[]): number => {
+      const ident = helpers.scriptIdentifier(ctx, fn, hostname, args);
+      const runningScript = helpers.getRunningScript(ctx, ident);
+      if (runningScript == null) {
+        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
+        return -1;
+      }
+      return runningScript.onlineMoneyMade / runningScript.onlineRunningTime;
+    },
+  getTotalScriptExpGain: () => (): number => {
+    let total = 0;
+    for (const ws of workerScripts.values()) {
+      total += ws.scriptRef.onlineExpGained / ws.scriptRef.onlineRunningTime;
+    }
+    return total;
+  },
+  getScriptExpGain:
+    (ctx: NetscriptContext) =>
+    (fn: unknown, hostname: unknown, ...args: unknown[]): number => {
+      const ident = helpers.scriptIdentifier(ctx, fn, hostname, args);
+      const runningScript = helpers.getRunningScript(ctx, ident);
+      if (runningScript == null) {
+        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
+        return -1;
+      }
+      return runningScript.onlineExpGained / runningScript.onlineRunningTime;
+    },
+  nFormat:
+    (ctx: NetscriptContext) =>
+    (_n: unknown, _format: unknown): string => {
+      const n = helpers.number(ctx, "n", _n);
+      const format = helpers.string(ctx, "format", _format);
+      if (isNaN(n)) {
+        return "";
+      }
+
+      return numeralWrapper.format(n, format);
+    },
+  tFormat:
+    (ctx: NetscriptContext) =>
+    (_milliseconds: unknown, _milliPrecision: unknown = false): string => {
+      const milliseconds = helpers.number(ctx, "milliseconds", _milliseconds);
+      const milliPrecision = !!_milliPrecision;
+      return convertTimeMsToTimeElapsedString(milliseconds, milliPrecision);
+    },
+  getTimeSinceLastAug: () => (): number => {
+    return Player.playtimeSinceLastAug;
+  },
+  alert:
+    (ctx: NetscriptContext) =>
+    (_message: unknown): void => {
+      const message = helpers.string(ctx, "message", _message);
+      dialogBoxCreate(message);
+    },
+  toast:
+    (ctx: NetscriptContext) =>
+    (_message: unknown, _variant: unknown = ToastVariant.SUCCESS, _duration: unknown = 2000): void => {
+      const message = helpers.string(ctx, "message", _message);
+      const variant = helpers.string(ctx, "variant", _variant);
+      const duration = helpers.number(ctx, "duration", _duration);
+      if (!checkEnum(ToastVariant, variant))
+        throw new Error(`variant must be one of ${Object.values(ToastVariant).join(", ")}`);
+      SnackbarEvents.emit(message, variant, duration);
+    },
+  prompt:
+    (ctx: NetscriptContext) =>
+    (_txt: unknown, options?: { type?: string; options?: string[] }): Promise<boolean | string> => {
+      const txt = helpers.string(ctx, "txt", _txt);
+
+      return new Promise(function (resolve) {
+        PromptEvent.emit({
+          txt: txt,
+          options,
+          resolve: resolve,
+        });
+      });
+    },
+  wget:
+    (ctx: NetscriptContext) =>
+    async (_url: unknown, _target: unknown, _hostname: unknown = ctx.workerScript.hostname): Promise<boolean> => {
+      const url = helpers.string(ctx, "url", _url);
+      const target = helpers.string(ctx, "target", _target);
+      const hostname = helpers.string(ctx, "hostname", _hostname);
+      if (!isScriptFilename(target) && !target.endsWith(".txt")) {
+        helpers.log(ctx, () => `Invalid target file: '${target}'. Must be a script or text file.`);
+        return Promise.resolve(false);
+      }
+      const s = helpers.getServer(ctx, hostname);
+      return new Promise(function (resolve) {
+        $.get(
+          url,
+          function (data) {
+            let res;
+            if (isScriptFilename(target)) {
+              res = s.writeToScriptFile(Player, target, data);
+            } else {
+              res = s.writeToTextFile(target, data);
+            }
+            if (!res.success) {
+              helpers.log(ctx, () => "Failed.");
+              return resolve(false);
+            }
+            if (res.overwritten) {
+              helpers.log(ctx, () => `Successfully retrieved content and overwrote '${target}' on '${hostname}'`);
+              return resolve(true);
+            }
+            helpers.log(ctx, () => `Successfully retrieved content to new file '${target}' on '${hostname}'`);
+            return resolve(true);
+          },
+          "text",
+        ).fail(function (e) {
+          helpers.log(ctx, () => JSON.stringify(e));
+          return resolve(false);
+        });
+      });
+    },
+  getFavorToDonate: () => (): number => {
+    return Math.floor(CONSTANTS.BaseFavorToDonate * BitNodeMultipliers.RepToDonateToFaction);
+  },
+  getPlayer: () => (): INetscriptPlayer => {
+    const data = {
+      hp: Player.hp,
+      skills: Player.skills,
+      exp: Player.exp,
+      hacking_chance_mult: Player.mults.hacking_chance,
+      mults: JSON.parse(JSON.stringify(Player.mults)),
+      numPeopleKilled: Player.numPeopleKilled,
+      money: Player.money,
+      city: Player.city,
+      location: Player.location,
+      bitNodeN: Player.bitNodeN,
+      totalPlaytime: Player.totalPlaytime,
+      playtimeSinceLastAug: Player.playtimeSinceLastAug,
+      playtimeSinceLastBitnode: Player.playtimeSinceLastBitnode,
+      jobs: {},
+      factions: Player.factions.slice(),
+      tor: Player.hasTorRouter(),
+      inBladeburner: Player.inBladeburner(),
+      hasCorporation: Player.hasCorporation(),
+      entropy: Player.entropy,
+    };
+    Object.assign(data.jobs, Player.jobs);
+    return data;
+  },
+  atExit:
+    (ctx: NetscriptContext) =>
+    (f: unknown): void => {
+      if (typeof f !== "function") {
+        throw helpers.makeRuntimeErrorMsg(ctx, "argument should be function");
+      }
+      ctx.workerScript.atExit = () => {
+        f();
+      }; // Wrap the user function to prevent WorkerScript leaking as 'this'
+    },
+  mv:
+    (ctx: NetscriptContext) =>
+    (_host: unknown, _source: unknown, _destination: unknown): void => {
+      const host = helpers.string(ctx, "host", _host);
+      const source = helpers.string(ctx, "source", _source);
+      const destination = helpers.string(ctx, "destination", _destination);
+
+      if (!isValidFilePath(source)) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: '${source}'`);
+      if (!isValidFilePath(destination)) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: '${destination}'`);
+
+      const source_is_txt = source.endsWith(".txt");
+      const dest_is_txt = destination.endsWith(".txt");
+
+      if (!isScriptFilename(source) && !source_is_txt)
+        throw helpers.makeRuntimeErrorMsg(ctx, `'mv' can only be used on scripts and text files (.txt)`);
+      if (source_is_txt != dest_is_txt)
+        throw helpers.makeRuntimeErrorMsg(ctx, `Source and destination files must have the same type`);
+
+      if (source === destination) {
+        return;
+      }
+
+      const destServer = helpers.getServer(ctx, host);
+
+      if (!source_is_txt && destServer.isRunning(source))
+        throw helpers.makeRuntimeErrorMsg(ctx, `Cannot use 'mv' on a script that is running`);
+
+      interface File {
+        filename: string;
+      }
+
+      const files = source_is_txt ? destServer.textFiles : destServer.scripts;
+      let source_file: File | null = null;
+      let dest_file: File | null = null;
+
+      for (let i = 0; i < files.length; ++i) {
+        const file = files[i];
+        if (file.filename === source) {
+          source_file = file;
+        } else if (file.filename === destination) {
+          dest_file = file;
+        }
+      }
+
+      if (source_file == null) throw helpers.makeRuntimeErrorMsg(ctx, `Source file ${source} does not exist`);
+
+      if (dest_file != null) {
+        if (dest_file instanceof TextFile && source_file instanceof TextFile) {
+          dest_file.text = source_file.text;
+        } else if (dest_file instanceof Script && source_file instanceof Script) {
+          dest_file.code = source_file.code;
+          dest_file.markUpdated();
+        }
+
+        destServer.removeFile(source);
+      } else {
+        source_file.filename = destination;
+        if (source_file instanceof Script) {
+          source_file.markUpdated();
+        }
+      }
+    },
+  flags: Flags,
+};
+
+// add undocumented functions
+const ns = {
+  ...base,
+  ...NetscriptExtra(),
+};
+
+const possibleLogs = Object.fromEntries([...helpers.getFunctionNames(ns, "")].map((a) => [a, true]));
diff --git a/src/NetscriptFunctions/Bladeburner.ts b/src/NetscriptFunctions/Bladeburner.ts
index d0ddc1677..efc5eaf23 100644
--- a/src/NetscriptFunctions/Bladeburner.ts
+++ b/src/NetscriptFunctions/Bladeburner.ts
@@ -1,13 +1,13 @@
-import { WorkerScript } from "../Netscript/WorkerScript";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { Bladeburner } from "../Bladeburner/Bladeburner";
 import { BitNodeMultipliers } from "../BitNode/BitNodeMultipliers";
 import { Bladeburner as INetscriptBladeburner, BladeburnerCurAction } from "../ScriptEditor/NetscriptDefinitions";
 import { IAction } from "src/Bladeburner/IAction";
 import { InternalAPI, NetscriptContext } from "src/Netscript/APIWrapper";
 import { BlackOperation } from "../Bladeburner/BlackOperation";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript): InternalAPI<INetscriptBladeburner> {
+export function NetscriptBladeburner(): InternalAPI<INetscriptBladeburner> {
   const checkBladeburnerAccess = function (ctx: NetscriptContext, skipjoined = false): void {
     const bladeburner = player.bladeburner;
     if (bladeburner === null) throw new Error("Must have joined bladeburner");
@@ -18,13 +18,13 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
       });
     if (!apiAccess) {
       const apiDenied = `You do not currently have access to the Bladeburner API. You must either be in BitNode-7 or have Source-File 7.`;
-      throw ctx.makeRuntimeErrorMsg(apiDenied);
+      throw helpers.makeRuntimeErrorMsg(ctx, apiDenied);
     }
     if (!skipjoined) {
       const bladeburnerAccess = bladeburner instanceof Bladeburner;
       if (!bladeburnerAccess) {
         const bladeburnerDenied = `You must be a member of the Bladeburner division to use this API.`;
-        throw ctx.makeRuntimeErrorMsg(bladeburnerDenied);
+        throw helpers.makeRuntimeErrorMsg(ctx, bladeburnerDenied);
       }
     }
   };
@@ -33,7 +33,7 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     const bladeburner = player.bladeburner;
     if (bladeburner === null) throw new Error("Must have joined bladeburner");
     if (!bladeburner.cities.hasOwnProperty(city)) {
-      throw ctx.makeRuntimeErrorMsg(`Invalid city: ${city}`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid city: ${city}`);
     }
   };
 
@@ -42,11 +42,11 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     if (bladeburner === null) throw new Error("Must have joined bladeburner");
     const actionId = bladeburner.getActionIdFromTypeAndName(type, name);
     if (!actionId) {
-      throw ctx.makeRuntimeErrorMsg(`Invalid action type='${type}', name='${name}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid action type='${type}', name='${name}'`);
     }
     const actionObj = bladeburner.getActionObject(actionId);
     if (!actionObj) {
-      throw ctx.makeRuntimeErrorMsg(`Invalid action type='${type}', name='${name}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid action type='${type}', name='${name}'`);
     }
 
     return actionObj;
@@ -74,7 +74,7 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getBlackOpRank:
       (ctx: NetscriptContext) =>
       (_blackOpName: unknown): number => {
-        const blackOpName = ctx.helper.string("blackOpName", _blackOpName);
+        const blackOpName = helpers.string(ctx, "blackOpName", _blackOpName);
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, "blackops", blackOpName);
         if (!(action instanceof BlackOperation)) throw new Error("action was not a black operation");
@@ -95,15 +95,15 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     startAction:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): boolean => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.startActionNetscriptFn(player, type, name, workerScript);
+          return bladeburner.startActionNetscriptFn(player, type, name, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     stopBladeburnerAction: (ctx: NetscriptContext) => (): void => {
@@ -121,8 +121,8 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getActionTime:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
@@ -130,13 +130,13 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
           const time = bladeburner.getActionTimeNetscriptFn(player, type, name);
           if (typeof time === "string") {
             const errorLogText = `Invalid action: type='${type}' name='${name}'`;
-            ctx.log(() => errorLogText);
+            helpers.log(ctx, () => errorLogText);
             return -1;
           } else {
             return time;
           }
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     getActionCurrentTime: (ctx: NetscriptContext) => (): number => {
@@ -149,14 +149,14 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
           1000;
         return timecomputed;
       } catch (e: unknown) {
-        throw ctx.makeRuntimeErrorMsg(String(e));
+        throw helpers.makeRuntimeErrorMsg(ctx, String(e));
       }
     },
     getActionEstimatedSuccessChance:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): [number, number] => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
@@ -164,21 +164,21 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
           const chance = bladeburner.getActionEstimatedSuccessChanceNetscriptFn(player, type, name);
           if (typeof chance === "string") {
             const errorLogText = `Invalid action: type='${type}' name='${name}'`;
-            ctx.log(() => errorLogText);
+            helpers.log(ctx, () => errorLogText);
             return [-1, -1];
           } else {
             return chance;
           }
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     getActionRepGain:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown, _level: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
-        const level = ctx.helper.number("level", _level);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
+        const level = helpers.number(ctx, "level", _level);
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, type, name);
         let rewardMultiplier;
@@ -193,22 +193,22 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getActionCountRemaining:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.getActionCountRemainingNetscriptFn(type, name, workerScript);
+          return bladeburner.getActionCountRemainingNetscriptFn(type, name, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     getActionMaxLevel:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, type, name);
         return action.maxLevel;
@@ -216,8 +216,8 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getActionCurrentLevel:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, type, name);
         return action.level;
@@ -225,8 +225,8 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getActionAutolevel:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): boolean => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, type, name);
         return action.autoLevel;
@@ -234,9 +234,9 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     setActionAutolevel:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown, _autoLevel: unknown = true): void => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
-        const autoLevel = ctx.helper.boolean(_autoLevel);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
+        const autoLevel = !!_autoLevel;
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, type, name);
         action.autoLevel = autoLevel;
@@ -244,13 +244,13 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     setActionLevel:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown, _level: unknown = 1): void => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
-        const level = ctx.helper.number("level", _level);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
+        const level = helpers.number(ctx, "level", _level);
         checkBladeburnerAccess(ctx);
         const action = getBladeburnerActionObject(ctx, type, name);
         if (level < 1 || level > action.maxLevel) {
-          ctx.helper.makeRuntimeErrorMsg(`Level must be between 1 and ${action.maxLevel}, is ${level}`);
+          helpers.makeRuntimeErrorMsg(ctx, `Level must be between 1 and ${action.maxLevel}, is ${level}`);
         }
         action.level = level;
       },
@@ -269,77 +269,77 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getSkillLevel:
       (ctx: NetscriptContext) =>
       (_skillName: unknown): number => {
-        const skillName = ctx.helper.string("skillName", _skillName);
+        const skillName = helpers.string(ctx, "skillName", _skillName);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.getSkillLevelNetscriptFn(skillName, workerScript);
+          return bladeburner.getSkillLevelNetscriptFn(skillName, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     getSkillUpgradeCost:
       (ctx: NetscriptContext) =>
       (_skillName: unknown, _count: unknown = 1): number => {
-        const skillName = ctx.helper.string("skillName", _skillName);
-        const count = ctx.helper.number("count", _count);
+        const skillName = helpers.string(ctx, "skillName", _skillName);
+        const count = helpers.number(ctx, "count", _count);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.getSkillUpgradeCostNetscriptFn(skillName, count, workerScript);
+          return bladeburner.getSkillUpgradeCostNetscriptFn(skillName, count, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     upgradeSkill:
       (ctx: NetscriptContext) =>
       (_skillName: unknown, _count: unknown = 1): boolean => {
-        const skillName = ctx.helper.string("skillName", _skillName);
-        const count = ctx.helper.number("count", _count);
+        const skillName = helpers.string(ctx, "skillName", _skillName);
+        const count = helpers.number(ctx, "count", _count);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.upgradeSkillNetscriptFn(skillName, count, workerScript);
+          return bladeburner.upgradeSkillNetscriptFn(skillName, count, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     getTeamSize:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.getTeamSizeNetscriptFn(type, name, workerScript);
+          return bladeburner.getTeamSizeNetscriptFn(type, name, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     setTeamSize:
       (ctx: NetscriptContext) =>
       (_type: unknown, _name: unknown, _size: unknown): number => {
-        const type = ctx.helper.string("type", _type);
-        const name = ctx.helper.string("name", _name);
-        const size = ctx.helper.number("size", _size);
+        const type = helpers.string(ctx, "type", _type);
+        const name = helpers.string(ctx, "name", _name);
+        const size = helpers.number(ctx, "size", _size);
         checkBladeburnerAccess(ctx);
         const bladeburner = player.bladeburner;
         if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
         try {
-          return bladeburner.setTeamSizeNetscriptFn(type, name, size, workerScript);
+          return bladeburner.setTeamSizeNetscriptFn(type, name, size, ctx.workerScript);
         } catch (e: unknown) {
-          throw ctx.makeRuntimeErrorMsg(String(e));
+          throw helpers.makeRuntimeErrorMsg(ctx, String(e));
         }
       },
     getCityEstimatedPopulation:
       (ctx: NetscriptContext) =>
       (_cityName: unknown): number => {
-        const cityName = ctx.helper.string("cityName", _cityName);
+        const cityName = helpers.string(ctx, "cityName", _cityName);
         checkBladeburnerAccess(ctx);
         checkBladeburnerCity(ctx, cityName);
         const bladeburner = player.bladeburner;
@@ -349,7 +349,7 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getCityCommunities:
       (ctx: NetscriptContext) =>
       (_cityName: unknown): number => {
-        const cityName = ctx.helper.string("cityName", _cityName);
+        const cityName = helpers.string(ctx, "cityName", _cityName);
         checkBladeburnerAccess(ctx);
         checkBladeburnerCity(ctx, cityName);
         const bladeburner = player.bladeburner;
@@ -359,7 +359,7 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     getCityChaos:
       (ctx: NetscriptContext) =>
       (_cityName: unknown): number => {
-        const cityName = ctx.helper.string("cityName", _cityName);
+        const cityName = helpers.string(ctx, "cityName", _cityName);
         checkBladeburnerAccess(ctx);
         checkBladeburnerCity(ctx, cityName);
         const bladeburner = player.bladeburner;
@@ -375,7 +375,7 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
     switchCity:
       (ctx: NetscriptContext) =>
       (_cityName: unknown): boolean => {
-        const cityName = ctx.helper.string("cityName", _cityName);
+        const cityName = helpers.string(ctx, "cityName", _cityName);
         checkBladeburnerAccess(ctx);
         checkBladeburnerCity(ctx, cityName);
         const bladeburner = player.bladeburner;
@@ -393,7 +393,7 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
       checkBladeburnerAccess(ctx, true);
       const bladeburner = player.bladeburner;
       if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
-      return bladeburner.joinBladeburnerFactionNetscriptFn(workerScript);
+      return bladeburner.joinBladeburnerFactionNetscriptFn(ctx.workerScript);
     },
     joinBladeburnerDivision: (ctx: NetscriptContext) => (): boolean => {
       if (player.bitNodeN === 7 || player.sourceFileLvl(7) > 0) {
@@ -409,11 +409,11 @@ export function NetscriptBladeburner(player: IPlayer, workerScript: WorkerScript
           player.skills.agility >= 100
         ) {
           player.bladeburner = new Bladeburner(player);
-          ctx.log(() => "You have been accepted into the Bladeburner division");
+          helpers.log(ctx, () => "You have been accepted into the Bladeburner division");
 
           return true;
         } else {
-          ctx.log(() => "You do not meet the requirements for joining the Bladeburner division");
+          helpers.log(ctx, () => "You do not meet the requirements for joining the Bladeburner division");
           return false;
         }
       }
diff --git a/src/NetscriptFunctions/CodingContract.ts b/src/NetscriptFunctions/CodingContract.ts
index 77afb7f22..785f0e9f8 100644
--- a/src/NetscriptFunctions/CodingContract.ts
+++ b/src/NetscriptFunctions/CodingContract.ts
@@ -1,21 +1,21 @@
-import { WorkerScript } from "../Netscript/WorkerScript";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { is2DArray } from "../utils/helpers/is2DArray";
 import { CodingContract } from "../CodingContracts";
 import { CodingAttemptOptions, CodingContract as ICodingContract } from "../ScriptEditor/NetscriptDefinitions";
-import { InternalAPI, NetscriptContext } from "src/Netscript/APIWrapper";
+import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptCodingContract(player: IPlayer, workerScript: WorkerScript): InternalAPI<ICodingContract> {
+export function NetscriptCodingContract(): InternalAPI<ICodingContract> {
   const getCodingContract = function (
     ctx: NetscriptContext,
     func: string,
     hostname: string,
     filename: string,
   ): CodingContract {
-    const server = ctx.helper.getServer(hostname);
+    const server = helpers.getServer(ctx, hostname);
     const contract = server.getContract(filename);
     if (contract == null) {
-      throw ctx.makeRuntimeErrorMsg(`Cannot find contract '${filename}' on server '${hostname}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Cannot find contract '${filename}' on server '${hostname}'`);
     }
 
     return contract;
@@ -27,11 +27,11 @@ export function NetscriptCodingContract(player: IPlayer, workerScript: WorkerScr
       (
         answer: unknown,
         _filename: unknown,
-        _hostname: unknown = workerScript.hostname,
+        _hostname: unknown = ctx.workerScript.hostname,
         { returnReward }: CodingAttemptOptions = { returnReward: false },
       ): boolean | string => {
-        const filename = ctx.helper.string("filename", _filename);
-        const hostname = ctx.helper.string("hostname", _hostname);
+        const filename = helpers.string(ctx, "filename", _filename);
+        const hostname = helpers.string(ctx, "hostname", _hostname);
         const contract = getCodingContract(ctx, "attempt", hostname, filename);
 
         // Convert answer to string. If the answer is a 2D array, then we have to
@@ -51,19 +51,20 @@ export function NetscriptCodingContract(player: IPlayer, workerScript: WorkerScr
         const creward = contract.reward;
         if (creward === null) throw new Error("Somehow solved a contract that didn't have a reward");
 
-        const serv = ctx.helper.getServer(hostname);
+        const serv = helpers.getServer(ctx, hostname);
         if (contract.isSolution(answerStr)) {
           const reward = player.gainCodingContractReward(creward, contract.getDifficulty());
-          ctx.log(() => `Successfully completed Coding Contract '${filename}'. Reward: ${reward}`);
+          helpers.log(ctx, () => `Successfully completed Coding Contract '${filename}'. Reward: ${reward}`);
           serv.removeContract(filename);
           return returnReward ? reward : true;
         } else {
           ++contract.tries;
           if (contract.tries >= contract.getMaxNumTries()) {
-            ctx.log(() => `Coding Contract attempt '${filename}' failed. Contract is now self-destructing`);
+            helpers.log(ctx, () => `Coding Contract attempt '${filename}' failed. Contract is now self-destructing`);
             serv.removeContract(filename);
           } else {
-            ctx.log(
+            helpers.log(
+              ctx,
               () =>
                 `Coding Contract attempt '${filename}' failed. ${
                   contract.getMaxNumTries() - contract.tries
@@ -76,17 +77,17 @@ export function NetscriptCodingContract(player: IPlayer, workerScript: WorkerScr
       },
     getContractType:
       (ctx: NetscriptContext) =>
-      (_filename: unknown, _hostname: unknown = workerScript.hostname): string => {
-        const filename = ctx.helper.string("filename", _filename);
-        const hostname = ctx.helper.string("hostname", _hostname);
+      (_filename: unknown, _hostname: unknown = ctx.workerScript.hostname): string => {
+        const filename = helpers.string(ctx, "filename", _filename);
+        const hostname = helpers.string(ctx, "hostname", _hostname);
         const contract = getCodingContract(ctx, "getContractType", hostname, filename);
         return contract.getType();
       },
     getData:
       (ctx: NetscriptContext) =>
-      (_filename: unknown, _hostname: unknown = workerScript.hostname): unknown => {
-        const filename = ctx.helper.string("filename", _filename);
-        const hostname = ctx.helper.string("hostname", _hostname);
+      (_filename: unknown, _hostname: unknown = ctx.workerScript.hostname): unknown => {
+        const filename = helpers.string(ctx, "filename", _filename);
+        const hostname = helpers.string(ctx, "hostname", _hostname);
         const contract = getCodingContract(ctx, "getData", hostname, filename);
         const data = contract.getData();
         if (Array.isArray(data)) {
@@ -107,17 +108,17 @@ export function NetscriptCodingContract(player: IPlayer, workerScript: WorkerScr
       },
     getDescription:
       (ctx: NetscriptContext) =>
-      (_filename: unknown, _hostname: unknown = workerScript.hostname): string => {
-        const filename = ctx.helper.string("filename", _filename);
-        const hostname = ctx.helper.string("hostname", _hostname);
+      (_filename: unknown, _hostname: unknown = ctx.workerScript.hostname): string => {
+        const filename = helpers.string(ctx, "filename", _filename);
+        const hostname = helpers.string(ctx, "hostname", _hostname);
         const contract = getCodingContract(ctx, "getDescription", hostname, filename);
         return contract.getDescription();
       },
     getNumTriesRemaining:
       (ctx: NetscriptContext) =>
-      (_filename: unknown, _hostname: unknown = workerScript.hostname): number => {
-        const filename = ctx.helper.string("filename", _filename);
-        const hostname = ctx.helper.string("hostname", _hostname);
+      (_filename: unknown, _hostname: unknown = ctx.workerScript.hostname): number => {
+        const filename = helpers.string(ctx, "filename", _filename);
+        const hostname = helpers.string(ctx, "hostname", _hostname);
         const contract = getCodingContract(ctx, "getNumTriesRemaining", hostname, filename);
         return contract.getMaxNumTries() - contract.tries;
       },
diff --git a/src/NetscriptFunctions/Corporation.ts b/src/NetscriptFunctions/Corporation.ts
index 023d990db..1b495484f 100644
--- a/src/NetscriptFunctions/Corporation.ts
+++ b/src/NetscriptFunctions/Corporation.ts
@@ -1,4 +1,4 @@
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 
 import { OfficeSpace } from "../Corporation/OfficeSpace";
 import { Employee } from "../Corporation/Employee";
@@ -65,9 +65,10 @@ import { CorporationConstants } from "../Corporation/data/Constants";
 import { ResearchMap } from "../Corporation/ResearchMap";
 import { Factions } from "../Faction/Factions";
 import { BitNodeMultipliers } from "../BitNode/BitNodeMultipliers";
-import { InternalAPI, NetscriptContext } from "src/Netscript/APIWrapper";
+import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation> {
+export function NetscriptCorporation(): InternalAPI<NSCorporation> {
   function createCorporation(corporationName: string, selfFund = true): boolean {
     if (!player.canAccessCorporation() || player.hasCorporation()) return false;
     if (!corporationName) return false;
@@ -101,7 +102,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
   }
 
   function getUpgradeLevel(ctx: NetscriptContext, _upgradeName: string): number {
-    const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+    const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
     const corporation = getCorporation();
     const upgrade = Object.values(CorporationUpgrades).find((upgrade) => upgrade.name === upgradeName);
     if (upgrade === undefined) throw new Error(`No upgrade named '${upgradeName}'`);
@@ -110,7 +111,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
   }
 
   function getUpgradeLevelCost(ctx: NetscriptContext, _upgradeName: string): number {
-    const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+    const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
     const corporation = getCorporation();
     const upgrade = Object.values(CorporationUpgrades).find((upgrade) => upgrade.name === upgradeName);
     if (upgrade === undefined) throw new Error(`No upgrade named '${upgradeName}'`);
@@ -274,10 +275,11 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
   }
 
   function checkAccess(ctx: NetscriptContext, api?: number): void {
-    if (player.corporation === null) throw ctx.makeRuntimeErrorMsg("Must own a corporation.");
+    if (player.corporation === null) throw helpers.makeRuntimeErrorMsg(ctx, "Must own a corporation.");
     if (!api) return;
 
-    if (!player.corporation.unlockUpgrades[api]) throw ctx.makeRuntimeErrorMsg("You do not have access to this API.");
+    if (!player.corporation.unlockUpgrades[api])
+      throw helpers.makeRuntimeErrorMsg(ctx, "You do not have access to this API.");
   }
 
   function getSafeDivision(division: Industry): NSDivision {
@@ -314,11 +316,11 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _amt: unknown = 1): number => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const amt = ctx.helper.number("amount", _amt);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const amt = helpers.number(ctx, "amount", _amt);
         if (amt < 1) {
-          throw ctx.makeRuntimeErrorMsg("You must provide a positive number");
+          throw helpers.makeRuntimeErrorMsg(ctx, "You must provide a positive number");
         }
         const warehouse = getWarehouse(divisionName, cityName);
         return UpgradeWarehouseCost(warehouse, amt);
@@ -327,8 +329,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): boolean => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
         const division = getDivision(divisionName);
         if (!(cityName in division.warehouses)) throw new Error(`Invalid city name '${cityName}'`);
         const warehouse = division.warehouses[cityName];
@@ -338,8 +340,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): NSWarehouse => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
         const warehouse = getWarehouse(divisionName, cityName);
         return {
           level: warehouse.level,
@@ -353,9 +355,9 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown): NSMaterial => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
         const material = getMaterial(divisionName, cityName, materialName);
         const corporation = getCorporation();
         return {
@@ -374,8 +376,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _productName: unknown): NSProduct => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const productName = ctx.helper.string("productName", _productName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const productName = helpers.string(ctx, "productName", _productName);
         const product = getProduct(divisionName, productName);
         const corporation = getCorporation();
         return {
@@ -401,8 +403,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
         const corporation = getCorporation();
         PurchaseWarehouse(corporation, getDivision(divisionName), cityName);
       },
@@ -410,12 +412,12 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _amt: unknown = 1): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const amt = ctx.helper.number("amount", _amt);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const amt = helpers.number(ctx, "amount", _amt);
         const corporation = getCorporation();
         if (amt < 1) {
-          throw ctx.makeRuntimeErrorMsg("You must provide a positive number");
+          throw helpers.makeRuntimeErrorMsg(ctx, "You must provide a positive number");
         }
         UpgradeWarehouse(corporation, getDivision(divisionName), getWarehouse(divisionName, cityName), amt);
       },
@@ -423,11 +425,11 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _amt: unknown, _price: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const amt = ctx.helper.string("amt", _amt);
-        const price = ctx.helper.string("price", _price);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const amt = helpers.string(ctx, "amt", _amt);
+        const price = helpers.string(ctx, "price", _price);
         const material = getMaterial(divisionName, cityName, materialName);
         SellMaterial(material, amt, price);
       },
@@ -442,12 +444,12 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
         _all: unknown,
       ): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const productName = ctx.helper.string("productName", _productName);
-        const amt = ctx.helper.string("amt", _amt);
-        const price = ctx.helper.string("price", _price);
-        const all = ctx.helper.boolean(_all);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const productName = helpers.string(ctx, "productName", _productName);
+        const amt = helpers.string(ctx, "amt", _amt);
+        const price = helpers.string(ctx, "price", _price);
+        const all = !!_all;
         const product = getProduct(divisionName, productName);
         SellProduct(product, cityName, amt, price, all);
       },
@@ -455,44 +457,44 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _productName: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const productName = ctx.helper.string("productName", _productName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const productName = helpers.string(ctx, "productName", _productName);
         getDivision(divisionName).discontinueProduct(getProduct(divisionName, productName));
       },
     setSmartSupply:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _enabled: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const enabled = ctx.helper.boolean(_enabled);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const enabled = !!_enabled;
         const warehouse = getWarehouse(divisionName, cityName);
         if (!hasUnlockUpgrade("Smart Supply"))
-          throw ctx.makeRuntimeErrorMsg(`You have not purchased the Smart Supply upgrade!`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `You have not purchased the Smart Supply upgrade!`);
         SetSmartSupply(warehouse, enabled);
       },
     setSmartSupplyUseLeftovers:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _enabled: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const enabled = ctx.helper.boolean(_enabled);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const enabled = !!_enabled;
         const warehouse = getWarehouse(divisionName, cityName);
         const material = getMaterial(divisionName, cityName, materialName);
         if (!hasUnlockUpgrade("Smart Supply"))
-          throw ctx.makeRuntimeErrorMsg(`You have not purchased the Smart Supply upgrade!`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `You have not purchased the Smart Supply upgrade!`);
         SetSmartSupplyUseLeftovers(warehouse, material, enabled);
       },
     buyMaterial:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _amt: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const amt = ctx.helper.number("amt", _amt);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const amt = helpers.number(ctx, "amt", _amt);
         if (amt < 0) throw new Error("Invalid value for amount field! Must be numeric and greater than 0");
         const material = getMaterial(divisionName, cityName, materialName);
         BuyMaterial(material, amt);
@@ -501,13 +503,13 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _amt: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
         if (!hasResearched(getDivision(divisionName), "Bulk Purchasing"))
           throw new Error(`You have not researched Bulk Purchasing in ${divisionName}`);
         const corporation = getCorporation();
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const amt = ctx.helper.number("amt", _amt);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const amt = helpers.number(ctx, "amt", _amt);
         const warehouse = getWarehouse(divisionName, cityName);
         const material = getMaterial(divisionName, cityName, materialName);
         BulkPurchase(corporation, warehouse, material, amt);
@@ -522,11 +524,11 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
         _marketingInvest: unknown,
       ): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const productName = ctx.helper.string("productName", _productName);
-        const designInvest = ctx.helper.number("designInvest", _designInvest);
-        const marketingInvest = ctx.helper.number("marketingInvest", _marketingInvest);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const productName = helpers.string(ctx, "productName", _productName);
+        const designInvest = helpers.number(ctx, "designInvest", _designInvest);
+        const marketingInvest = helpers.number(ctx, "marketingInvest", _marketingInvest);
         const corporation = getCorporation();
         MakeProduct(corporation, getDivision(divisionName), cityName, productName, designInvest, marketingInvest);
       },
@@ -534,10 +536,10 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _productName: unknown, _cityName: unknown, _qty: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const productName = ctx.helper.string("productName", _productName);
-        const qty = ctx.helper.number("qty", _qty);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const productName = helpers.string(ctx, "productName", _productName);
+        const qty = helpers.number(ctx, "qty", _qty);
         LimitProductProduction(getProduct(divisionName, productName), cityName, qty);
       },
     exportMaterial:
@@ -551,12 +553,12 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
         _amt: unknown,
       ): void => {
         checkAccess(ctx, 7);
-        const sourceDivision = ctx.helper.string("sourceDivision", _sourceDivision);
-        const sourceCity = ctx.helper.string("sourceCity", _sourceCity);
-        const targetDivision = ctx.helper.string("targetDivision", _targetDivision);
-        const targetCity = ctx.helper.string("targetCity", _targetCity);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const amt = ctx.helper.string("amt", _amt);
+        const sourceDivision = helpers.string(ctx, "sourceDivision", _sourceDivision);
+        const sourceCity = helpers.string(ctx, "sourceCity", _sourceCity);
+        const targetDivision = helpers.string(ctx, "targetDivision", _targetDivision);
+        const targetCity = helpers.string(ctx, "targetCity", _targetCity);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const amt = helpers.string(ctx, "amt", _amt);
         ExportMaterial(
           targetDivision,
           targetCity,
@@ -576,12 +578,12 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
         _amt: unknown,
       ): void => {
         checkAccess(ctx, 7);
-        const sourceDivision = ctx.helper.string("sourceDivision", _sourceDivision);
-        const sourceCity = ctx.helper.string("sourceCity", _sourceCity);
-        const targetDivision = ctx.helper.string("targetDivision", _targetDivision);
-        const targetCity = ctx.helper.string("targetCity", _targetCity);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const amt = ctx.helper.string("amt", _amt);
+        const sourceDivision = helpers.string(ctx, "sourceDivision", _sourceDivision);
+        const sourceCity = helpers.string(ctx, "sourceCity", _sourceCity);
+        const targetDivision = helpers.string(ctx, "targetDivision", _targetDivision);
+        const targetCity = helpers.string(ctx, "targetCity", _targetCity);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const amt = helpers.string(ctx, "amt", _amt);
         CancelExportMaterial(
           targetDivision,
           targetCity,
@@ -593,56 +595,56 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _qty: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const qty = ctx.helper.number("qty", _qty);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const qty = helpers.number(ctx, "qty", _qty);
         LimitMaterialProduction(getMaterial(divisionName, cityName, materialName), qty);
       },
     setMaterialMarketTA1:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _on: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const on = ctx.helper.boolean(_on);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const on = !!_on;
         if (!getDivision(divisionName).hasResearch("Market-TA.I"))
-          throw ctx.makeRuntimeErrorMsg(`You have not researched MarketTA.I for division: ${divisionName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `You have not researched MarketTA.I for division: ${divisionName}`);
         SetMaterialMarketTA1(getMaterial(divisionName, cityName, materialName), on);
       },
     setMaterialMarketTA2:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _materialName: unknown, _on: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const materialName = ctx.helper.string("materialName", _materialName);
-        const on = ctx.helper.boolean(_on);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const materialName = helpers.string(ctx, "materialName", _materialName);
+        const on = !!_on;
         if (!getDivision(divisionName).hasResearch("Market-TA.II"))
-          throw ctx.makeRuntimeErrorMsg(`You have not researched MarketTA.II for division: ${divisionName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `You have not researched MarketTA.II for division: ${divisionName}`);
         SetMaterialMarketTA2(getMaterial(divisionName, cityName, materialName), on);
       },
     setProductMarketTA1:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _productName: unknown, _on: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const productName = ctx.helper.string("productName", _productName);
-        const on = ctx.helper.boolean(_on);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const productName = helpers.string(ctx, "productName", _productName);
+        const on = !!_on;
         if (!getDivision(divisionName).hasResearch("Market-TA.I"))
-          throw ctx.makeRuntimeErrorMsg(`You have not researched MarketTA.I for division: ${divisionName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `You have not researched MarketTA.I for division: ${divisionName}`);
         SetProductMarketTA1(getProduct(divisionName, productName), on);
       },
     setProductMarketTA2:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _productName: unknown, _on: unknown): void => {
         checkAccess(ctx, 7);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const productName = ctx.helper.string("productName", _productName);
-        const on = ctx.helper.boolean(_on);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const productName = helpers.string(ctx, "productName", _productName);
+        const on = !!_on;
         if (!getDivision(divisionName).hasResearch("Market-TA.II"))
-          throw ctx.makeRuntimeErrorMsg(`You have not researched MarketTA.II for division: ${divisionName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `You have not researched MarketTA.II for division: ${divisionName}`);
         SetProductMarketTA2(getProduct(divisionName, productName), on);
       },
   };
@@ -652,7 +654,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown): number => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
         const division = getDivision(divisionName);
         return division.getAdVertCost();
       },
@@ -660,7 +662,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown): number => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
         const division = getDivision(divisionName);
         return division.numAdVerts;
       },
@@ -668,25 +670,25 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _researchName: unknown): number => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const researchName = ctx.helper.string("researchName", _researchName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const researchName = helpers.string(ctx, "researchName", _researchName);
         return getResearchCost(getDivision(divisionName), researchName);
       },
     hasResearched:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _researchName: unknown): boolean => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const researchName = ctx.helper.string("researchName", _researchName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const researchName = helpers.string(ctx, "researchName", _researchName);
         return hasResearched(getDivision(divisionName), researchName);
       },
     getOfficeSizeUpgradeCost:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _size: unknown): number => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const size = ctx.helper.number("size", _size);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const size = helpers.number(ctx, "size", _size);
         if (size < 0) throw new Error("Invalid value for size field! Must be numeric and greater than 0");
         const office = getOffice(divisionName, cityName);
         const initialPriceMult = Math.round(office.size / CorporationConstants.OfficeInitialSize);
@@ -701,10 +703,10 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _employeeName: unknown, _job: unknown): void => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const employeeName = ctx.helper.string("employeeName", _employeeName);
-        const job = ctx.helper.string("job", _job);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const employeeName = helpers.string(ctx, "employeeName", _employeeName);
+        const job = helpers.string(ctx, "job", _job);
 
         if (!Object.values(EmployeePositions).includes(job)) throw new Error(`'${job}' is not a valid job.`);
         const office = getOffice(divisionName, cityName);
@@ -715,10 +717,10 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _job: unknown, _amount: unknown): boolean => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const amount = ctx.helper.number("amount", _amount);
-        const job = ctx.helper.string("job", _job);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const amount = helpers.number(ctx, "amount", _amount);
+        const job = helpers.string(ctx, "job", _job);
 
         if (!Object.values(EmployeePositions).includes(job)) throw new Error(`'${job}' is not a valid job.`);
         const office = getOffice(divisionName, cityName);
@@ -729,8 +731,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): NSEmployee | undefined => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
         const office = getOffice(divisionName, cityName);
         const employee = office.hireRandomEmployee();
         if (employee === undefined) return undefined;
@@ -753,9 +755,9 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _size: unknown): void => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const size = ctx.helper.number("size", _size);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const size = helpers.number(ctx, "size", _size);
         if (size < 0) throw new Error("Invalid value for size field! Must be numeric and greater than 0");
         const office = getOffice(divisionName, cityName);
         const corporation = getCorporation();
@@ -765,9 +767,9 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _costPerEmployee: unknown): number => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const costPerEmployee = ctx.helper.number("costPerEmployee", _costPerEmployee);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const costPerEmployee = helpers.number(ctx, "costPerEmployee", _costPerEmployee);
 
         if (costPerEmployee < 0) {
           throw new Error("Invalid value for Cost Per Employee field! Must be numeric and greater than 0");
@@ -782,8 +784,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): boolean => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
 
         const corporation = getCorporation();
         const office = getOffice(divisionName, cityName);
@@ -794,7 +796,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown): void => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
         const corporation = getCorporation();
         HireAdVert(corporation, getDivision(divisionName));
       },
@@ -802,16 +804,16 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _researchName: unknown): void => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const researchName = ctx.helper.string("researchName", _researchName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const researchName = helpers.string(ctx, "researchName", _researchName);
         Research(getDivision(divisionName), researchName);
       },
     getOffice:
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): NSOffice => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
         const office = getOffice(divisionName, cityName);
         return {
           loc: office.loc,
@@ -847,9 +849,9 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown, _employeeName: unknown): NSEmployee => {
         checkAccess(ctx, 8);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
-        const employeeName = ctx.helper.string("employeeName", _employeeName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
+        const employeeName = helpers.string(ctx, "employeeName", _employeeName);
         const employee = getEmployee(divisionName, cityName, employeeName);
         return {
           name: employee.name,
@@ -871,12 +873,27 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
   return {
     ...warehouseAPI,
     ...officeAPI,
+    getMaterialNames: () => (): string[] => {
+      return CorporationConstants.AllMaterials;
+    },
+    getIndustryTypes: () => (): string[] => {
+      return CorporationConstants.AllIndustryTypes;
+    },
+    getUnlockables: () => (): string[] => {
+      return CorporationConstants.AllUnlocks;
+    },
+    getUpgradeNames: () => (): string[] => {
+      return CorporationConstants.AllUpgrades;
+    },
+    getResearchNames: () => (): string[] => {
+      return CorporationConstants.AllResearch;
+    },
     expandIndustry:
       (ctx: NetscriptContext) =>
       (_industryName: unknown, _divisionName: unknown): void => {
         checkAccess(ctx);
-        const industryName = ctx.helper.string("industryName", _industryName);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
+        const industryName = helpers.string(ctx, "industryName", _industryName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
         const corporation = getCorporation();
         NewIndustry(corporation, industryName, divisionName);
       },
@@ -884,8 +901,8 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown, _cityName: unknown): void => {
         checkAccess(ctx);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
-        const cityName = ctx.helper.city("cityName", _cityName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
         if (!CorporationConstants.Cities.includes(cityName)) throw new Error("Invalid city name");
         const corporation = getCorporation();
         const division = getDivision(divisionName);
@@ -895,7 +912,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_upgradeName: unknown): void => {
         checkAccess(ctx);
-        const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+        const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
         const corporation = getCorporation();
         const upgrade = Object.values(CorporationUnlockUpgrades).find((upgrade) => upgrade.name === upgradeName);
         if (upgrade === undefined) throw new Error(`No upgrade named '${upgradeName}'`);
@@ -905,7 +922,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_upgradeName: unknown): void => {
         checkAccess(ctx);
-        const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+        const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
         const corporation = getCorporation();
         const upgrade = Object.values(CorporationUpgrades).find((upgrade) => upgrade.name === upgradeName);
         if (upgrade === undefined) throw new Error(`No upgrade named '${upgradeName}'`);
@@ -915,12 +932,12 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_rate: unknown): void => {
         checkAccess(ctx);
-        const rate = ctx.helper.number("rate", _rate);
+        const rate = helpers.number(ctx, "rate", _rate);
         const max = CorporationConstants.DividendMaxRate;
         if (rate < 0 || rate > max)
           throw new Error(`Invalid value for rate field! Must be numeric, greater than 0, and less than ${max}`);
         const corporation = getCorporation();
-        if (!corporation.public) throw ctx.makeRuntimeErrorMsg(`Your company has not gone public!`);
+        if (!corporation.public) throw helpers.makeRuntimeErrorMsg(ctx, `Your company has not gone public!`);
         IssueDividends(corporation, rate);
       },
 
@@ -930,7 +947,7 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_divisionName: unknown): NSDivision => {
         checkAccess(ctx);
-        const divisionName = ctx.helper.string("divisionName", _divisionName);
+        const divisionName = helpers.string(ctx, "divisionName", _divisionName);
         const division = getDivision(divisionName);
         return getSafeDivision(division);
       },
@@ -958,43 +975,43 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
     createCorporation:
       (ctx: NetscriptContext) =>
       (_corporationName: unknown, _selfFund: unknown = true): boolean => {
-        const corporationName = ctx.helper.string("corporationName", _corporationName);
-        const selfFund = ctx.helper.boolean(_selfFund);
+        const corporationName = helpers.string(ctx, "corporationName", _corporationName);
+        const selfFund = !_selfFund;
         return createCorporation(corporationName, selfFund);
       },
     hasUnlockUpgrade:
       (ctx: NetscriptContext) =>
       (_upgradeName: unknown): boolean => {
         checkAccess(ctx);
-        const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+        const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
         return hasUnlockUpgrade(upgradeName);
       },
     getUnlockUpgradeCost:
       (ctx: NetscriptContext) =>
       (_upgradeName: unknown): number => {
         checkAccess(ctx);
-        const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+        const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
         return getUnlockUpgradeCost(upgradeName);
       },
     getUpgradeLevel:
       (ctx: NetscriptContext) =>
       (_upgradeName: unknown): number => {
         checkAccess(ctx);
-        const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+        const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
         return getUpgradeLevel(ctx, upgradeName);
       },
     getUpgradeLevelCost:
       (ctx: NetscriptContext) =>
       (_upgradeName: unknown): number => {
         checkAccess(ctx);
-        const upgradeName = ctx.helper.string("upgradeName", _upgradeName);
+        const upgradeName = helpers.string(ctx, "upgradeName", _upgradeName);
         return getUpgradeLevelCost(ctx, upgradeName);
       },
     getExpandIndustryCost:
       (ctx: NetscriptContext) =>
       (_industryName: unknown): number => {
         checkAccess(ctx);
-        const industryName = ctx.helper.string("industryName", _industryName);
+        const industryName = helpers.string(ctx, "industryName", _industryName);
         return getExpandIndustryCost(industryName);
       },
     getExpandCityCost: (ctx: NetscriptContext) => (): number => {
@@ -1013,29 +1030,29 @@ export function NetscriptCorporation(player: IPlayer): InternalAPI<NSCorporation
       (ctx: NetscriptContext) =>
       (_numShares: unknown): boolean => {
         checkAccess(ctx);
-        const numShares = ctx.helper.number("numShares", _numShares);
+        const numShares = helpers.number(ctx, "numShares", _numShares);
         return goPublic(numShares);
       },
     sellShares:
       (ctx: NetscriptContext) =>
       (_numShares: unknown): number => {
         checkAccess(ctx);
-        const numShares = ctx.helper.number("numShares", _numShares);
+        const numShares = helpers.number(ctx, "numShares", _numShares);
         return SellShares(getCorporation(), player, numShares);
       },
     buyBackShares:
       (ctx: NetscriptContext) =>
       (_numShares: unknown): boolean => {
         checkAccess(ctx);
-        const numShares = ctx.helper.number("numShares", _numShares);
+        const numShares = helpers.number(ctx, "numShares", _numShares);
         return BuyBackShares(getCorporation(), player, numShares);
       },
     bribe:
       (ctx: NetscriptContext) =>
       (_factionName: unknown, _amountCash: unknown): boolean => {
         checkAccess(ctx);
-        const factionName = ctx.helper.string("factionName", _factionName);
-        const amountCash = ctx.helper.number("amountCash", _amountCash);
+        const factionName = helpers.string(ctx, "factionName", _factionName);
+        const amountCash = helpers.number(ctx, "amountCash", _amountCash);
         return bribe(factionName, amountCash);
       },
     getBonusTime: (ctx: NetscriptContext) => (): number => {
diff --git a/src/NetscriptFunctions/Extra.ts b/src/NetscriptFunctions/Extra.ts
index a5e2b04ba..427a1ec63 100644
--- a/src/NetscriptFunctions/Extra.ts
+++ b/src/NetscriptFunctions/Extra.ts
@@ -1,8 +1,9 @@
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { Exploit } from "../Exploits/Exploit";
 import * as bcrypt from "bcryptjs";
 import { Apr1Events as devMenu } from "../ui/Apr1";
 import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
 export interface INetscriptExtra {
   heart: {
@@ -15,7 +16,7 @@ export interface INetscriptExtra {
   rainbow(guess: string): void;
 }
 
-export function NetscriptExtra(player: IPlayer): InternalAPI<INetscriptExtra> {
+export function NetscriptExtra(): InternalAPI<INetscriptExtra> {
   return {
     heart: {
       // Easter egg function
@@ -67,7 +68,7 @@ export function NetscriptExtra(player: IPlayer): InternalAPI<INetscriptExtra> {
         function tryGuess(): boolean {
           // eslint-disable-next-line no-sync
           const verified = bcrypt.compareSync(
-            ctx.helper.string("guess", guess),
+            helpers.string(ctx, "guess", guess),
             "$2a$10$aertxDEkgor8baVtQDZsLuMwwGYmkRM/ohcA6FjmmzIHQeTCsrCcO",
           );
           if (verified) {
diff --git a/src/NetscriptFunctions/Flags.ts b/src/NetscriptFunctions/Flags.ts
index d67158dc0..1d08dc67b 100644
--- a/src/NetscriptFunctions/Flags.ts
+++ b/src/NetscriptFunctions/Flags.ts
@@ -1,41 +1,42 @@
 import { toNative } from "./toNative";
 import libarg from "arg";
 import { ScriptArg } from "../Netscript/ScriptArg";
+import { NetscriptContext } from "../Netscript/APIWrapper";
 
 type FlagType = StringConstructor | NumberConstructor | BooleanConstructor | StringConstructor[];
 type FlagsRet = { [key: string]: ScriptArg };
-export function Flags(vargs: string[]): () => (data: unknown) => FlagsRet {
-  return (/* ctx: NetscriptContext */) =>
-    (schema: unknown): FlagsRet => {
-      schema = toNative(schema);
-      if (!Array.isArray(schema)) throw new Error("flags schema passed in is invalid.");
-      const args: {
-        [key: string]: FlagType;
-      } = {};
+export function Flags(ctx: NetscriptContext | string[]): (data: unknown) => FlagsRet {
+  const vargs = Array.isArray(ctx) ? ctx : ctx.workerScript.args;
+  return (schema: unknown): FlagsRet => {
+    schema = toNative(schema);
+    if (!Array.isArray(schema)) throw new Error("flags schema passed in is invalid.");
+    const args: {
+      [key: string]: FlagType;
+    } = {};
 
-      for (const d of schema) {
-        let t: FlagType = String;
-        if (typeof d[1] === "number") {
-          t = Number;
-        } else if (typeof d[1] === "boolean") {
-          t = Boolean;
-        } else if (Array.isArray(d[1])) {
-          t = [String];
-        }
-        const numDashes = d[0].length > 1 ? 2 : 1;
-        args["-".repeat(numDashes) + d[0]] = t;
+    for (const d of schema) {
+      let t: FlagType = String;
+      if (typeof d[1] === "number") {
+        t = Number;
+      } else if (typeof d[1] === "boolean") {
+        t = Boolean;
+      } else if (Array.isArray(d[1])) {
+        t = [String];
       }
-      const ret: FlagsRet = libarg(args, { argv: vargs });
-      for (const d of schema) {
-        if (!ret.hasOwnProperty("--" + d[0]) || !ret.hasOwnProperty("-" + d[0])) ret[d[0]] = d[1];
-      }
-      for (const key of Object.keys(ret)) {
-        if (!key.startsWith("-")) continue;
-        const value = ret[key];
-        delete ret[key];
-        const numDashes = key.length === 2 ? 1 : 2;
-        ret[key.slice(numDashes)] = value;
-      }
-      return ret;
-    };
+      const numDashes = d[0].length > 1 ? 2 : 1;
+      args["-".repeat(numDashes) + d[0]] = t;
+    }
+    const ret: FlagsRet = libarg(args, { argv: vargs });
+    for (const d of schema) {
+      if (!ret.hasOwnProperty("--" + d[0]) || !ret.hasOwnProperty("-" + d[0])) ret[d[0]] = d[1];
+    }
+    for (const key of Object.keys(ret)) {
+      if (!key.startsWith("-")) continue;
+      const value = ret[key];
+      delete ret[key];
+      const numDashes = key.length === 2 ? 1 : 2;
+      ret[key.slice(numDashes)] = value;
+    }
+    return ret;
+  };
 }
diff --git a/src/NetscriptFunctions/Formulas.ts b/src/NetscriptFunctions/Formulas.ts
index f7ed0797d..3cc659d2e 100644
--- a/src/NetscriptFunctions/Formulas.ts
+++ b/src/NetscriptFunctions/Formulas.ts
@@ -1,5 +1,4 @@
-import { INetscriptHelper } from "./INetscriptHelper";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { calculateServerGrowth } from "../Server/formulas/grow";
 import {
   calculateMoneyGainRate,
@@ -43,11 +42,12 @@ import {
 import { favorToRep as calculateFavorToRep, repToFavor as calculateRepToFavor } from "../Faction/formulas/favor";
 import { repFromDonation } from "../Faction/formulas/donation";
 import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): InternalAPI<IFormulas> {
+export function NetscriptFormulas(): InternalAPI<IFormulas> {
   const checkFormulasAccess = function (ctx: NetscriptContext): void {
     if (!player.hasProgram(Programs.Formulas.name)) {
-      throw helper.makeRuntimeErrorMsg(`formulas.${ctx.function}`, `Requires Formulas.exe to run.`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Requires Formulas.exe to run.`);
     }
   };
   return {
@@ -55,22 +55,22 @@ export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): In
       calculateFavorToRep:
         (ctx: NetscriptContext) =>
         (_favor: unknown): number => {
-          const favor = ctx.helper.number("favor", _favor);
+          const favor = helpers.number(ctx, "favor", _favor);
           checkFormulasAccess(ctx);
           return calculateFavorToRep(favor);
         },
       calculateRepToFavor:
         (ctx: NetscriptContext) =>
         (_rep: unknown): number => {
-          const rep = ctx.helper.number("rep", _rep);
+          const rep = helpers.number(ctx, "rep", _rep);
           checkFormulasAccess(ctx);
           return calculateRepToFavor(rep);
         },
       repFromDonation:
         (ctx: NetscriptContext) =>
         (_amount: unknown, _player: unknown): number => {
-          const amount = ctx.helper.number("amount", _amount);
-          const player = ctx.helper.player(_player);
+          const amount = helpers.number(ctx, "amount", _amount);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return repFromDonation(amount, player);
         },
@@ -79,16 +79,16 @@ export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): In
       calculateSkill:
         (ctx: NetscriptContext) =>
         (_exp: unknown, _mult: unknown = 1): number => {
-          const exp = ctx.helper.number("exp", _exp);
-          const mult = ctx.helper.number("mult", _mult);
+          const exp = helpers.number(ctx, "exp", _exp);
+          const mult = helpers.number(ctx, "mult", _mult);
           checkFormulasAccess(ctx);
           return calculateSkill(exp, mult);
         },
       calculateExp:
         (ctx: NetscriptContext) =>
         (_skill: unknown, _mult: unknown = 1): number => {
-          const skill = ctx.helper.number("skill", _skill);
-          const mult = ctx.helper.number("mult", _mult);
+          const skill = helpers.number(ctx, "skill", _skill);
+          const mult = helpers.number(ctx, "mult", _mult);
           checkFormulasAccess(ctx);
           return calculateExp(skill, mult);
         },
@@ -97,58 +97,58 @@ export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): In
       hackChance:
         (ctx: NetscriptContext) =>
         (_server: unknown, _player: unknown): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return calculateHackingChance(server, player);
         },
       hackExp:
         (ctx: NetscriptContext) =>
         (_server: unknown, _player: unknown): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return calculateHackingExpGain(server, player);
         },
       hackPercent:
         (ctx: NetscriptContext) =>
         (_server: unknown, _player: unknown): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return calculatePercentMoneyHacked(server, player);
         },
       growPercent:
         (ctx: NetscriptContext) =>
         (_server: unknown, _threads: unknown, _player: unknown, _cores: unknown = 1): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
-          const threads = ctx.helper.number("threads", _threads);
-          const cores = ctx.helper.number("cores", _cores);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
+          const threads = helpers.number(ctx, "threads", _threads);
+          const cores = helpers.number(ctx, "cores", _cores);
           checkFormulasAccess(ctx);
           return calculateServerGrowth(server, threads, player, cores);
         },
       hackTime:
         (ctx: NetscriptContext) =>
         (_server: unknown, _player: unknown): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return calculateHackingTime(server, player) * 1000;
         },
       growTime:
         (ctx: NetscriptContext) =>
         (_server: unknown, _player: unknown): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return calculateGrowTime(server, player) * 1000;
         },
       weakenTime:
         (ctx: NetscriptContext) =>
         (_server: unknown, _player: unknown): number => {
-          const server = ctx.helper.server(_server);
-          const player = ctx.helper.player(_player);
+          const server = helpers.server(ctx, _server);
+          const player = helpers.player(ctx, _player);
           checkFormulasAccess(ctx);
           return calculateWeakenTime(server, player) * 1000;
         },
@@ -157,45 +157,45 @@ export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): In
       moneyGainRate:
         (ctx: NetscriptContext) =>
         (_level: unknown, _ram: unknown, _cores: unknown, _mult: unknown = 1): number => {
-          const level = ctx.helper.number("level", _level);
-          const ram = ctx.helper.number("ram", _ram);
-          const cores = ctx.helper.number("cores", _cores);
-          const mult = ctx.helper.number("mult", _mult);
+          const level = helpers.number(ctx, "level", _level);
+          const ram = helpers.number(ctx, "ram", _ram);
+          const cores = helpers.number(ctx, "cores", _cores);
+          const mult = helpers.number(ctx, "mult", _mult);
           checkFormulasAccess(ctx);
           return calculateMoneyGainRate(level, ram, cores, mult);
         },
       levelUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
-          const startingLevel = ctx.helper.number("startingLevel", _startingLevel);
-          const extraLevels = ctx.helper.number("extraLevels", _extraLevels);
-          const costMult = ctx.helper.number("costMult", _costMult);
+          const startingLevel = helpers.number(ctx, "startingLevel", _startingLevel);
+          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
+          const costMult = helpers.number(ctx, "costMult", _costMult);
           checkFormulasAccess(ctx);
           return calculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
         },
       ramUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
-          const startingRam = ctx.helper.number("startingRam", _startingRam);
-          const extraLevels = ctx.helper.number("extraLevels", _extraLevels);
-          const costMult = ctx.helper.number("costMult", _costMult);
+          const startingRam = helpers.number(ctx, "startingRam", _startingRam);
+          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
+          const costMult = helpers.number(ctx, "costMult", _costMult);
           checkFormulasAccess(ctx);
           return calculateRamUpgradeCost(startingRam, extraLevels, costMult);
         },
       coreUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => {
-          const startingCore = ctx.helper.number("startingCore", _startingCore);
-          const extraCores = ctx.helper.number("extraCores", _extraCores);
-          const costMult = ctx.helper.number("costMult", _costMult);
+          const startingCore = helpers.number(ctx, "startingCore", _startingCore);
+          const extraCores = helpers.number(ctx, "extraCores", _extraCores);
+          const costMult = helpers.number(ctx, "costMult", _costMult);
           checkFormulasAccess(ctx);
           return calculateCoreUpgradeCost(startingCore, extraCores, costMult);
         },
       hacknetNodeCost:
         (ctx: NetscriptContext) =>
         (_n: unknown, _mult: unknown): number => {
-          const n = ctx.helper.number("n", _n);
-          const mult = ctx.helper.number("mult", _mult);
+          const n = helpers.number(ctx, "n", _n);
+          const mult = helpers.number(ctx, "mult", _mult);
           checkFormulasAccess(ctx);
           return calculateNodeCost(n, mult);
         },
@@ -208,69 +208,66 @@ export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): In
       hashGainRate:
         (ctx: NetscriptContext) =>
         (_level: unknown, _ramUsed: unknown, _maxRam: unknown, _cores: unknown, _mult: unknown = 1): number => {
-          const level = ctx.helper.number("level", _level);
-          const ramUsed = ctx.helper.number("ramUsed", _ramUsed);
-          const maxRam = ctx.helper.number("maxRam", _maxRam);
-          const cores = ctx.helper.number("cores", _cores);
-          const mult = ctx.helper.number("mult", _mult);
+          const level = helpers.number(ctx, "level", _level);
+          const ramUsed = helpers.number(ctx, "ramUsed", _ramUsed);
+          const maxRam = helpers.number(ctx, "maxRam", _maxRam);
+          const cores = helpers.number(ctx, "cores", _cores);
+          const mult = helpers.number(ctx, "mult", _mult);
           checkFormulasAccess(ctx);
           return HScalculateHashGainRate(level, ramUsed, maxRam, cores, mult);
         },
       levelUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
-          const startingLevel = ctx.helper.number("startingLevel", _startingLevel);
-          const extraLevels = ctx.helper.number("extraLevels", _extraLevels);
-          const costMult = ctx.helper.number("costMult", _costMult);
+          const startingLevel = helpers.number(ctx, "startingLevel", _startingLevel);
+          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
+          const costMult = helpers.number(ctx, "costMult", _costMult);
           checkFormulasAccess(ctx);
           return HScalculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
         },
       ramUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
-          const startingRam = ctx.helper.number("startingRam", _startingRam);
-          const extraLevels = ctx.helper.number("extraLevels", _extraLevels);
-          const costMult = ctx.helper.number("costMult", _costMult);
+          const startingRam = helpers.number(ctx, "startingRam", _startingRam);
+          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
+          const costMult = helpers.number(ctx, "costMult", _costMult);
           checkFormulasAccess(ctx);
           return HScalculateRamUpgradeCost(startingRam, extraLevels, costMult);
         },
       coreUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => {
-          const startingCore = ctx.helper.number("startingCore", _startingCore);
-          const extraCores = ctx.helper.number("extraCores", _extraCores);
-          const costMult = ctx.helper.number("costMult", _costMult);
+          const startingCore = helpers.number(ctx, "startingCore", _startingCore);
+          const extraCores = helpers.number(ctx, "extraCores", _extraCores);
+          const costMult = helpers.number(ctx, "costMult", _costMult);
           checkFormulasAccess(ctx);
           return HScalculateCoreUpgradeCost(startingCore, extraCores, costMult);
         },
       cacheUpgradeCost:
         (ctx: NetscriptContext) =>
         (_startingCache: unknown, _extraCache: unknown = 1): number => {
-          const startingCache = ctx.helper.number("startingCache", _startingCache);
-          const extraCache = ctx.helper.number("extraCache", _extraCache);
+          const startingCache = helpers.number(ctx, "startingCache", _startingCache);
+          const extraCache = helpers.number(ctx, "extraCache", _extraCache);
           checkFormulasAccess(ctx);
           return HScalculateCacheUpgradeCost(startingCache, extraCache);
         },
       hashUpgradeCost:
         (ctx: NetscriptContext) =>
         (_upgName: unknown, _level: unknown): number => {
-          const upgName = helper.string("hashUpgradeCost", "upgName", _upgName);
-          const level = ctx.helper.number("level", _level);
+          const upgName = helpers.string(ctx, "upgName", _upgName);
+          const level = helpers.number(ctx, "level", _level);
           checkFormulasAccess(ctx);
           const upg = player.hashManager.getUpgrade(upgName);
           if (!upg) {
-            throw helper.makeRuntimeErrorMsg(
-              "formulas.hacknetServers.calculateHashUpgradeCost",
-              `Invalid Hash Upgrade: ${upgName}`,
-            );
+            throw helpers.makeRuntimeErrorMsg(ctx, `Invalid Hash Upgrade: ${upgName}`);
           }
           return upg.getCost(level);
         },
       hacknetServerCost:
         (ctx: NetscriptContext) =>
         (_n: unknown, _mult: unknown = 1): number => {
-          const n = ctx.helper.number("n", _n);
-          const mult = ctx.helper.number("mult", _mult);
+          const n = helpers.number(ctx, "n", _n);
+          const mult = helpers.number(ctx, "mult", _mult);
           checkFormulasAccess(ctx);
           return HScalculateServerCost(n, mult);
         },
@@ -283,48 +280,48 @@ export function NetscriptFormulas(player: IPlayer, helper: INetscriptHelper): In
       wantedPenalty:
         (ctx: NetscriptContext) =>
         (_gang: unknown): number => {
-          const gang = ctx.helper.gang(_gang);
+          const gang = helpers.gang(ctx, _gang);
           checkFormulasAccess(ctx);
           return calculateWantedPenalty(gang);
         },
       respectGain:
         (ctx: NetscriptContext) =>
         (_gang: unknown, _member: unknown, _task: unknown): number => {
-          const gang = ctx.helper.gang(_gang);
-          const member = ctx.helper.gangMember(_member);
-          const task = ctx.helper.gangTask(_task);
+          const gang = helpers.gang(ctx, _gang);
+          const member = helpers.gangMember(ctx, _member);
+          const task = helpers.gangTask(ctx, _task);
           checkFormulasAccess(ctx);
           return calculateRespectGain(gang, member, task);
         },
       wantedLevelGain:
         (ctx: NetscriptContext) =>
         (_gang: unknown, _member: unknown, _task: unknown): number => {
-          const gang = ctx.helper.gang(_gang);
-          const member = ctx.helper.gangMember(_member);
-          const task = ctx.helper.gangTask(_task);
+          const gang = helpers.gang(ctx, _gang);
+          const member = helpers.gangMember(ctx, _member);
+          const task = helpers.gangTask(ctx, _task);
           checkFormulasAccess(ctx);
           return calculateWantedLevelGain(gang, member, task);
         },
       moneyGain:
         (ctx: NetscriptContext) =>
         (_gang: unknown, _member: unknown, _task: unknown): number => {
-          const gang = ctx.helper.gang(_gang);
-          const member = ctx.helper.gangMember(_member);
-          const task = ctx.helper.gangTask(_task);
+          const gang = helpers.gang(ctx, _gang);
+          const member = helpers.gangMember(ctx, _member);
+          const task = helpers.gangTask(ctx, _task);
           checkFormulasAccess(ctx);
           return calculateMoneyGain(gang, member, task);
         },
       ascensionPointsGain:
         (ctx: NetscriptContext) =>
         (_exp: unknown): number => {
-          const exp = ctx.helper.number("exp", _exp);
+          const exp = helpers.number(ctx, "exp", _exp);
           checkFormulasAccess(ctx);
           return calculateAscensionPointsGain(exp);
         },
       ascensionMultiplier:
         (ctx: NetscriptContext) =>
         (_points: unknown): number => {
-          const points = ctx.helper.number("points", _points);
+          const points = helpers.number(ctx, "points", _points);
           checkFormulasAccess(ctx);
           return calculateAscensionMult(points);
         },
diff --git a/src/NetscriptFunctions/Gang.ts b/src/NetscriptFunctions/Gang.ts
index 8e13bf9ba..69c889397 100644
--- a/src/NetscriptFunctions/Gang.ts
+++ b/src/NetscriptFunctions/Gang.ts
@@ -1,13 +1,13 @@
 import { FactionNames } from "../Faction/data/FactionNames";
 import { GangConstants } from "../Gang/data/Constants";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { Gang } from "../Gang/Gang";
 import { AllGangs } from "../Gang/AllGangs";
 import { GangMemberTasks } from "../Gang/GangMemberTasks";
 import { GangMemberUpgrades } from "../Gang/GangMemberUpgrades";
-import { WorkerScript } from "../Netscript/WorkerScript";
 import { GangMember } from "../Gang/GangMember";
 import { GangMemberTask } from "../Gang/GangMemberTask";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
 import {
   Gang as IGang,
@@ -21,13 +21,13 @@ import {
 } from "../ScriptEditor/NetscriptDefinitions";
 import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
 
-export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): InternalAPI<IGang> {
+export function NetscriptGang(): InternalAPI<IGang> {
   const checkGangApiAccess = function (ctx: NetscriptContext): void {
     const gang = player.gang;
     if (gang === null) throw new Error("Must have joined gang");
     const hasAccess = gang instanceof Gang;
     if (!hasAccess) {
-      throw ctx.makeRuntimeErrorMsg(`You do not currently have a Gang`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `You do not currently have a Gang`);
     }
   };
 
@@ -35,13 +35,13 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     const gang = player.gang;
     if (gang === null) throw new Error("Must have joined gang");
     for (const member of gang.members) if (member.name === name) return member;
-    throw ctx.makeRuntimeErrorMsg(`Invalid gang member: '${name}'`);
+    throw helpers.makeRuntimeErrorMsg(ctx, `Invalid gang member: '${name}'`);
   };
 
   const getGangTask = function (ctx: NetscriptContext, name: string): GangMemberTask {
     const task = GangMemberTasks[name];
     if (!task) {
-      throw ctx.makeRuntimeErrorMsg(`Invalid task: '${name}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid task: '${name}'`);
     }
 
     return task;
@@ -51,7 +51,7 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     createGang:
       (ctx: NetscriptContext) =>
       (_faction: unknown): boolean => {
-        const faction = ctx.helper.string("faction", _faction);
+        const faction = helpers.string(ctx, "faction", _faction);
         // this list is copied from Faction/ui/Root.tsx
 
         if (!player.canAccessGang() || !GangConstants.Names.includes(faction)) return false;
@@ -102,7 +102,7 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     getMemberInformation:
       (ctx: NetscriptContext) =>
       (_memberName: unknown): GangMemberInfo => {
-        const memberName = ctx.helper.string("memberName", _memberName);
+        const memberName = helpers.string(ctx, "memberName", _memberName);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
@@ -163,15 +163,15 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     recruitMember:
       (ctx: NetscriptContext) =>
       (_memberName: unknown): boolean => {
-        const memberName = ctx.helper.string("memberName", _memberName);
+        const memberName = helpers.string(ctx, "memberName", _memberName);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
         const recruited = gang.recruitMember(memberName);
         if (recruited) {
-          workerScript.log("gang.recruitMember", () => `Successfully recruited Gang Member '${memberName}'`);
+          ctx.workerScript.log("gang.recruitMember", () => `Successfully recruited Gang Member '${memberName}'`);
         } else {
-          workerScript.log("gang.recruitMember", () => `Failed to recruit Gang Member '${memberName}'`);
+          ctx.workerScript.log("gang.recruitMember", () => `Failed to recruit Gang Member '${memberName}'`);
         }
 
         return recruited;
@@ -187,14 +187,14 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     setMemberTask:
       (ctx: NetscriptContext) =>
       (_memberName: unknown, _taskName: unknown): boolean => {
-        const memberName = ctx.helper.string("memberName", _memberName);
-        const taskName = ctx.helper.string("taskName", _taskName);
+        const memberName = helpers.string(ctx, "memberName", _memberName);
+        const taskName = helpers.string(ctx, "taskName", _taskName);
         checkGangApiAccess(ctx);
         const member = getGangMember(ctx, memberName);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
         if (!gang.getAllTaskNames().includes(taskName)) {
-          workerScript.log(
+          ctx.workerScript.log(
             "gang.setMemberTask",
             () =>
               `Failed to assign Gang Member '${memberName}' to Invalid task '${taskName}'. '${memberName}' is now Unassigned`,
@@ -203,12 +203,12 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
         }
         const success = member.assignToTask(taskName);
         if (success) {
-          workerScript.log(
+          ctx.workerScript.log(
             "gang.setMemberTask",
             () => `Successfully assigned Gang Member '${memberName}' to '${taskName}' task`,
           );
         } else {
-          workerScript.log(
+          ctx.workerScript.log(
             "gang.setMemberTask",
             () =>
               `Failed to assign Gang Member '${memberName}' to '${taskName}' task. '${memberName}' is now Unassigned`,
@@ -220,7 +220,7 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     getTaskStats:
       (ctx: NetscriptContext) =>
       (_taskName: unknown): GangTaskStats => {
-        const taskName = ctx.helper.string("taskName", _taskName);
+        const taskName = helpers.string(ctx, "taskName", _taskName);
         checkGangApiAccess(ctx);
         const task = getGangTask(ctx, taskName);
         const copy = Object.assign({}, task);
@@ -234,7 +234,7 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     getEquipmentCost:
       (ctx: NetscriptContext) =>
       (_equipName: unknown): number => {
-        const equipName = ctx.helper.string("equipName", _equipName);
+        const equipName = helpers.string(ctx, "equipName", _equipName);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
@@ -245,7 +245,7 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     getEquipmentType:
       (ctx: NetscriptContext) =>
       (_equipName: unknown): string => {
-        const equipName = ctx.helper.string("equipName", _equipName);
+        const equipName = helpers.string(ctx, "equipName", _equipName);
         checkGangApiAccess(ctx);
         const upg = GangMemberUpgrades[equipName];
         if (upg == null) return "";
@@ -254,11 +254,11 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     getEquipmentStats:
       (ctx: NetscriptContext) =>
       (_equipName: unknown): EquipmentStats => {
-        const equipName = ctx.helper.string("equipName", _equipName);
+        const equipName = helpers.string(ctx, "equipName", _equipName);
         checkGangApiAccess(ctx);
         const equipment = GangMemberUpgrades[equipName];
         if (!equipment) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid equipment: ${equipName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid equipment: ${equipName}`);
         }
         const typecheck: EquipmentStats = equipment.mults;
         return Object.assign({}, typecheck) as any;
@@ -266,8 +266,8 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     purchaseEquipment:
       (ctx: NetscriptContext) =>
       (_memberName: unknown, _equipName: unknown): boolean => {
-        const memberName = ctx.helper.string("memberName", _memberName);
-        const equipName = ctx.helper.string("equipName", _equipName);
+        const memberName = helpers.string(ctx, "memberName", _memberName);
+        const equipName = helpers.string(ctx, "equipName", _equipName);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
@@ -276,9 +276,12 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
         if (!equipment) return false;
         const res = member.buyUpgrade(equipment, player, gang);
         if (res) {
-          workerScript.log("gang.purchaseEquipment", () => `Purchased '${equipName}' for Gang member '${memberName}'`);
+          ctx.workerScript.log(
+            "gang.purchaseEquipment",
+            () => `Purchased '${equipName}' for Gang member '${memberName}'`,
+          );
         } else {
-          workerScript.log(
+          ctx.workerScript.log(
             "gang.purchaseEquipment",
             () => `Failed to purchase '${equipName}' for Gang member '${memberName}'`,
           );
@@ -289,18 +292,18 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     ascendMember:
       (ctx: NetscriptContext) =>
       (_memberName: unknown): GangMemberAscension | undefined => {
-        const memberName = ctx.helper.string("memberName", _memberName);
+        const memberName = helpers.string(ctx, "memberName", _memberName);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
         const member = getGangMember(ctx, memberName);
         if (!member.canAscend()) return;
-        return gang.ascendMember(member, workerScript);
+        return gang.ascendMember(member, ctx.workerScript);
       },
     getAscensionResult:
       (ctx: NetscriptContext) =>
       (_memberName: unknown): GangMemberAscension | undefined => {
-        const memberName = ctx.helper.string("memberName", _memberName);
+        const memberName = helpers.string(ctx, "memberName", _memberName);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
@@ -314,27 +317,27 @@ export function NetscriptGang(player: IPlayer, workerScript: WorkerScript): Inte
     setTerritoryWarfare:
       (ctx: NetscriptContext) =>
       (_engage: unknown): void => {
-        const engage = ctx.helper.boolean(_engage);
+        const engage = !!_engage;
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
         if (engage) {
           gang.territoryWarfareEngaged = true;
-          workerScript.log("gang.setTerritoryWarfare", () => "Engaging in Gang Territory Warfare");
+          ctx.workerScript.log("gang.setTerritoryWarfare", () => "Engaging in Gang Territory Warfare");
         } else {
           gang.territoryWarfareEngaged = false;
-          workerScript.log("gang.setTerritoryWarfare", () => "Disengaging in Gang Territory Warfare");
+          ctx.workerScript.log("gang.setTerritoryWarfare", () => "Disengaging in Gang Territory Warfare");
         }
       },
     getChanceToWinClash:
       (ctx: NetscriptContext) =>
       (_otherGang: unknown): number => {
-        const otherGang = ctx.helper.string("otherGang", _otherGang);
+        const otherGang = helpers.string(ctx, "otherGang", _otherGang);
         checkGangApiAccess(ctx);
         const gang = player.gang;
         if (gang === null) throw new Error("Should not be called without Gang");
         if (AllGangs[otherGang] == null) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid gang: ${otherGang}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid gang: ${otherGang}`);
         }
 
         const playerPower = AllGangs[gang.facName].power;
diff --git a/src/NetscriptFunctions/Grafting.ts b/src/NetscriptFunctions/Grafting.ts
index f74e85ba9..1b1623b52 100644
--- a/src/NetscriptFunctions/Grafting.ts
+++ b/src/NetscriptFunctions/Grafting.ts
@@ -4,15 +4,17 @@ import { hasAugmentationPrereqs } from "../Faction/FactionHelpers";
 import { CityName } from "../Locations/data/CityNames";
 import { GraftableAugmentation } from "../PersonObjects/Grafting/GraftableAugmentation";
 import { getGraftingAvailableAugs, calculateGraftingTimeWithBonus } from "../PersonObjects/Grafting/GraftingHelpers";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { Grafting as IGrafting } from "../ScriptEditor/NetscriptDefinitions";
 import { Router } from "../ui/GameRoot";
 import { GraftingWork } from "../Work/GraftingWork";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptGrafting(player: IPlayer): InternalAPI<IGrafting> {
+export function NetscriptGrafting(): InternalAPI<IGrafting> {
   const checkGraftingAPIAccess = (ctx: NetscriptContext): void => {
     if (!player.canAccessGrafting()) {
-      throw ctx.makeRuntimeErrorMsg(
+      throw helpers.makeRuntimeErrorMsg(
+        ctx,
         "You do not currently have access to the Grafting API. This is either because you are not in BitNode 10 or because you do not have Source-File 10",
       );
     }
@@ -22,10 +24,10 @@ export function NetscriptGrafting(player: IPlayer): InternalAPI<IGrafting> {
     getAugmentationGraftPrice:
       (ctx: NetscriptContext) =>
       (_augName: unknown): number => {
-        const augName = ctx.helper.string("augName", _augName);
+        const augName = helpers.string(ctx, "augName", _augName);
         checkGraftingAPIAccess(ctx);
         if (!getGraftingAvailableAugs(player).includes(augName) || !StaticAugmentations.hasOwnProperty(augName)) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid aug: ${augName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid aug: ${augName}`);
         }
         const graftableAug = new GraftableAugmentation(StaticAugmentations[augName]);
         return graftableAug.cost;
@@ -34,10 +36,10 @@ export function NetscriptGrafting(player: IPlayer): InternalAPI<IGrafting> {
     getAugmentationGraftTime:
       (ctx: NetscriptContext) =>
       (_augName: string): number => {
-        const augName = ctx.helper.string("augName", _augName);
+        const augName = helpers.string(ctx, "augName", _augName);
         checkGraftingAPIAccess(ctx);
         if (!getGraftingAvailableAugs(player).includes(augName) || !StaticAugmentations.hasOwnProperty(augName)) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid aug: ${augName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid aug: ${augName}`);
         }
         const graftableAug = new GraftableAugmentation(StaticAugmentations[augName]);
         return calculateGraftingTimeWithBonus(player, graftableAug);
@@ -52,14 +54,14 @@ export function NetscriptGrafting(player: IPlayer): InternalAPI<IGrafting> {
     graftAugmentation:
       (ctx: NetscriptContext) =>
       (_augName: string, _focus: unknown = true): boolean => {
-        const augName = ctx.helper.string("augName", _augName);
-        const focus = ctx.helper.boolean(_focus);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const focus = !!_focus;
         checkGraftingAPIAccess(ctx);
         if (player.city !== CityName.NewTokyo) {
-          throw ctx.makeRuntimeErrorMsg("You must be in New Tokyo to begin grafting an Augmentation.");
+          throw helpers.makeRuntimeErrorMsg(ctx, "You must be in New Tokyo to begin grafting an Augmentation.");
         }
         if (!getGraftingAvailableAugs(player).includes(augName) || !StaticAugmentations.hasOwnProperty(augName)) {
-          ctx.log(() => `Invalid aug: ${augName}`);
+          helpers.log(ctx, () => `Invalid aug: ${augName}`);
           return false;
         }
 
@@ -67,12 +69,12 @@ export function NetscriptGrafting(player: IPlayer): InternalAPI<IGrafting> {
 
         const craftableAug = new GraftableAugmentation(StaticAugmentations[augName]);
         if (player.money < craftableAug.cost) {
-          ctx.log(() => `You don't have enough money to craft ${augName}`);
+          helpers.log(ctx, () => `You don't have enough money to craft ${augName}`);
           return false;
         }
 
         if (!hasAugmentationPrereqs(craftableAug.augmentation)) {
-          ctx.log(() => `You don't have the pre-requisites for ${augName}`);
+          helpers.log(ctx, () => `You don't have the pre-requisites for ${augName}`);
           return false;
         }
 
@@ -92,7 +94,7 @@ export function NetscriptGrafting(player: IPlayer): InternalAPI<IGrafting> {
           Router.toTerminal();
         }
 
-        ctx.log(() => `Began grafting Augmentation ${augName}.`);
+        helpers.log(ctx, () => `Began grafting Augmentation ${augName}.`);
         return true;
       },
   };
diff --git a/src/NetscriptFunctions/Hacknet.ts b/src/NetscriptFunctions/Hacknet.ts
index 8454c4789..7e173ae71 100644
--- a/src/NetscriptFunctions/Hacknet.ts
+++ b/src/NetscriptFunctions/Hacknet.ts
@@ -1,5 +1,4 @@
-import { IPlayer } from "../PersonObjects/IPlayer";
-import { WorkerScript } from "../Netscript/WorkerScript";
+import { Player as player } from "../Player";
 import { HacknetServerConstants } from "../Hacknet/data/Constants";
 import {
   getCostOfNextHacknetNode,
@@ -21,12 +20,13 @@ import { GetServer } from "../Server/AllServers";
 
 import { Hacknet as IHacknet, NodeStats } from "../ScriptEditor/NetscriptDefinitions";
 import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): InternalAPI<IHacknet> {
+export function NetscriptHacknet(): InternalAPI<IHacknet> {
   // Utility function to get Hacknet Node object
   const getHacknetNode = function (ctx: NetscriptContext, i: number): HacknetNode | HacknetServer {
     if (i < 0 || i >= player.hacknetNodes.length) {
-      throw ctx.makeRuntimeErrorMsg("Index specified for Hacknet Node is out-of-bounds: " + i);
+      throw helpers.makeRuntimeErrorMsg(ctx, "Index specified for Hacknet Node is out-of-bounds: " + i);
     }
 
     if (hasHacknetServers(player)) {
@@ -35,7 +35,8 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
       const hserver = GetServer(hi);
       if (!(hserver instanceof HacknetServer)) throw new Error("hacknet server was not actually hacknet server");
       if (hserver == null) {
-        throw ctx.makeRuntimeErrorMsg(
+        throw helpers.makeRuntimeErrorMsg(
+          ctx,
           `Could not get Hacknet Server for index ${i}. This is probably a bug, please report to game dev`,
         );
       }
@@ -71,7 +72,7 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
     getNodeStats:
       (ctx: NetscriptContext) =>
       (_i: unknown): NodeStats => {
-        const i = ctx.helper.number("i", _i);
+        const i = helpers.number(ctx, "i", _i);
         const node = getHacknetNode(ctx, i);
         const hasUpgraded = hasHacknetServers(player);
         const res: NodeStats = {
@@ -95,38 +96,38 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
     upgradeLevel:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): boolean => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         const node = getHacknetNode(ctx, i);
         return purchaseLevelUpgrade(player, node, n);
       },
     upgradeRam:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): boolean => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         const node = getHacknetNode(ctx, i);
         return purchaseRamUpgrade(player, node, n);
       },
     upgradeCore:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): boolean => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         const node = getHacknetNode(ctx, i);
         return purchaseCoreUpgrade(player, node, n);
       },
     upgradeCache:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): boolean => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         if (!hasHacknetServers(player)) {
           return false;
         }
         const node = getHacknetNode(ctx, i);
         if (!(node instanceof HacknetServer)) {
-          workerScript.log("hacknet.upgradeCache", () => "Can only be called on hacknet servers");
+          helpers.log(ctx, () => "Can only be called on hacknet servers");
           return false;
         }
         const res = purchaseCacheUpgrade(player, node, n);
@@ -138,38 +139,38 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
     getLevelUpgradeCost:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): number => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         const node = getHacknetNode(ctx, i);
         return node.calculateLevelUpgradeCost(n, player.mults.hacknet_node_level_cost);
       },
     getRamUpgradeCost:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): number => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         const node = getHacknetNode(ctx, i);
         return node.calculateRamUpgradeCost(n, player.mults.hacknet_node_ram_cost);
       },
     getCoreUpgradeCost:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): number => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         const node = getHacknetNode(ctx, i);
         return node.calculateCoreUpgradeCost(n, player.mults.hacknet_node_core_cost);
       },
     getCacheUpgradeCost:
       (ctx: NetscriptContext) =>
       (_i: unknown, _n: unknown = 1): number => {
-        const i = ctx.helper.number("i", _i);
-        const n = ctx.helper.number("n", _n);
+        const i = helpers.number(ctx, "i", _i);
+        const n = helpers.number(ctx, "n", _n);
         if (!hasHacknetServers(player)) {
           return Infinity;
         }
         const node = getHacknetNode(ctx, i);
         if (!(node instanceof HacknetServer)) {
-          workerScript.log("hacknet.getCacheUpgradeCost", () => "Can only be called on hacknet servers");
+          helpers.log(ctx, () => "Can only be called on hacknet servers");
           return -1;
         }
         return node.calculateCacheUpgradeCost(n);
@@ -189,8 +190,8 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
     hashCost:
       (ctx: NetscriptContext) =>
       (_upgName: unknown, _count: unknown = 1): number => {
-        const upgName = ctx.helper.string("upgName", _upgName);
-        const count = ctx.helper.number("count", _count);
+        const upgName = helpers.string(ctx, "upgName", _upgName);
+        const count = helpers.number(ctx, "count", _count);
         if (!hasHacknetServers(player)) {
           return Infinity;
         }
@@ -200,9 +201,9 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
     spendHashes:
       (ctx: NetscriptContext) =>
       (_upgName: unknown, _upgTarget: unknown = "", _count: unknown = 1): boolean => {
-        const upgName = ctx.helper.string("upgName", _upgName);
-        const upgTarget = ctx.helper.string("upgTarget", _upgTarget);
-        const count = ctx.helper.number("count", _count);
+        const upgName = helpers.string(ctx, "upgName", _upgName);
+        const upgTarget = helpers.string(ctx, "upgTarget", _upgTarget);
+        const count = helpers.number(ctx, "count", _count);
         if (!hasHacknetServers(player)) {
           return false;
         }
@@ -217,10 +218,10 @@ export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript): I
     getHashUpgradeLevel:
       (ctx: NetscriptContext) =>
       (_upgName: unknown): number => {
-        const upgName = ctx.helper.string("upgName", _upgName);
+        const upgName = helpers.string(ctx, "upgName", _upgName);
         const level = player.hashManager.upgrades[upgName];
         if (level === undefined) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid Hash Upgrade: ${upgName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid Hash Upgrade: ${upgName}`);
         }
         return level;
       },
diff --git a/src/NetscriptFunctions/INetscriptHelper.ts b/src/NetscriptFunctions/INetscriptHelper.ts
deleted file mode 100644
index 6d18df6cc..000000000
--- a/src/NetscriptFunctions/INetscriptHelper.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { CityName } from "../Locations/data/CityNames";
-import { NetscriptContext } from "../Netscript/APIWrapper";
-import { IPort } from "../NetscriptPort";
-import { IPlayer } from "../PersonObjects/IPlayer";
-import { Server } from "../Server/Server";
-import { BaseServer } from "../Server/BaseServer";
-import { FormulaGang } from "../Gang/formulas/formulas";
-import { GangMember } from "../Gang/GangMember";
-import { GangMemberTask } from "../Gang/GangMemberTask";
-import { BasicHGWOptions } from "../ScriptEditor/NetscriptDefinitions";
-import { ScriptArg } from "../Netscript/ScriptArg";
-
-export type ScriptIdentifier =
-  | number
-  | {
-      fn: string;
-      hostname: string;
-      args: ScriptArg[];
-    };
-
-export interface INetscriptHelper {
-  updateDynamicRam(functionName: string, ram: number): void;
-  makeRuntimeErrorMsg(functionName: string, message: string): string;
-  string(funcName: string, argName: string, v: unknown): string;
-  number(funcName: string, argName: string, v: unknown): number;
-  ustring(funcName: string, argName: string, v: unknown): string | undefined;
-  unumber(funcName: string, argName: string, v: unknown): number | undefined;
-  scriptArgs(funcName: string, args: unknown): ScriptArg[];
-  scriptIdentifier(funcName: string, fn: unknown, hostname: unknown, args: unknown): ScriptIdentifier;
-  city(funcName: string, argName: string, v: unknown): CityName;
-  boolean(v: unknown): boolean;
-  getServer(ip: string, ctx: NetscriptContext): BaseServer;
-  checkSingularityAccess(func: string): void;
-  hack(ctx: NetscriptContext, hostname: string, manual: boolean, extra?: BasicHGWOptions): Promise<number>;
-  getValidPort(funcName: string, port: number): IPort;
-  player(funcName: string, p: unknown): IPlayer;
-  server(funcName: string, s: unknown): Server;
-  gang(funcName: string, g: unknown): FormulaGang;
-  gangMember(funcName: string, m: unknown): GangMember;
-  gangTask(funcName: string, m: unknown): GangMemberTask;
-}
diff --git a/src/NetscriptFunctions/Infiltration.ts b/src/NetscriptFunctions/Infiltration.ts
index 692abaa50..63f2703a5 100644
--- a/src/NetscriptFunctions/Infiltration.ts
+++ b/src/NetscriptFunctions/Infiltration.ts
@@ -1,4 +1,4 @@
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 
 import {
   Infiltration as IInfiltration,
@@ -18,8 +18,9 @@ import { Factions } from "../Faction/Factions";
 import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
 import { checkEnum } from "../utils/helpers/checkEnum";
 import { LocationName } from "../Locations/data/LocationNames";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptInfiltration(player: IPlayer): InternalAPI<IInfiltration> {
+export function NetscriptInfiltration(): InternalAPI<IInfiltration> {
   const getLocationsWithInfiltrations = Object.values(Locations).filter(
     (location: Location) => location.infiltrationData,
   );
@@ -27,9 +28,9 @@ export function NetscriptInfiltration(player: IPlayer): InternalAPI<IInfiltratio
   const calculateInfiltrationData = (ctx: NetscriptContext, locationName: string): InfiltrationLocation => {
     if (!checkEnum(LocationName, locationName)) throw new Error(`Location '${locationName}' does not exists.`);
     const location = Locations[locationName];
-    if (location === undefined) throw ctx.makeRuntimeErrorMsg(`Location '${location}' does not exists.`);
+    if (location === undefined) throw helpers.makeRuntimeErrorMsg(ctx, `Location '${location}' does not exists.`);
     if (location.infiltrationData === undefined)
-      throw ctx.makeRuntimeErrorMsg(`Location '${location}' does not provide infiltrations.`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Location '${location}' does not provide infiltrations.`);
     const startingSecurityLevel = location.infiltrationData.startingSecurityLevel;
     const difficulty = calculateDifficulty(player, startingSecurityLevel);
     const reward = calculateReward(player, startingSecurityLevel);
@@ -54,7 +55,7 @@ export function NetscriptInfiltration(player: IPlayer): InternalAPI<IInfiltratio
     getInfiltration:
       (ctx: NetscriptContext) =>
       (_location: unknown): InfiltrationLocation => {
-        const location = ctx.helper.string("location", _location);
+        const location = helpers.string(ctx, "location", _location);
         return calculateInfiltrationData(ctx, location);
       },
   };
diff --git a/src/NetscriptFunctions/Singularity.ts b/src/NetscriptFunctions/Singularity.ts
index ff6402bae..74ee8b925 100644
--- a/src/NetscriptFunctions/Singularity.ts
+++ b/src/NetscriptFunctions/Singularity.ts
@@ -1,5 +1,4 @@
-import { WorkerScript } from "../Netscript/WorkerScript";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { purchaseAugmentation, joinFaction, getFactionAugmentationsFiltered } from "../Faction/FactionHelpers";
 import { startWorkerScript } from "../NetscriptWorker";
 import { Augmentation } from "../Augmentation/Augmentation";
@@ -36,7 +35,7 @@ import { Company } from "../Company/Company";
 import { Companies } from "../Company/Companies";
 import { Factions, factionExists } from "../Faction/Factions";
 import { Faction } from "../Faction/Faction";
-import { netscriptDelay } from "../NetscriptEvaluator";
+import { helpers } from "../Netscript/NetscriptHelpers";
 import { convertTimeMsToTimeElapsedString } from "../utils/StringHelperFunctions";
 import { getServerOnNetwork } from "../Server/ServerHelpers";
 import { Terminal } from "../Terminal";
@@ -54,27 +53,27 @@ import { FactionWork } from "../Work/FactionWork";
 import { FactionWorkType } from "../Work/data/FactionWorkType";
 import { CompanyWork } from "../Work/CompanyWork";
 
-export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript): InternalAPI<ISingularity> {
-  const getAugmentation = function (_ctx: NetscriptContext, name: string): Augmentation {
+export function NetscriptSingularity(): InternalAPI<ISingularity> {
+  const getAugmentation = function (ctx: NetscriptContext, name: string): Augmentation {
     if (!augmentationExists(name)) {
-      throw _ctx.helper.makeRuntimeErrorMsg(`Invalid augmentation: '${name}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid augmentation: '${name}'`);
     }
 
     return StaticAugmentations[name];
   };
 
-  const getFaction = function (_ctx: NetscriptContext, name: string): Faction {
+  const getFaction = function (ctx: NetscriptContext, name: string): Faction {
     if (!factionExists(name)) {
-      throw _ctx.helper.makeRuntimeErrorMsg(`Invalid faction name: '${name}`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid faction name: '${name}`);
     }
 
     return Factions[name];
   };
 
-  const getCompany = function (_ctx: NetscriptContext, name: string): Company {
+  const getCompany = function (ctx: NetscriptContext, name: string): Company {
     const company = Companies[name];
     if (company == null || !(company instanceof Company)) {
-      throw _ctx.helper.makeRuntimeErrorMsg(`Invalid company name: '${name}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid company name: '${name}'`);
     }
     return company;
   };
@@ -98,10 +97,10 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
   };
 
   return {
-    getOwnedAugmentations: (_ctx: NetscriptContext) =>
+    getOwnedAugmentations: (ctx: NetscriptContext) =>
       function (_purchased: unknown = false): string[] {
-        _ctx.helper.checkSingularityAccess();
-        const purchased = _ctx.helper.boolean(_purchased);
+        helpers.checkSingularityAccess(ctx);
+        const purchased = !!_purchased;
         const res = [];
         for (let i = 0; i < player.augmentations.length; ++i) {
           res.push(player.augmentations[i].name);
@@ -123,74 +122,74 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
       }
       return res;
     },
-    getAugmentationsFromFaction: (_ctx: NetscriptContext) =>
+    getAugmentationsFromFaction: (ctx: NetscriptContext) =>
       function (_facName: unknown): string[] {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const faction = getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const faction = getFaction(ctx, facName);
 
         return getFactionAugmentationsFiltered(player, faction);
       },
-    getAugmentationCost: (_ctx: NetscriptContext) =>
+    getAugmentationCost: (ctx: NetscriptContext) =>
       function (_augName: unknown): [number, number] {
-        _ctx.helper.checkSingularityAccess();
-        const augName = _ctx.helper.string("augName", _augName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const aug = getAugmentation(ctx, augName);
         const costs = aug.getCost(player);
         return [costs.repCost, costs.moneyCost];
       },
-    getAugmentationPrereq: (_ctx: NetscriptContext) =>
+    getAugmentationPrereq: (ctx: NetscriptContext) =>
       function (_augName: unknown): string[] {
-        _ctx.helper.checkSingularityAccess();
-        const augName = _ctx.helper.string("augName", _augName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const aug = getAugmentation(ctx, augName);
         return aug.prereqs.slice();
       },
-    getAugmentationBasePrice: (_ctx: NetscriptContext) =>
+    getAugmentationBasePrice: (ctx: NetscriptContext) =>
       function (_augName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const augName = _ctx.helper.string("augName", _augName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const aug = getAugmentation(ctx, augName);
         return aug.baseCost * BitNodeMultipliers.AugmentationMoneyCost;
       },
-    getAugmentationPrice: (_ctx: NetscriptContext) =>
+    getAugmentationPrice: (ctx: NetscriptContext) =>
       function (_augName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const augName = _ctx.helper.string("augName", _augName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const aug = getAugmentation(ctx, augName);
         return aug.getCost(player).moneyCost;
       },
-    getAugmentationRepReq: (_ctx: NetscriptContext) =>
+    getAugmentationRepReq: (ctx: NetscriptContext) =>
       function (_augName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const augName = _ctx.helper.string("augName", _augName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const aug = getAugmentation(ctx, augName);
         return aug.getCost(player).repCost;
       },
-    getAugmentationStats: (_ctx: NetscriptContext) =>
+    getAugmentationStats: (ctx: NetscriptContext) =>
       function (_augName: unknown): AugmentationStats {
-        _ctx.helper.checkSingularityAccess();
-        const augName = _ctx.helper.string("augName", _augName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const aug = getAugmentation(ctx, augName);
         return Object.assign({}, aug.mults);
       },
-    purchaseAugmentation: (_ctx: NetscriptContext) =>
+    purchaseAugmentation: (ctx: NetscriptContext) =>
       function (_facName: unknown, _augName: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const augName = _ctx.helper.string("augName", _augName);
-        const fac = getFaction(_ctx, facName);
-        const aug = getAugmentation(_ctx, augName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const augName = helpers.string(ctx, "augName", _augName);
+        const fac = getFaction(ctx, facName);
+        const aug = getAugmentation(ctx, augName);
 
         const augs = getFactionAugmentationsFiltered(player, fac);
 
         if (!player.factions.includes(fac.name)) {
-          _ctx.log(() => `You can't purchase augmentations from '${facName}' because you aren't a member`);
+          helpers.log(ctx, () => `You can't purchase augmentations from '${facName}' because you aren't a member`);
           return false;
         }
 
         if (!augs.includes(augName)) {
-          _ctx.log(() => `Faction '${facName}' does not have the '${augName}' augmentation.`);
+          helpers.log(ctx, () => `Faction '${facName}' does not have the '${augName}' augmentation.`);
           return false;
         }
 
@@ -198,25 +197,25 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         if (!isNeuroflux) {
           for (let j = 0; j < player.queuedAugmentations.length; ++j) {
             if (player.queuedAugmentations[j].name === aug.name) {
-              _ctx.log(() => `You already have the '${augName}' augmentation.`);
+              helpers.log(ctx, () => `You already have the '${augName}' augmentation.`);
               return false;
             }
           }
           for (let j = 0; j < player.augmentations.length; ++j) {
             if (player.augmentations[j].name === aug.name) {
-              _ctx.log(() => `You already have the '${augName}' augmentation.`);
+              helpers.log(ctx, () => `You already have the '${augName}' augmentation.`);
               return false;
             }
           }
         }
 
         if (fac.playerReputation < aug.getCost(player).repCost) {
-          _ctx.log(() => `You do not have enough reputation with '${fac.name}'.`);
+          helpers.log(ctx, () => `You do not have enough reputation with '${fac.name}'.`);
           return false;
         }
 
         const res = purchaseAugmentation(aug, fac, true);
-        _ctx.log(() => res);
+        helpers.log(ctx, () => res);
         if (isString(res) && res.startsWith("You purchased")) {
           player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain * 10);
           return true;
@@ -224,53 +223,53 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           return false;
         }
       },
-    softReset: (_ctx: NetscriptContext) =>
+    softReset: (ctx: NetscriptContext) =>
       function (_cbScript: unknown = ""): void {
-        _ctx.helper.checkSingularityAccess();
-        const cbScript = _ctx.helper.string("cbScript", _cbScript);
+        helpers.checkSingularityAccess(ctx);
+        const cbScript = helpers.string(ctx, "cbScript", _cbScript);
 
-        _ctx.log(() => "Soft resetting. This will cause this script to be killed");
+        helpers.log(ctx, () => "Soft resetting. This will cause this script to be killed");
         setTimeout(() => {
           installAugmentations(true);
           runAfterReset(cbScript);
         }, 0);
 
-        // Prevent workerScript from "finishing execution naturally"
-        workerScript.running = false;
-        killWorkerScript(workerScript);
+        // Prevent ctx.workerScript from "finishing execution naturally"
+        ctx.workerScript.running = false;
+        killWorkerScript(ctx.workerScript);
       },
-    installAugmentations: (_ctx: NetscriptContext) =>
+    installAugmentations: (ctx: NetscriptContext) =>
       function (_cbScript: unknown = ""): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const cbScript = _ctx.helper.string("cbScript", _cbScript);
+        helpers.checkSingularityAccess(ctx);
+        const cbScript = helpers.string(ctx, "cbScript", _cbScript);
 
         if (player.queuedAugmentations.length === 0) {
-          _ctx.log(() => "You do not have any Augmentations to be installed.");
+          helpers.log(ctx, () => "You do not have any Augmentations to be installed.");
           return false;
         }
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain * 10);
-        _ctx.log(() => "Installing Augmentations. This will cause this script to be killed");
+        helpers.log(ctx, () => "Installing Augmentations. This will cause this script to be killed");
         setTimeout(() => {
           installAugmentations();
           runAfterReset(cbScript);
         }, 0);
 
-        workerScript.running = false; // Prevent workerScript from "finishing execution naturally"
-        killWorkerScript(workerScript);
+        ctx.workerScript.running = false; // Prevent ctx.workerScript from "finishing execution naturally"
+        killWorkerScript(ctx.workerScript);
         return true;
       },
 
-    goToLocation: (_ctx: NetscriptContext) =>
+    goToLocation: (ctx: NetscriptContext) =>
       function (_locationName: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const locationName = _ctx.helper.string("locationName", _locationName);
+        helpers.checkSingularityAccess(ctx);
+        const locationName = helpers.string(ctx, "locationName", _locationName);
         const location = Object.values(Locations).find((l) => l.name === locationName);
         if (!location) {
-          _ctx.log(() => `No location named ${locationName}`);
+          helpers.log(ctx, () => `No location named ${locationName}`);
           return false;
         }
         if (location.city && player.city !== location.city) {
-          _ctx.log(() => `No location named ${locationName} in ${player.city}`);
+          helpers.log(ctx, () => `No location named ${locationName} in ${player.city}`);
           return false;
         }
         if (location.name === LocationName.TravelAgency) {
@@ -283,32 +282,39 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain / 50000);
         return true;
       },
-    universityCourse: (_ctx: NetscriptContext) =>
+    universityCourse: (ctx: NetscriptContext) =>
       function (_universityName: unknown, _className: unknown, _focus: unknown = true): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const universityName = _ctx.helper.string("universityName", _universityName);
-        const className = _ctx.helper.string("className", _className);
-        const focus = _ctx.helper.boolean(_focus);
+        helpers.checkSingularityAccess(ctx);
+        const universityName = helpers.string(ctx, "universityName", _universityName);
+        const className = helpers.string(ctx, "className", _className);
+        const focus = !!_focus;
         const wasFocusing = player.focus;
 
         switch (universityName.toLowerCase()) {
           case LocationName.AevumSummitUniversity.toLowerCase():
             if (player.city != CityName.Aevum) {
-              _ctx.log(() => `You cannot study at 'Summit University' because you are not in '${CityName.Aevum}'.`);
+              helpers.log(
+                ctx,
+                () => `You cannot study at 'Summit University' because you are not in '${CityName.Aevum}'.`,
+              );
               return false;
             }
             player.gotoLocation(LocationName.AevumSummitUniversity);
             break;
           case LocationName.Sector12RothmanUniversity.toLowerCase():
             if (player.city != CityName.Sector12) {
-              _ctx.log(() => `You cannot study at 'Rothman University' because you are not in '${CityName.Sector12}'.`);
+              helpers.log(
+                ctx,
+                () => `You cannot study at 'Rothman University' because you are not in '${CityName.Sector12}'.`,
+              );
               return false;
             }
             player.location = LocationName.Sector12RothmanUniversity;
             break;
           case LocationName.VolhavenZBInstituteOfTechnology.toLowerCase():
             if (player.city != CityName.Volhaven) {
-              _ctx.log(
+              helpers.log(
+                ctx,
                 () => `You cannot study at 'ZB Institute of Technology' because you are not in '${CityName.Volhaven}'.`,
               );
               return false;
@@ -316,7 +322,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             player.location = LocationName.VolhavenZBInstituteOfTechnology;
             break;
           default:
-            _ctx.log(() => `Invalid university name: '${universityName}'.`);
+            helpers.log(ctx, () => `Invalid university name: '${universityName}'.`);
             return false;
         }
 
@@ -341,7 +347,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             task = ClassType.Leadership;
             break;
           default:
-            _ctx.log(() => `Invalid class name: ${className}.`);
+            helpers.log(ctx, () => `Invalid class name: ${className}.`);
             return false;
         }
         player.startWork(
@@ -358,22 +364,23 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           player.stopFocusing();
           Router.toTerminal();
         }
-        _ctx.log(() => `Started ${task} at ${universityName}`);
+        helpers.log(ctx, () => `Started ${task} at ${universityName}`);
         return true;
       },
 
-    gymWorkout: (_ctx: NetscriptContext) =>
+    gymWorkout: (ctx: NetscriptContext) =>
       function (_gymName: unknown, _stat: unknown, _focus: unknown = true): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const gymName = _ctx.helper.string("gymName", _gymName);
-        const stat = _ctx.helper.string("stat", _stat);
-        const focus = _ctx.helper.boolean(_focus);
+        helpers.checkSingularityAccess(ctx);
+        const gymName = helpers.string(ctx, "gymName", _gymName);
+        const stat = helpers.string(ctx, "stat", _stat);
+        const focus = !!_focus;
         const wasFocusing = player.focus;
 
         switch (gymName.toLowerCase()) {
           case LocationName.AevumCrushFitnessGym.toLowerCase():
             if (player.city != CityName.Aevum) {
-              _ctx.log(
+              helpers.log(
+                ctx,
                 () =>
                   `You cannot workout at '${LocationName.AevumCrushFitnessGym}' because you are not in '${CityName.Aevum}'.`,
               );
@@ -383,7 +390,8 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             break;
           case LocationName.AevumSnapFitnessGym.toLowerCase():
             if (player.city != CityName.Aevum) {
-              _ctx.log(
+              helpers.log(
+                ctx,
                 () =>
                   `You cannot workout at '${LocationName.AevumSnapFitnessGym}' because you are not in '${CityName.Aevum}'.`,
               );
@@ -393,7 +401,8 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             break;
           case LocationName.Sector12IronGym.toLowerCase():
             if (player.city != CityName.Sector12) {
-              _ctx.log(
+              helpers.log(
+                ctx,
                 () =>
                   `You cannot workout at '${LocationName.Sector12IronGym}' because you are not in '${CityName.Sector12}'.`,
               );
@@ -403,7 +412,8 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             break;
           case LocationName.Sector12PowerhouseGym.toLowerCase():
             if (player.city != CityName.Sector12) {
-              _ctx.log(
+              helpers.log(
+                ctx,
                 () =>
                   `You cannot workout at '${LocationName.Sector12PowerhouseGym}' because you are not in '${CityName.Sector12}'.`,
               );
@@ -413,7 +423,8 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             break;
           case LocationName.VolhavenMilleniumFitnessGym.toLowerCase():
             if (player.city != CityName.Volhaven) {
-              _ctx.log(
+              helpers.log(
+                ctx,
                 () =>
                   `You cannot workout at '${LocationName.VolhavenMilleniumFitnessGym}' because you are not in '${CityName.Volhaven}'.`,
               );
@@ -422,7 +433,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             player.location = LocationName.VolhavenMilleniumFitnessGym;
             break;
           default:
-            _ctx.log(() => `Invalid gym name: ${gymName}. gymWorkout() failed`);
+            helpers.log(ctx, () => `Invalid gym name: ${gymName}. gymWorkout() failed`);
             return false;
         }
 
@@ -452,7 +463,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             );
             break;
           default:
-            _ctx.log(() => `Invalid stat: ${stat}.`);
+            helpers.log(ctx, () => `Invalid stat: ${stat}.`);
             return false;
         }
         if (focus) {
@@ -462,14 +473,14 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           player.stopFocusing();
           Router.toTerminal();
         }
-        _ctx.log(() => `Started training ${stat} at ${gymName}`);
+        helpers.log(ctx, () => `Started training ${stat} at ${gymName}`);
         return true;
       },
 
-    travelToCity: (_ctx: NetscriptContext) =>
+    travelToCity: (ctx: NetscriptContext) =>
       function (_cityName: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const cityName = _ctx.helper.city("cityName", _cityName);
+        helpers.checkSingularityAccess(ctx);
+        const cityName = helpers.city(ctx, "cityName", _cityName);
 
         switch (cityName) {
           case CityName.Aevum:
@@ -479,68 +490,69 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           case CityName.Ishima:
           case CityName.Volhaven:
             if (player.money < CONSTANTS.TravelCost) {
-              _ctx.log(() => "Not enough money to travel.");
+              helpers.log(ctx, () => "Not enough money to travel.");
               return false;
             }
             player.loseMoney(CONSTANTS.TravelCost, "other");
             player.city = cityName;
-            _ctx.log(() => `Traveled to ${cityName}`);
+            helpers.log(ctx, () => `Traveled to ${cityName}`);
             player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain / 50000);
             return true;
           default:
-            throw _ctx.helper.makeRuntimeErrorMsg(`Invalid city name: '${cityName}'.`);
+            throw helpers.makeRuntimeErrorMsg(ctx, `Invalid city name: '${cityName}'.`);
         }
       },
 
-    purchaseTor: (_ctx: NetscriptContext) =>
+    purchaseTor: (ctx: NetscriptContext) =>
       function (): boolean {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
 
         if (player.hasTorRouter()) {
-          _ctx.log(() => "You already have a TOR router!");
+          helpers.log(ctx, () => "You already have a TOR router!");
           return true;
         }
 
         if (player.money < CONSTANTS.TorRouterCost) {
-          _ctx.log(() => "You cannot afford to purchase a Tor router.");
+          helpers.log(ctx, () => "You cannot afford to purchase a Tor router.");
           return false;
         }
         player.loseMoney(CONSTANTS.TorRouterCost, "other");
 
         const darkweb = GetServer(SpecialServers.DarkWeb);
-        if (!darkweb) throw _ctx.makeRuntimeErrorMsg("DarkWeb was not a server but should have been");
+        if (!darkweb) throw helpers.makeRuntimeErrorMsg(ctx, "DarkWeb was not a server but should have been");
 
         player.getHomeComputer().serversOnNetwork.push(darkweb.hostname);
         darkweb.serversOnNetwork.push(player.getHomeComputer().hostname);
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain / 500);
-        _ctx.log(() => "You have purchased a Tor router!");
+        helpers.log(ctx, () => "You have purchased a Tor router!");
         return true;
       },
-    purchaseProgram: (_ctx: NetscriptContext) =>
+    purchaseProgram: (ctx: NetscriptContext) =>
       function (_programName: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const programName = _ctx.helper.string("programName", _programName).toLowerCase();
+        helpers.checkSingularityAccess(ctx);
+        const programName = helpers.string(ctx, "programName", _programName).toLowerCase();
 
         if (!player.hasTorRouter()) {
-          _ctx.log(() => "You do not have the TOR router.");
+          helpers.log(ctx, () => "You do not have the TOR router.");
           return false;
         }
 
         const item = Object.values(DarkWebItems).find((i) => i.program.toLowerCase() === programName);
         if (item == null) {
-          _ctx.log(() => `Invalid program name: '${programName}.`);
+          helpers.log(ctx, () => `Invalid program name: '${programName}.`);
           return false;
         }
 
         if (player.money < item.price) {
-          _ctx.log(
+          helpers.log(
+            ctx,
             () => `Not enough money to purchase '${item.program}'. Need ${numeralWrapper.formatMoney(item.price)}`,
           );
           return false;
         }
 
         if (player.hasProgram(item.program)) {
-          _ctx.log(() => `You already have the '${item.program}' program`);
+          helpers.log(ctx, () => `You already have the '${item.program}' program`);
           return true;
         }
 
@@ -551,28 +563,29 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         }
 
         player.loseMoney(item.price, "other");
-        _ctx.log(
+        helpers.log(
+          ctx,
           () => `You have purchased the '${item.program}' program. The new program can be found on your home computer.`,
         );
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain / 5000);
         return true;
       },
-    getCurrentServer: (_ctx: NetscriptContext) =>
+    getCurrentServer: (ctx: NetscriptContext) =>
       function (): string {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         return player.getCurrentServer().hostname;
       },
-    connect: (_ctx: NetscriptContext) =>
+    connect: (ctx: NetscriptContext) =>
       function (_hostname: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const hostname = _ctx.helper.string("hostname", _hostname);
+        helpers.checkSingularityAccess(ctx);
+        const hostname = helpers.string(ctx, "hostname", _hostname);
         if (!hostname) {
-          throw _ctx.helper.makeRuntimeErrorMsg(`Invalid hostname: '${hostname}'`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid hostname: '${hostname}'`);
         }
 
         const target = GetServer(hostname);
         if (target == null) {
-          throw _ctx.helper.makeRuntimeErrorMsg(`Invalid hostname: '${hostname}'`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid hostname: '${hostname}'`);
         }
 
         //Home case
@@ -611,17 +624,17 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         //Failure case
         return false;
       },
-    manualHack: (_ctx: NetscriptContext) =>
+    manualHack: (ctx: NetscriptContext) =>
       function (): Promise<number> {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         const server = player.getCurrentServer();
-        return _ctx.helper.hack(server.hostname, true);
+        return helpers.hack(ctx, server.hostname, true);
       },
-    installBackdoor: (_ctx: NetscriptContext) => async (): Promise<void> => {
-      _ctx.helper.checkSingularityAccess();
+    installBackdoor: (ctx: NetscriptContext) => async (): Promise<void> => {
+      helpers.checkSingularityAccess(ctx);
       const baseserver = player.getCurrentServer();
       if (!(baseserver instanceof Server)) {
-        _ctx.log(() => "cannot backdoor this kind of server");
+        helpers.log(ctx, () => "cannot backdoor this kind of server");
         return Promise.resolve();
       }
       const server = baseserver;
@@ -630,15 +643,16 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
       // No root access or skill level too low
       const canHack = netscriptCanHack(server, player);
       if (!canHack.res) {
-        throw _ctx.helper.makeRuntimeErrorMsg(canHack.msg || "");
+        throw helpers.makeRuntimeErrorMsg(ctx, canHack.msg || "");
       }
 
-      _ctx.log(
+      helpers.log(
+        ctx,
         () => `Installing backdoor on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(installTime, true)}`,
       );
 
-      return netscriptDelay(installTime, workerScript).then(function () {
-        _ctx.log(() => `Successfully installed backdoor on '${server.hostname}'`);
+      return helpers.netscriptDelay(ctx, installTime).then(function () {
+        helpers.log(ctx, () => `Successfully installed backdoor on '${server.hostname}'`);
 
         server.backdoorInstalled = true;
 
@@ -648,17 +662,17 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         return Promise.resolve();
       });
     },
-    isFocused: (_ctx: NetscriptContext) =>
+    isFocused: (ctx: NetscriptContext) =>
       function (): boolean {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         return player.focus;
       },
-    setFocus: (_ctx: NetscriptContext) =>
+    setFocus: (ctx: NetscriptContext) =>
       function (_focus: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const focus = _ctx.helper.boolean(_focus);
+        helpers.checkSingularityAccess(ctx);
+        const focus = !!_focus;
         if (player.currentWork === null) {
-          throw _ctx.helper.makeRuntimeErrorMsg("Not currently working");
+          throw helpers.makeRuntimeErrorMsg(ctx, "Not currently working");
         }
 
         if (!player.focus && focus) {
@@ -672,41 +686,41 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         }
         return false;
       },
-    hospitalize: (_ctx: NetscriptContext) =>
+    hospitalize: (ctx: NetscriptContext) =>
       function (): void {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         if (player.currentWork || Router.page() === Page.Infiltration || Router.page() === Page.BitVerse) {
-          _ctx.log(() => "Cannot go to the hospital because the player is busy.");
+          helpers.log(ctx, () => "Cannot go to the hospital because the player is busy.");
           return;
         }
         player.hospitalize();
       },
-    isBusy: (_ctx: NetscriptContext) =>
+    isBusy: (ctx: NetscriptContext) =>
       function (): boolean {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         return player.currentWork !== null || Router.page() === Page.Infiltration || Router.page() === Page.BitVerse;
       },
-    stopAction: (_ctx: NetscriptContext) =>
+    stopAction: (ctx: NetscriptContext) =>
       function (): boolean {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         const wasWorking = player.currentWork !== null;
         player.finishWork(true);
         return wasWorking;
       },
-    upgradeHomeCores: (_ctx: NetscriptContext) =>
+    upgradeHomeCores: (ctx: NetscriptContext) =>
       function (): boolean {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
 
         // Check if we're at max cores
         const homeComputer = player.getHomeComputer();
         if (homeComputer.cpuCores >= 8) {
-          _ctx.log(() => `Your home computer is at max cores.`);
+          helpers.log(ctx, () => `Your home computer is at max cores.`);
           return false;
         }
 
         const cost = player.getUpgradeHomeCoresCost();
         if (player.money < cost) {
-          _ctx.log(() => `You don't have enough money. Need ${numeralWrapper.formatMoney(cost)}`);
+          helpers.log(ctx, () => `You don't have enough money. Need ${numeralWrapper.formatMoney(cost)}`);
           return false;
         }
 
@@ -714,29 +728,32 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         player.loseMoney(cost, "servers");
 
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain * 2);
-        _ctx.log(() => `Purchased an additional core for home computer! It now has ${homeComputer.cpuCores} cores.`);
+        helpers.log(
+          ctx,
+          () => `Purchased an additional core for home computer! It now has ${homeComputer.cpuCores} cores.`,
+        );
         return true;
       },
-    getUpgradeHomeCoresCost: (_ctx: NetscriptContext) =>
+    getUpgradeHomeCoresCost: (ctx: NetscriptContext) =>
       function (): number {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
 
         return player.getUpgradeHomeCoresCost();
       },
-    upgradeHomeRam: (_ctx: NetscriptContext) =>
+    upgradeHomeRam: (ctx: NetscriptContext) =>
       function (): boolean {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
 
         // Check if we're at max RAM
         const homeComputer = player.getHomeComputer();
         if (homeComputer.maxRam >= CONSTANTS.HomeComputerMaxRam) {
-          _ctx.log(() => `Your home computer is at max RAM.`);
+          helpers.log(ctx, () => `Your home computer is at max RAM.`);
           return false;
         }
 
         const cost = player.getUpgradeHomeRamCost();
         if (player.money < cost) {
-          _ctx.log(() => `You don't have enough money. Need ${numeralWrapper.formatMoney(cost)}`);
+          helpers.log(ctx, () => `You don't have enough money. Need ${numeralWrapper.formatMoney(cost)}`);
           return false;
         }
 
@@ -744,7 +761,8 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         player.loseMoney(cost, "servers");
 
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain * 2);
-        _ctx.log(
+        helpers.log(
+          ctx,
           () =>
             `Purchased additional RAM for home computer! It now has ${numeralWrapper.formatRAM(
               homeComputer.maxRam,
@@ -752,27 +770,27 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         );
         return true;
       },
-    getUpgradeHomeRamCost: (_ctx: NetscriptContext) =>
+    getUpgradeHomeRamCost: (ctx: NetscriptContext) =>
       function (): number {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
 
         return player.getUpgradeHomeRamCost();
       },
-    workForCompany: (_ctx: NetscriptContext) =>
+    workForCompany: (ctx: NetscriptContext) =>
       function (_companyName: unknown, _focus: unknown = true): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const companyName = _ctx.helper.string("companyName", _companyName);
-        const focus = _ctx.helper.boolean(_focus);
+        helpers.checkSingularityAccess(ctx);
+        const companyName = helpers.string(ctx, "companyName", _companyName);
+        const focus = !_focus;
 
         // Make sure its a valid company
         if (companyName == null || companyName === "" || !(Companies[companyName] instanceof Company)) {
-          _ctx.log(() => `Invalid company: '${companyName}'`);
+          helpers.log(ctx, () => `Invalid company: '${companyName}'`);
           return false;
         }
 
         // Make sure player is actually employed at the comapny
         if (!Object.keys(player.jobs).includes(companyName)) {
-          _ctx.log(() => `You do not have a job at '${companyName}'`);
+          helpers.log(ctx, () => `You do not have a job at '${companyName}'`);
           return false;
         }
 
@@ -780,7 +798,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         const companyPositionName = player.jobs[companyName];
         const companyPosition = CompanyPositions[companyPositionName];
         if (companyPositionName === "" || !(companyPosition instanceof CompanyPosition)) {
-          _ctx.log(() => "You do not have a job");
+          helpers.log(ctx, () => "You do not have a job");
           return false;
         }
 
@@ -799,15 +817,15 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           player.stopFocusing();
           Router.toTerminal();
         }
-        _ctx.log(() => `Began working at '${companyName}' as a '${companyPositionName}'`);
+        helpers.log(ctx, () => `Began working at '${companyName}' as a '${companyPositionName}'`);
         return true;
       },
-    applyToCompany: (_ctx: NetscriptContext) =>
+    applyToCompany: (ctx: NetscriptContext) =>
       function (_companyName: unknown, _field: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const companyName = _ctx.helper.string("companyName", _companyName);
-        const field = _ctx.helper.string("field", _field);
-        getCompany(_ctx, companyName);
+        helpers.checkSingularityAccess(ctx);
+        const companyName = helpers.string(ctx, "companyName", _companyName);
+        const field = helpers.string(ctx, "field", _field);
+        getCompany(ctx, companyName);
 
         player.location = companyName as LocationName;
         let res;
@@ -852,63 +870,63 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
             res = player.applyForPartTimeWaiterJob(true);
             break;
           default:
-            _ctx.log(() => `Invalid job: '${field}'.`);
+            helpers.log(ctx, () => `Invalid job: '${field}'.`);
             return false;
         }
         // TODO https://github.com/danielyxie/bitburner/issues/1378
         // The player object's applyForJob function can return string with special error messages
         // if (isString(res)) {
-        //   _ctx.log("applyToCompany",()=> res);
+        //   helpers.log(ctx,"applyToCompany",()=> res);
         //   return false;
         // }
         if (res) {
-          _ctx.log(() => `You were offered a new job at '${companyName}' as a '${player.jobs[companyName]}'`);
+          helpers.log(ctx, () => `You were offered a new job at '${companyName}' as a '${player.jobs[companyName]}'`);
         } else {
-          _ctx.log(() => `You failed to get a new job/promotion at '${companyName}' in the '${field}' field.`);
+          helpers.log(ctx, () => `You failed to get a new job/promotion at '${companyName}' in the '${field}' field.`);
         }
         return res;
       },
-    quitJob: (_ctx: NetscriptContext) =>
+    quitJob: (ctx: NetscriptContext) =>
       function (_companyName: unknown): void {
-        _ctx.helper.checkSingularityAccess();
-        const companyName = _ctx.helper.string("companyName", _companyName);
+        helpers.checkSingularityAccess(ctx);
+        const companyName = helpers.string(ctx, "companyName", _companyName);
         player.quitJob(companyName);
       },
-    getCompanyRep: (_ctx: NetscriptContext) =>
+    getCompanyRep: (ctx: NetscriptContext) =>
       function (_companyName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const companyName = _ctx.helper.string("companyName", _companyName);
-        const company = getCompany(_ctx, companyName);
+        helpers.checkSingularityAccess(ctx);
+        const companyName = helpers.string(ctx, "companyName", _companyName);
+        const company = getCompany(ctx, companyName);
         return company.playerReputation;
       },
-    getCompanyFavor: (_ctx: NetscriptContext) =>
+    getCompanyFavor: (ctx: NetscriptContext) =>
       function (_companyName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const companyName = _ctx.helper.string("companyName", _companyName);
-        const company = getCompany(_ctx, companyName);
+        helpers.checkSingularityAccess(ctx);
+        const companyName = helpers.string(ctx, "companyName", _companyName);
+        const company = getCompany(ctx, companyName);
         return company.favor;
       },
-    getCompanyFavorGain: (_ctx: NetscriptContext) =>
+    getCompanyFavorGain: (ctx: NetscriptContext) =>
       function (_companyName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const companyName = _ctx.helper.string("companyName", _companyName);
-        const company = getCompany(_ctx, companyName);
+        helpers.checkSingularityAccess(ctx);
+        const companyName = helpers.string(ctx, "companyName", _companyName);
+        const company = getCompany(ctx, companyName);
         return company.getFavorGain();
       },
-    checkFactionInvitations: (_ctx: NetscriptContext) =>
+    checkFactionInvitations: (ctx: NetscriptContext) =>
       function (): string[] {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
         // Make a copy of player.factionInvitations
         return player.factionInvitations.slice();
       },
-    joinFaction: (_ctx: NetscriptContext) =>
+    joinFaction: (ctx: NetscriptContext) =>
       function (_facName: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        getFaction(ctx, facName);
 
         if (!player.factionInvitations.includes(facName)) {
-          _ctx.log(() => `You have not been invited by faction '${facName}'`);
+          helpers.log(ctx, () => `You have not been invited by faction '${facName}'`);
           return false;
         }
         const fac = Factions[facName];
@@ -922,25 +940,25 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           }
         }
         player.gainIntelligenceExp(CONSTANTS.IntelligenceSingFnBaseExpGain * 5);
-        _ctx.log(() => `Joined the '${facName}' faction.`);
+        helpers.log(ctx, () => `Joined the '${facName}' faction.`);
         return true;
       },
-    workForFaction: (_ctx: NetscriptContext) =>
+    workForFaction: (ctx: NetscriptContext) =>
       function (_facName: unknown, _type: unknown, _focus: unknown = true): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const type = _ctx.helper.string("type", _type);
-        const focus = _ctx.helper.boolean(_focus);
-        const faction = getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const type = helpers.string(ctx, "type", _type);
+        const focus = !!_focus;
+        const faction = getFaction(ctx, facName);
 
         // if the player is in a gang and the target faction is any of the gang faction, fail
         if (player.inGang() && faction.name === player.getGangFaction().name) {
-          _ctx.log(() => `You can't work for '${facName}' because youre managing a gang for it`);
+          helpers.log(ctx, () => `You can't work for '${facName}' because youre managing a gang for it`);
           return false;
         }
 
         if (!player.factions.includes(facName)) {
-          _ctx.log(() => `You are not a member of '${facName}'`);
+          helpers.log(ctx, () => `You are not a member of '${facName}'`);
           return false;
         }
 
@@ -951,7 +969,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           case "hacking contracts":
           case "hackingcontracts":
             if (!FactionInfos[faction.name].offerHackingWork) {
-              _ctx.log(() => `Faction '${faction.name}' do not need help with hacking contracts.`);
+              helpers.log(ctx, () => `Faction '${faction.name}' do not need help with hacking contracts.`);
               return false;
             }
             player.startWork(
@@ -968,13 +986,13 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
               player.stopFocusing();
               Router.toTerminal();
             }
-            _ctx.log(() => `Started carrying out hacking contracts for '${faction.name}'`);
+            helpers.log(ctx, () => `Started carrying out hacking contracts for '${faction.name}'`);
             return true;
           case "field":
           case "fieldwork":
           case "field work":
             if (!FactionInfos[faction.name].offerFieldWork) {
-              _ctx.log(() => `Faction '${faction.name}' do not need help with field missions.`);
+              helpers.log(ctx, () => `Faction '${faction.name}' do not need help with field missions.`);
               return false;
             }
             player.startWork(
@@ -991,13 +1009,13 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
               player.stopFocusing();
               Router.toTerminal();
             }
-            _ctx.log(() => `Started carrying out field missions for '${faction.name}'`);
+            helpers.log(ctx, () => `Started carrying out field missions for '${faction.name}'`);
             return true;
           case "security":
           case "securitywork":
           case "security work":
             if (!FactionInfos[faction.name].offerSecurityWork) {
-              _ctx.log(() => `Faction '${faction.name}' do not need help with security work.`);
+              helpers.log(ctx, () => `Faction '${faction.name}' do not need help with security work.`);
               return false;
             }
             player.startWork(
@@ -1014,63 +1032,67 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
               player.stopFocusing();
               Router.toTerminal();
             }
-            _ctx.log(() => `Started carrying out security work for '${faction.name}'`);
+            helpers.log(ctx, () => `Started carrying out security work for '${faction.name}'`);
             return true;
           default:
-            _ctx.log(() => `Invalid work type: '${type}`);
+            helpers.log(ctx, () => `Invalid work type: '${type}`);
             return false;
         }
       },
-    getFactionRep: (_ctx: NetscriptContext) =>
+    getFactionRep: (ctx: NetscriptContext) =>
       function (_facName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const faction = getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const faction = getFaction(ctx, facName);
         return faction.playerReputation;
       },
-    getFactionFavor: (_ctx: NetscriptContext) =>
+    getFactionFavor: (ctx: NetscriptContext) =>
       function (_facName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const faction = getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const faction = getFaction(ctx, facName);
         return faction.favor;
       },
-    getFactionFavorGain: (_ctx: NetscriptContext) =>
+    getFactionFavorGain: (ctx: NetscriptContext) =>
       function (_facName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const faction = getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const faction = getFaction(ctx, facName);
         return faction.getFavorGain();
       },
-    donateToFaction: (_ctx: NetscriptContext) =>
+    donateToFaction: (ctx: NetscriptContext) =>
       function (_facName: unknown, _amt: unknown): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const facName = _ctx.helper.string("facName", _facName);
-        const amt = _ctx.helper.number("amt", _amt);
-        const faction = getFaction(_ctx, facName);
+        helpers.checkSingularityAccess(ctx);
+        const facName = helpers.string(ctx, "facName", _facName);
+        const amt = helpers.number(ctx, "amt", _amt);
+        const faction = getFaction(ctx, facName);
         if (!player.factions.includes(faction.name)) {
-          _ctx.log(() => `You can't donate to '${facName}' because you aren't a member`);
+          helpers.log(ctx, () => `You can't donate to '${facName}' because you aren't a member`);
           return false;
         }
         if (player.inGang() && faction.name === player.getGangFaction().name) {
-          _ctx.log(() => `You can't donate to '${facName}' because youre managing a gang for it`);
+          helpers.log(ctx, () => `You can't donate to '${facName}' because youre managing a gang for it`);
           return false;
         }
         if (faction.name === FactionNames.ChurchOfTheMachineGod || faction.name === FactionNames.Bladeburners) {
-          _ctx.log(() => `You can't donate to '${facName}' because they do not accept donations`);
+          helpers.log(ctx, () => `You can't donate to '${facName}' because they do not accept donations`);
           return false;
         }
         if (typeof amt !== "number" || amt <= 0 || isNaN(amt)) {
-          _ctx.log(() => `Invalid donation amount: '${amt}'.`);
+          helpers.log(ctx, () => `Invalid donation amount: '${amt}'.`);
           return false;
         }
         if (player.money < amt) {
-          _ctx.log(() => `You do not have enough money to donate ${numeralWrapper.formatMoney(amt)} to '${facName}'`);
+          helpers.log(
+            ctx,
+            () => `You do not have enough money to donate ${numeralWrapper.formatMoney(amt)} to '${facName}'`,
+          );
           return false;
         }
         const repNeededToDonate = Math.floor(CONSTANTS.BaseFavorToDonate * BitNodeMultipliers.RepToDonateToFaction);
         if (faction.favor < repNeededToDonate) {
-          _ctx.log(
+          helpers.log(
+            ctx,
             () =>
               `You do not have enough favor to donate to this faction. Have ${faction.favor}, need ${repNeededToDonate}`,
           );
@@ -1079,7 +1101,8 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         const repGain = (amt / CONSTANTS.DonateMoneyToRepDivisor) * player.mults.faction_rep;
         faction.playerReputation += repGain;
         player.loseMoney(amt, "other");
-        _ctx.log(
+        helpers.log(
+          ctx,
           () =>
             `${numeralWrapper.formatMoney(amt)} donated to '${facName}' for ${numeralWrapper.formatReputation(
               repGain,
@@ -1087,34 +1110,34 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         );
         return true;
       },
-    createProgram: (_ctx: NetscriptContext) =>
+    createProgram: (ctx: NetscriptContext) =>
       function (_programName: unknown, _focus: unknown = true): boolean {
-        _ctx.helper.checkSingularityAccess();
-        const programName = _ctx.helper.string("programName", _programName).toLowerCase();
-        const focus = _ctx.helper.boolean(_focus);
+        helpers.checkSingularityAccess(ctx);
+        const programName = helpers.string(ctx, "programName", _programName).toLowerCase();
+        const focus = !!_focus;
 
         const wasFocusing = player.focus;
 
         const p = Object.values(Programs).find((p) => p.name.toLowerCase() === programName);
 
         if (p == null) {
-          _ctx.log(() => `The specified program does not exist: '${programName}`);
+          helpers.log(ctx, () => `The specified program does not exist: '${programName}`);
           return false;
         }
 
         if (player.hasProgram(p.name)) {
-          _ctx.log(() => `You already have the '${p.name}' program`);
+          helpers.log(ctx, () => `You already have the '${p.name}' program`);
           return false;
         }
 
         const create = p.create;
         if (create === null) {
-          _ctx.log(() => `You cannot create the '${p.name}' program`);
+          helpers.log(ctx, () => `You cannot create the '${p.name}' program`);
           return false;
         }
 
         if (!create.req(player)) {
-          _ctx.log(() => `Hacking level is too low to create '${p.name}' (level ${create.level} req)`);
+          helpers.log(ctx, () => `Hacking level is too low to create '${p.name}' (level ${create.level} req)`);
           return false;
         }
 
@@ -1132,14 +1155,14 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           player.stopFocusing();
           Router.toTerminal();
         }
-        _ctx.log(() => `Began creating program: '${programName}'`);
+        helpers.log(ctx, () => `Began creating program: '${programName}'`);
         return true;
       },
-    commitCrime: (_ctx: NetscriptContext) =>
+    commitCrime: (ctx: NetscriptContext) =>
       function (_crimeRoughName: unknown, _focus: unknown = true): number {
-        _ctx.helper.checkSingularityAccess();
-        const crimeRoughName = _ctx.helper.string("crimeRoughName", _crimeRoughName);
-        const focus = _ctx.helper.boolean(_focus);
+        helpers.checkSingularityAccess(ctx);
+        const crimeRoughName = helpers.string(ctx, "crimeRoughName", _crimeRoughName);
+        const focus = !!_focus;
         const wasFocusing = player.focus;
 
         if (player.currentWork !== null) {
@@ -1152,10 +1175,10 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         const crime = findCrime(crimeRoughName.toLowerCase());
         if (crime == null) {
           // couldn't find crime
-          throw _ctx.helper.makeRuntimeErrorMsg(`Invalid crime: '${crimeRoughName}'`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid crime: '${crimeRoughName}'`);
         }
-        _ctx.log(() => `Attempting to commit ${crime.name}...`);
-        const crimeTime = crime.commit(player, 1, workerScript);
+        helpers.log(ctx, () => `Attempting to commit ${crime.name}...`);
+        const crimeTime = crime.commit(player, 1, ctx.workerScript);
         if (focus) {
           player.startFocusing();
           Router.toWork();
@@ -1165,49 +1188,49 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         }
         return crimeTime;
       },
-    getCrimeChance: (_ctx: NetscriptContext) =>
+    getCrimeChance: (ctx: NetscriptContext) =>
       function (_crimeRoughName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const crimeRoughName = _ctx.helper.string("crimeRoughName", _crimeRoughName);
+        helpers.checkSingularityAccess(ctx);
+        const crimeRoughName = helpers.string(ctx, "crimeRoughName", _crimeRoughName);
 
         const crime = findCrime(crimeRoughName.toLowerCase());
         if (crime == null) {
-          throw _ctx.helper.makeRuntimeErrorMsg(`Invalid crime: ${crimeRoughName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid crime: ${crimeRoughName}`);
         }
 
         return crime.successRate(player);
       },
-    getCrimeStats: (_ctx: NetscriptContext) =>
+    getCrimeStats: (ctx: NetscriptContext) =>
       function (_crimeRoughName: unknown): CrimeStats {
-        _ctx.helper.checkSingularityAccess();
-        const crimeRoughName = _ctx.helper.string("crimeRoughName", _crimeRoughName);
+        helpers.checkSingularityAccess(ctx);
+        const crimeRoughName = helpers.string(ctx, "crimeRoughName", _crimeRoughName);
 
         const crime = findCrime(crimeRoughName.toLowerCase());
         if (crime == null) {
-          throw _ctx.helper.makeRuntimeErrorMsg(`Invalid crime: ${crimeRoughName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid crime: ${crimeRoughName}`);
         }
 
         return Object.assign({}, crime);
       },
-    getDarkwebPrograms: (_ctx: NetscriptContext) =>
+    getDarkwebPrograms: (ctx: NetscriptContext) =>
       function (): string[] {
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
 
         // If we don't have Tor, log it and return [] (empty list)
         if (!player.hasTorRouter()) {
-          _ctx.log(() => "You do not have the TOR router.");
+          helpers.log(ctx, () => "You do not have the TOR router.");
           return [];
         }
         return Object.values(DarkWebItems).map((p) => p.program);
       },
-    getDarkwebProgramCost: (_ctx: NetscriptContext) =>
+    getDarkwebProgramCost: (ctx: NetscriptContext) =>
       function (_programName: unknown): number {
-        _ctx.helper.checkSingularityAccess();
-        const programName = _ctx.helper.string("programName", _programName).toLowerCase();
+        helpers.checkSingularityAccess(ctx);
+        const programName = helpers.string(ctx, "programName", _programName).toLowerCase();
 
         // If we don't have Tor, log it and return -1
         if (!player.hasTorRouter()) {
-          _ctx.log(() => "You do not have the TOR router.");
+          helpers.log(ctx, () => "You do not have the TOR router.");
           // returning -1 rather than throwing an error to be consistent with purchaseProgram
           // which returns false if tor has
           return -1;
@@ -1220,25 +1243,26 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         // doesn't exist, it's the first time they've run the script. So throw an error to let them know
         // that they need to fix it.
         if (item == null) {
-          throw _ctx.helper.makeRuntimeErrorMsg(
+          throw helpers.makeRuntimeErrorMsg(
+            ctx,
             `No such exploit ('${programName}') found on the darkweb! ` +
               `\nThis function is not case-sensitive. Did you perhaps forget .exe at the end?`,
           );
         }
 
         if (player.hasProgram(item.program)) {
-          _ctx.log(() => `You already have the '${item.program}' program`);
+          helpers.log(ctx, () => `You already have the '${item.program}' program`);
           return 0;
         }
         return item.price;
       },
     b1tflum3:
-      (_ctx: NetscriptContext) =>
+      (ctx: NetscriptContext) =>
       (_nextBN: unknown, _callbackScript: unknown = ""): void => {
-        _ctx.helper.checkSingularityAccess();
-        const nextBN = _ctx.helper.number("nextBN", _nextBN);
-        const callbackScript = _ctx.helper.string("callbackScript", _callbackScript);
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
+        const nextBN = helpers.number(ctx, "nextBN", _nextBN);
+        const callbackScript = helpers.string(ctx, "callbackScript", _callbackScript);
+        helpers.checkSingularityAccess(ctx);
         enterBitNode(Router, true, player.bitNodeN, nextBN);
         if (callbackScript)
           setTimeout(() => {
@@ -1246,12 +1270,12 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
           }, 0);
       },
     destroyW0r1dD43m0n:
-      (_ctx: NetscriptContext) =>
+      (ctx: NetscriptContext) =>
       (_nextBN: unknown, _callbackScript: unknown = ""): void => {
-        _ctx.helper.checkSingularityAccess();
-        const nextBN = _ctx.helper.number("nextBN", _nextBN);
-        const callbackScript = _ctx.helper.string("callbackScript", _callbackScript);
-        _ctx.helper.checkSingularityAccess();
+        helpers.checkSingularityAccess(ctx);
+        const nextBN = helpers.number(ctx, "nextBN", _nextBN);
+        const callbackScript = helpers.string(ctx, "callbackScript", _callbackScript);
+        helpers.checkSingularityAccess(ctx);
 
         const hackingRequirements = (): boolean => {
           const wd = GetServer(SpecialServers.WorldDaemon);
@@ -1268,7 +1292,7 @@ export function NetscriptSingularity(player: IPlayer, workerScript: WorkerScript
         };
 
         if (!hackingRequirements() && !bladeburnerRequirements()) {
-          _ctx.log(() => "Requirements not met to destroy the world daemon");
+          helpers.log(ctx, () => "Requirements not met to destroy the world daemon");
           return;
         }
 
diff --git a/src/NetscriptFunctions/Sleeve.ts b/src/NetscriptFunctions/Sleeve.ts
index eff3d882b..16b076926 100644
--- a/src/NetscriptFunctions/Sleeve.ts
+++ b/src/NetscriptFunctions/Sleeve.ts
@@ -1,4 +1,4 @@
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { findSleevePurchasableAugs } from "../PersonObjects/Sleeve/SleeveHelpers";
 import { StaticAugmentations } from "../Augmentation/StaticAugmentations";
 import { CityName } from "../Locations/data/CityNames";
@@ -17,11 +17,13 @@ import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
 import { isSleeveBladeburnerWork } from "../PersonObjects/Sleeve/Work/SleeveBladeburnerWork";
 import { isSleeveFactionWork } from "../PersonObjects/Sleeve/Work/SleeveFactionWork";
 import { isSleeveCompanyWork } from "../PersonObjects/Sleeve/Work/SleeveCompanyWork";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
+export function NetscriptSleeve(): InternalAPI<ISleeve> {
   const checkSleeveAPIAccess = function (ctx: NetscriptContext): void {
     if (player.bitNodeN !== 10 && !player.sourceFileLvl(10)) {
-      throw ctx.makeRuntimeErrorMsg(
+      throw helpers.makeRuntimeErrorMsg(
+        ctx,
         "You do not currently have access to the Sleeve API. This is either because you are not in BitNode-10 or because you do not have Source-File 10",
       );
     }
@@ -30,8 +32,8 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
   const checkSleeveNumber = function (ctx: NetscriptContext, sleeveNumber: number): void {
     if (sleeveNumber >= player.sleeves.length || sleeveNumber < 0) {
       const msg = `Invalid sleeve number: ${sleeveNumber}`;
-      ctx.log(() => msg);
-      throw ctx.makeRuntimeErrorMsg(msg);
+      helpers.log(ctx, () => msg);
+      throw helpers.makeRuntimeErrorMsg(ctx, msg);
     }
   };
 
@@ -58,7 +60,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     setToShockRecovery:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
         return player.sleeves[sleeveNumber].shockRecovery(player);
@@ -66,7 +68,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     setToSynchronize:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
         return player.sleeves[sleeveNumber].synchronize(player);
@@ -74,8 +76,8 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     setToCommitCrime:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _crimeRoughName: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const crimeRoughName = ctx.helper.string("crimeName", _crimeRoughName);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const crimeRoughName = helpers.string(ctx, "crimeName", _crimeRoughName);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
         const crime = findCrime(crimeRoughName);
@@ -87,9 +89,9 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     setToUniversityCourse:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _universityName: unknown, _className: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const universityName = ctx.helper.string("universityName", _universityName);
-        const className = ctx.helper.string("className", _className);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const universityName = helpers.string(ctx, "universityName", _universityName);
+        const className = helpers.string(ctx, "className", _className);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
         return player.sleeves[sleeveNumber].takeUniversityCourse(player, universityName, className);
@@ -97,21 +99,21 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     travel:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _cityName: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const cityName = ctx.helper.string("cityName", _cityName);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const cityName = helpers.string(ctx, "cityName", _cityName);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
         if (checkEnum(CityName, cityName)) {
           return player.sleeves[sleeveNumber].travel(player, cityName);
         } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid city name: '${cityName}'.`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid city name: '${cityName}'.`);
         }
       },
     setToCompanyWork:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, acompanyName: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const companyName = ctx.helper.string("companyName", acompanyName);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const companyName = helpers.string(ctx, "companyName", acompanyName);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -122,7 +124,8 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
           }
           const other = player.sleeves[i];
           if (isSleeveCompanyWork(other.currentWork) && other.currentWork.companyName === companyName) {
-            throw ctx.makeRuntimeErrorMsg(
+            throw helpers.makeRuntimeErrorMsg(
+              ctx,
               `Sleeve ${sleeveNumber} cannot work for company ${companyName} because Sleeve ${i} is already working for them.`,
             );
           }
@@ -133,9 +136,9 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     setToFactionWork:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _factionName: unknown, _workType: unknown): boolean | undefined => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const factionName = ctx.helper.string("factionName", _factionName);
-        const workType = ctx.helper.string("workType", _workType);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const factionName = helpers.string(ctx, "factionName", _factionName);
+        const workType = helpers.string(ctx, "workType", _workType);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -146,14 +149,16 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
           }
           const other = player.sleeves[i];
           if (isSleeveFactionWork(other.currentWork) && other.currentWork.factionName === factionName) {
-            throw ctx.makeRuntimeErrorMsg(
+            throw helpers.makeRuntimeErrorMsg(
+              ctx,
               `Sleeve ${sleeveNumber} cannot work for faction ${factionName} because Sleeve ${i} is already working for them.`,
             );
           }
         }
 
         if (player.gang && player.gang.facName == factionName) {
-          throw ctx.makeRuntimeErrorMsg(
+          throw helpers.makeRuntimeErrorMsg(
+            ctx,
             `Sleeve ${sleeveNumber} cannot work for faction ${factionName} because you have started a gang with them.`,
           );
         }
@@ -163,9 +168,9 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     setToGymWorkout:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _gymName: unknown, _stat: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const gymName = ctx.helper.string("gymName", _gymName);
-        const stat = ctx.helper.string("stat", _stat);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const gymName = helpers.string(ctx, "gymName", _gymName);
+        const stat = helpers.string(ctx, "stat", _stat);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -174,7 +179,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     getSleeveStats:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): SleeveSkills => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
         return getSleeveStats(sleeveNumber);
@@ -182,7 +187,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     getTask:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): SleeveTask | null => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -193,7 +198,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     getInformation:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): SleeveInformation => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -229,7 +234,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     getSleeveAugmentations:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): string[] => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -242,7 +247,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     getSleevePurchasableAugs:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown): AugmentPair[] => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
@@ -261,18 +266,18 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
     purchaseSleeveAug:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _augName: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const augName = ctx.helper.string("augName", _augName);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const augName = helpers.string(ctx, "augName", _augName);
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
 
         if (getSleeveStats(sleeveNumber).shock > 0) {
-          throw ctx.makeRuntimeErrorMsg(`Sleeve shock too high: Sleeve ${sleeveNumber}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Sleeve shock too high: Sleeve ${sleeveNumber}`);
         }
 
         const aug = StaticAugmentations[augName];
         if (!aug) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid aug: ${augName}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid aug: ${augName}`);
         }
 
         return player.sleeves[sleeveNumber].tryBuyAugmentation(player, aug);
@@ -281,7 +286,7 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
       (ctx: NetscriptContext) =>
       (_augName: unknown): number => {
         checkSleeveAPIAccess(ctx);
-        const augName = ctx.helper.string("augName", _augName);
+        const augName = helpers.string(ctx, "augName", _augName);
         const aug: Augmentation = StaticAugmentations[augName];
         return aug.baseCost;
       },
@@ -289,20 +294,20 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
       (ctx: NetscriptContext) =>
       (_augName: unknown): number => {
         checkSleeveAPIAccess(ctx);
-        const augName = ctx.helper.string("augName", _augName);
+        const augName = helpers.string(ctx, "augName", _augName);
         const aug: Augmentation = StaticAugmentations[augName];
         return aug.getCost(player).repCost;
       },
     setToBladeburnerAction:
       (ctx: NetscriptContext) =>
       (_sleeveNumber: unknown, _action: unknown, _contract?: unknown): boolean => {
-        const sleeveNumber = ctx.helper.number("sleeveNumber", _sleeveNumber);
-        const action = ctx.helper.string("action", _action);
+        const sleeveNumber = helpers.number(ctx, "sleeveNumber", _sleeveNumber);
+        const action = helpers.string(ctx, "action", _action);
         let contract: string;
         if (typeof _contract === "undefined") {
           contract = "------";
         } else {
-          contract = ctx.helper.string("contract", _contract);
+          contract = helpers.string(ctx, "contract", _contract);
         }
         checkSleeveAPIAccess(ctx);
         checkSleeveNumber(ctx, sleeveNumber);
@@ -315,7 +320,8 @@ export function NetscriptSleeve(player: IPlayer): InternalAPI<ISleeve> {
             }
             const other = player.sleeves[i];
             if (isSleeveBladeburnerWork(other.currentWork) && other.currentWork.actionName === contract) {
-              throw ctx.helper.makeRuntimeErrorMsg(
+              throw helpers.makeRuntimeErrorMsg(
+                ctx,
                 `Sleeve ${sleeveNumber} cannot take on contracts because Sleeve ${i} is already performing that action.`,
               );
             }
diff --git a/src/NetscriptFunctions/Stanek.ts b/src/NetscriptFunctions/Stanek.ts
index e4e8f1008..c2e936f1b 100644
--- a/src/NetscriptFunctions/Stanek.ts
+++ b/src/NetscriptFunctions/Stanek.ts
@@ -1,7 +1,4 @@
-import { INetscriptHelper } from "./INetscriptHelper";
-import { IPlayer } from "../PersonObjects/IPlayer";
-import { WorkerScript } from "../Netscript/WorkerScript";
-import { netscriptDelay } from "../NetscriptEvaluator";
+import { Player as player } from "../Player";
 
 import { staneksGift } from "../CotMG/Helper";
 import { Fragments, FragmentById } from "../CotMG/Fragment";
@@ -18,111 +15,109 @@ import { applyAugmentation } from "../Augmentation/AugmentationHelpers";
 import { FactionNames } from "../Faction/data/FactionNames";
 import { joinFaction } from "../Faction/FactionHelpers";
 import { Factions } from "../Faction/Factions";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptStanek(
-  player: IPlayer,
-  workerScript: WorkerScript,
-  helper: INetscriptHelper,
-): InternalAPI<IStanek> {
-  function checkStanekAPIAccess(func: string): void {
+export function NetscriptStanek(): InternalAPI<IStanek> {
+  function checkStanekAPIAccess(ctx: NetscriptContext): void {
     if (!player.hasAugmentation(AugmentationNames.StaneksGift1, true)) {
-      throw helper.makeRuntimeErrorMsg(func, "Stanek's Gift is not installed");
+      throw helpers.makeRuntimeErrorMsg(ctx, "Stanek's Gift is not installed");
     }
   }
 
   return {
-    giftWidth: () =>
+    giftWidth: (ctx: NetscriptContext) =>
       function (): number {
-        checkStanekAPIAccess("giftWidth");
+        checkStanekAPIAccess(ctx);
         return staneksGift.width();
       },
-    giftHeight: () =>
+    giftHeight: (ctx: NetscriptContext) =>
       function (): number {
-        checkStanekAPIAccess("giftHeight");
+        checkStanekAPIAccess(ctx);
         return staneksGift.height();
       },
-    chargeFragment: (_ctx: NetscriptContext) =>
+    chargeFragment: (ctx: NetscriptContext) =>
       function (_rootX: unknown, _rootY: unknown): Promise<void> {
         //Get the fragment object using the given coordinates
-        const rootX = _ctx.helper.number("rootX", _rootX);
-        const rootY = _ctx.helper.number("rootY", _rootY);
-        checkStanekAPIAccess("chargeFragment");
+        const rootX = helpers.number(ctx, "rootX", _rootX);
+        const rootY = helpers.number(ctx, "rootY", _rootY);
+        checkStanekAPIAccess(ctx);
         const fragment = staneksGift.findFragment(rootX, rootY);
         //Check whether the selected fragment can ge charged
-        if (!fragment) throw _ctx.makeRuntimeErrorMsg(`No fragment with root (${rootX}, ${rootY}).`);
+        if (!fragment) throw helpers.makeRuntimeErrorMsg(ctx, `No fragment with root (${rootX}, ${rootY}).`);
         if (fragment.fragment().type == FragmentType.Booster) {
-          throw _ctx.makeRuntimeErrorMsg(
+          throw helpers.makeRuntimeErrorMsg(
+            ctx,
             `The fragment with root (${rootX}, ${rootY}) is a Booster Fragment and thus cannot be charged.`,
           );
         }
         //Charge the fragment
         const time = staneksGift.inBonus() ? 200 : 1000;
-        return netscriptDelay(time, workerScript).then(function () {
-          staneksGift.charge(player, fragment, workerScript.scriptRef.threads);
-          _ctx.log(() => `Charged fragment with ${_ctx.workerScript.scriptRef.threads} threads.`);
+        return helpers.netscriptDelay(ctx, time).then(function () {
+          staneksGift.charge(player, fragment, ctx.workerScript.scriptRef.threads);
+          helpers.log(ctx, () => `Charged fragment with ${ctx.workerScript.scriptRef.threads} threads.`);
           return Promise.resolve();
         });
       },
-    fragmentDefinitions: (_ctx: NetscriptContext) =>
+    fragmentDefinitions: (ctx: NetscriptContext) =>
       function (): IFragment[] {
-        checkStanekAPIAccess("fragmentDefinitions");
-        _ctx.log(() => `Returned ${Fragments.length} fragments`);
+        checkStanekAPIAccess(ctx);
+        helpers.log(ctx, () => `Returned ${Fragments.length} fragments`);
         return Fragments.map((f) => f.copy());
       },
-    activeFragments: (_ctx: NetscriptContext) =>
+    activeFragments: (ctx: NetscriptContext) =>
       function (): IActiveFragment[] {
-        checkStanekAPIAccess("activeFragments");
-        _ctx.log(() => `Returned ${staneksGift.fragments.length} fragments`);
+        checkStanekAPIAccess(ctx);
+        helpers.log(ctx, () => `Returned ${staneksGift.fragments.length} fragments`);
         return staneksGift.fragments.map((af) => {
           return { ...af.copy(), ...af.fragment().copy() };
         });
       },
-    clearGift: (_ctx: NetscriptContext) =>
+    clearGift: (ctx: NetscriptContext) =>
       function (): void {
-        checkStanekAPIAccess("clearGift");
-        _ctx.log(() => `Cleared Stanek's Gift.`);
+        checkStanekAPIAccess(ctx);
+        helpers.log(ctx, () => `Cleared Stanek's Gift.`);
         staneksGift.clear();
       },
-    canPlaceFragment: (_ctx: NetscriptContext) =>
+    canPlaceFragment: (ctx: NetscriptContext) =>
       function (_rootX: unknown, _rootY: unknown, _rotation: unknown, _fragmentId: unknown): boolean {
-        const rootX = _ctx.helper.number("rootX", _rootX);
-        const rootY = _ctx.helper.number("rootY", _rootY);
-        const rotation = _ctx.helper.number("rotation", _rotation);
-        const fragmentId = _ctx.helper.number("fragmentId", _fragmentId);
-        checkStanekAPIAccess("canPlaceFragment");
+        const rootX = helpers.number(ctx, "rootX", _rootX);
+        const rootY = helpers.number(ctx, "rootY", _rootY);
+        const rotation = helpers.number(ctx, "rotation", _rotation);
+        const fragmentId = helpers.number(ctx, "fragmentId", _fragmentId);
+        checkStanekAPIAccess(ctx);
         const fragment = FragmentById(fragmentId);
-        if (!fragment) throw _ctx.makeRuntimeErrorMsg(`Invalid fragment id: ${fragmentId}`);
+        if (!fragment) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid fragment id: ${fragmentId}`);
         const can = staneksGift.canPlace(rootX, rootY, rotation, fragment);
         return can;
       },
-    placeFragment: (_ctx: NetscriptContext) =>
+    placeFragment: (ctx: NetscriptContext) =>
       function (_rootX: unknown, _rootY: unknown, _rotation: unknown, _fragmentId: unknown): boolean {
-        const rootX = _ctx.helper.number("rootX", _rootX);
-        const rootY = _ctx.helper.number("rootY", _rootY);
-        const rotation = _ctx.helper.number("rotation", _rotation);
-        const fragmentId = _ctx.helper.number("fragmentId", _fragmentId);
-        checkStanekAPIAccess("placeFragment");
+        const rootX = helpers.number(ctx, "rootX", _rootX);
+        const rootY = helpers.number(ctx, "rootY", _rootY);
+        const rotation = helpers.number(ctx, "rotation", _rotation);
+        const fragmentId = helpers.number(ctx, "fragmentId", _fragmentId);
+        checkStanekAPIAccess(ctx);
         const fragment = FragmentById(fragmentId);
-        if (!fragment) throw _ctx.makeRuntimeErrorMsg(`Invalid fragment id: ${fragmentId}`);
+        if (!fragment) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid fragment id: ${fragmentId}`);
         return staneksGift.place(rootX, rootY, rotation, fragment);
       },
-    getFragment: (_ctx: NetscriptContext) =>
+    getFragment: (ctx: NetscriptContext) =>
       function (_rootX: unknown, _rootY: unknown): IActiveFragment | undefined {
-        const rootX = _ctx.helper.number("rootX", _rootX);
-        const rootY = _ctx.helper.number("rootY", _rootY);
-        checkStanekAPIAccess("getFragment");
+        const rootX = helpers.number(ctx, "rootX", _rootX);
+        const rootY = helpers.number(ctx, "rootY", _rootY);
+        checkStanekAPIAccess(ctx);
         const fragment = staneksGift.findFragment(rootX, rootY);
         if (fragment !== undefined) return fragment.copy();
         return undefined;
       },
-    removeFragment: (_ctx: NetscriptContext) =>
+    removeFragment: (ctx: NetscriptContext) =>
       function (_rootX: unknown, _rootY: unknown): boolean {
-        const rootX = _ctx.helper.number("rootX", _rootX);
-        const rootY = _ctx.helper.number("rootY", _rootY);
-        checkStanekAPIAccess("removeFragment");
+        const rootX = helpers.number(ctx, "rootX", _rootX);
+        const rootY = helpers.number(ctx, "rootY", _rootY);
+        checkStanekAPIAccess(ctx);
         return staneksGift.delete(rootX, rootY);
       },
-    acceptGift: (_ctx: NetscriptContext) =>
+    acceptGift: (ctx: NetscriptContext) =>
       function (): boolean {
         //Check if the player is eligible to join the church
         if (
@@ -138,7 +133,8 @@ export function NetscriptStanek(
             !player.queuedAugmentations.some((a) => a.name === AugmentationNames.StaneksGift1)
           ) {
             applyAugmentation({ name: AugmentationNames.StaneksGift1, level: 1 });
-            _ctx.log(
+            helpers.log(
+              ctx,
               () => `'${FactionNames.ChurchOfTheMachineGod}' joined and '${AugmentationNames.StaneksGift1}' installed.`,
             );
           }
diff --git a/src/NetscriptFunctions/StockMarket.ts b/src/NetscriptFunctions/StockMarket.ts
index 7236e617c..5436680b4 100644
--- a/src/NetscriptFunctions/StockMarket.ts
+++ b/src/NetscriptFunctions/StockMarket.ts
@@ -1,5 +1,4 @@
-import { WorkerScript } from "../Netscript/WorkerScript";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player as player } from "../Player";
 import { buyStock, sellStock, shortStock, sellShort } from "../StockMarket/BuyingAndSelling";
 import { StockMarket, SymbolToStockMap, placeOrder, cancelOrder, initStockMarketFn } from "../StockMarket/StockMarket";
 import { getBuyTransactionCost, getSellTransactionGain } from "../StockMarket/StockMarketHelpers";
@@ -14,25 +13,26 @@ import {
 } from "../StockMarket/StockMarketCosts";
 import { Stock } from "../StockMarket/Stock";
 import { StockOrder, TIX } from "../ScriptEditor/NetscriptDefinitions";
-import { InternalAPI, NetscriptContext } from "src/Netscript/APIWrapper";
+import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
-export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript): InternalAPI<TIX> {
+export function NetscriptStockMarket(): InternalAPI<TIX> {
   /**
    * Checks if the player has TIX API access. Throws an error if the player does not
    */
   const checkTixApiAccess = function (ctx: NetscriptContext): void {
     if (!player.hasWseAccount) {
-      throw ctx.makeRuntimeErrorMsg(`You don't have WSE Access! Cannot use ${ctx.function}()`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `You don't have WSE Access! Cannot use ${ctx.function}()`);
     }
     if (!player.hasTixApiAccess) {
-      throw ctx.makeRuntimeErrorMsg(`You don't have TIX API Access! Cannot use ${ctx.function}()`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `You don't have TIX API Access! Cannot use ${ctx.function}()`);
     }
   };
 
   const getStockFromSymbol = function (ctx: NetscriptContext, symbol: string): Stock {
     const stock = SymbolToStockMap[symbol];
     if (stock == null) {
-      throw ctx.makeRuntimeErrorMsg(`Invalid stock symbol: '${symbol}'`);
+      throw helpers.makeRuntimeErrorMsg(ctx, `Invalid stock symbol: '${symbol}'`);
     }
 
     return stock;
@@ -58,7 +58,7 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getPrice:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
 
@@ -67,7 +67,7 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getAskPrice:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
 
@@ -76,7 +76,7 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getBidPrice:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
 
@@ -85,18 +85,18 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getPosition:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): [number, number, number, number] => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         checkTixApiAccess(ctx);
         const stock = SymbolToStockMap[symbol];
         if (stock == null) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid stock symbol: ${symbol}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid stock symbol: ${symbol}`);
         }
         return [stock.playerShares, stock.playerAvgPx, stock.playerShortShares, stock.playerAvgShortPx];
       },
     getMaxShares:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
 
@@ -105,9 +105,9 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getPurchaseCost:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown, _posType: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        let shares = ctx.helper.number("shares", _shares);
-        const posType = ctx.helper.string("posType", _posType);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        let shares = helpers.number(ctx, "shares", _shares);
+        const posType = helpers.string(ctx, "posType", _posType);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
         shares = Math.round(shares);
@@ -132,9 +132,9 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getSaleGain:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown, _posType: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        let shares = ctx.helper.number("shares", _shares);
-        const posType = ctx.helper.string("posType", _posType);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        let shares = helpers.number(ctx, "shares", _shares);
+        const posType = helpers.string(ctx, "posType", _posType);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
         shares = Math.round(shares);
@@ -159,68 +159,77 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     buyStock:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        const shares = ctx.helper.number("shares", _shares);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        const shares = helpers.number(ctx, "shares", _shares);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
-        const res = buyStock(stock, shares, workerScript, {});
+        const res = buyStock(stock, shares, ctx.workerScript, {});
         return res ? stock.getAskPrice() : 0;
       },
     sellStock:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        const shares = ctx.helper.number("shares", _shares);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        const shares = helpers.number(ctx, "shares", _shares);
         checkTixApiAccess(ctx);
         const stock = getStockFromSymbol(ctx, symbol);
-        const res = sellStock(stock, shares, workerScript, {});
+        const res = sellStock(stock, shares, ctx.workerScript, {});
 
         return res ? stock.getBidPrice() : 0;
       },
     buyShort:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        const shares = ctx.helper.number("shares", _shares);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        const shares = helpers.number(ctx, "shares", _shares);
         checkTixApiAccess(ctx);
         if (player.bitNodeN !== 8) {
           if (player.sourceFileLvl(8) <= 1) {
-            throw ctx.makeRuntimeErrorMsg("You must either be in BitNode-8 or you must have Source-File 8 Level 2.");
+            throw helpers.makeRuntimeErrorMsg(
+              ctx,
+              "You must either be in BitNode-8 or you must have Source-File 8 Level 2.",
+            );
           }
         }
         const stock = getStockFromSymbol(ctx, symbol);
-        const res = shortStock(stock, shares, workerScript, {});
+        const res = shortStock(stock, shares, ctx.workerScript, {});
 
         return res ? stock.getBidPrice() : 0;
       },
     sellShort:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        const shares = ctx.helper.number("shares", _shares);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        const shares = helpers.number(ctx, "shares", _shares);
         checkTixApiAccess(ctx);
         if (player.bitNodeN !== 8) {
           if (player.sourceFileLvl(8) <= 1) {
-            throw ctx.makeRuntimeErrorMsg("You must either be in BitNode-8 or you must have Source-File 8 Level 2.");
+            throw helpers.makeRuntimeErrorMsg(
+              ctx,
+              "You must either be in BitNode-8 or you must have Source-File 8 Level 2.",
+            );
           }
         }
         const stock = getStockFromSymbol(ctx, symbol);
-        const res = sellShort(stock, shares, workerScript, {});
+        const res = sellShort(stock, shares, ctx.workerScript, {});
 
         return res ? stock.getAskPrice() : 0;
       },
     placeOrder:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown, _price: unknown, _type: unknown, _pos: unknown): boolean => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        const shares = ctx.helper.number("shares", _shares);
-        const price = ctx.helper.number("price", _price);
-        const type = ctx.helper.string("type", _type);
-        const pos = ctx.helper.string("pos", _pos);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        const shares = helpers.number(ctx, "shares", _shares);
+        const price = helpers.number(ctx, "price", _price);
+        const type = helpers.string(ctx, "type", _type);
+        const pos = helpers.string(ctx, "pos", _pos);
         checkTixApiAccess(ctx);
         if (player.bitNodeN !== 8) {
           if (player.sourceFileLvl(8) <= 2) {
-            throw ctx.makeRuntimeErrorMsg("You must either be in BitNode-8 or you must have Source-File 8 Level 3.");
+            throw helpers.makeRuntimeErrorMsg(
+              ctx,
+              "You must either be in BitNode-8 or you must have Source-File 8 Level 3.",
+            );
           }
         }
         const stock = getStockFromSymbol(ctx, symbol);
@@ -237,7 +246,7 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
         } else if (ltype.includes("stop") && ltype.includes("sell")) {
           orderType = OrderTypes.StopSell;
         } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid order type: ${type}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid order type: ${type}`);
         }
 
         const lpos = pos.toLowerCase();
@@ -246,28 +255,34 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
         } else if (lpos.includes("s")) {
           orderPos = PositionTypes.Short;
         } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid position type: ${pos}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid position type: ${pos}`);
         }
 
-        return placeOrder(stock, shares, price, orderType, orderPos, workerScript);
+        return placeOrder(stock, shares, price, orderType, orderPos, ctx.workerScript);
       },
     cancelOrder:
       (ctx: NetscriptContext) =>
       (_symbol: unknown, _shares: unknown, _price: unknown, _type: unknown, _pos: unknown): boolean => {
-        const symbol = ctx.helper.string("symbol", _symbol);
-        const shares = ctx.helper.number("shares", _shares);
-        const price = ctx.helper.number("price", _price);
-        const type = ctx.helper.string("type", _type);
-        const pos = ctx.helper.string("pos", _pos);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
+        const shares = helpers.number(ctx, "shares", _shares);
+        const price = helpers.number(ctx, "price", _price);
+        const type = helpers.string(ctx, "type", _type);
+        const pos = helpers.string(ctx, "pos", _pos);
         checkTixApiAccess(ctx);
         if (player.bitNodeN !== 8) {
           if (player.sourceFileLvl(8) <= 2) {
-            throw ctx.makeRuntimeErrorMsg("You must either be in BitNode-8 or you must have Source-File 8 Level 3.");
+            throw helpers.makeRuntimeErrorMsg(
+              ctx,
+              "You must either be in BitNode-8 or you must have Source-File 8 Level 3.",
+            );
           }
         }
         const stock = getStockFromSymbol(ctx, symbol);
         if (isNaN(shares) || isNaN(price)) {
-          throw ctx.makeRuntimeErrorMsg(`Invalid shares or price. Must be numeric. shares=${shares}, price=${price}`);
+          throw helpers.makeRuntimeErrorMsg(
+            ctx,
+            `Invalid shares or price. Must be numeric. shares=${shares}, price=${price}`,
+          );
         }
         let orderType;
         let orderPos;
@@ -281,7 +296,7 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
         } else if (ltype.includes("stop") && ltype.includes("sell")) {
           orderType = OrderTypes.StopSell;
         } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid order type: ${type}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid order type: ${type}`);
         }
 
         const lpos = pos.toLowerCase();
@@ -290,7 +305,7 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
         } else if (lpos.includes("s")) {
           orderPos = PositionTypes.Short;
         } else {
-          throw ctx.makeRuntimeErrorMsg(`Invalid position type: ${pos}`);
+          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid position type: ${pos}`);
         }
         const params = {
           stock: stock,
@@ -299,13 +314,13 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
           type: orderType,
           pos: orderPos,
         };
-        return cancelOrder(params, workerScript);
+        return cancelOrder(params, ctx.workerScript);
       },
     getOrders: (ctx: NetscriptContext) => (): StockOrder => {
       checkTixApiAccess(ctx);
       if (player.bitNodeN !== 8) {
         if (player.sourceFileLvl(8) <= 2) {
-          throw ctx.makeRuntimeErrorMsg("You must either be in BitNode-8 or have Source-File 8 Level 3.");
+          throw helpers.makeRuntimeErrorMsg(ctx, "You must either be in BitNode-8 or have Source-File 8 Level 3.");
         }
       }
 
@@ -332,9 +347,9 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getVolatility:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         if (!player.has4SDataTixApi) {
-          throw ctx.makeRuntimeErrorMsg("You don't have 4S Market Data TIX API Access!");
+          throw helpers.makeRuntimeErrorMsg(ctx, "You don't have 4S Market Data TIX API Access!");
         }
         const stock = getStockFromSymbol(ctx, symbol);
 
@@ -343,9 +358,9 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
     getForecast:
       (ctx: NetscriptContext) =>
       (_symbol: unknown): number => {
-        const symbol = ctx.helper.string("symbol", _symbol);
+        const symbol = helpers.string(ctx, "symbol", _symbol);
         if (!player.has4SDataTixApi) {
-          throw ctx.makeRuntimeErrorMsg("You don't have 4S Market Data TIX API Access!");
+          throw helpers.makeRuntimeErrorMsg(ctx, "You don't have 4S Market Data TIX API Access!");
         }
         const stock = getStockFromSymbol(ctx, symbol);
 
@@ -355,69 +370,69 @@ export function NetscriptStockMarket(player: IPlayer, workerScript: WorkerScript
       },
     purchase4SMarketData: (ctx: NetscriptContext) => (): boolean => {
       if (player.has4SData) {
-        ctx.log(() => "Already purchased 4S Market Data.");
+        helpers.log(ctx, () => "Already purchased 4S Market Data.");
         return true;
       }
 
       if (player.money < getStockMarket4SDataCost()) {
-        ctx.log(() => "Not enough money to purchase 4S Market Data.");
+        helpers.log(ctx, () => "Not enough money to purchase 4S Market Data.");
         return false;
       }
 
       player.has4SData = true;
       player.loseMoney(getStockMarket4SDataCost(), "stock");
-      ctx.log(() => "Purchased 4S Market Data");
+      helpers.log(ctx, () => "Purchased 4S Market Data");
       return true;
     },
     purchase4SMarketDataTixApi: (ctx: NetscriptContext) => (): boolean => {
       checkTixApiAccess(ctx);
 
       if (player.has4SDataTixApi) {
-        ctx.log(() => "Already purchased 4S Market Data TIX API");
+        helpers.log(ctx, () => "Already purchased 4S Market Data TIX API");
         return true;
       }
 
       if (player.money < getStockMarket4STixApiCost()) {
-        ctx.log(() => "Not enough money to purchase 4S Market Data TIX API");
+        helpers.log(ctx, () => "Not enough money to purchase 4S Market Data TIX API");
         return false;
       }
 
       player.has4SDataTixApi = true;
       player.loseMoney(getStockMarket4STixApiCost(), "stock");
-      ctx.log(() => "Purchased 4S Market Data TIX API");
+      helpers.log(ctx, () => "Purchased 4S Market Data TIX API");
       return true;
     },
     purchaseWseAccount: (ctx: NetscriptContext) => (): boolean => {
       if (player.hasWseAccount) {
-        ctx.log(() => "Already purchased WSE Account");
+        helpers.log(ctx, () => "Already purchased WSE Account");
         return true;
       }
 
       if (player.money < getStockMarketWseCost()) {
-        ctx.log(() => "Not enough money to purchase WSE Account Access");
+        helpers.log(ctx, () => "Not enough money to purchase WSE Account Access");
         return false;
       }
 
       player.hasWseAccount = true;
       initStockMarketFn();
       player.loseMoney(getStockMarketWseCost(), "stock");
-      ctx.log(() => "Purchased WSE Account Access");
+      helpers.log(ctx, () => "Purchased WSE Account Access");
       return true;
     },
     purchaseTixApi: (ctx: NetscriptContext) => (): boolean => {
       if (player.hasTixApiAccess) {
-        ctx.log(() => "Already purchased TIX API");
+        helpers.log(ctx, () => "Already purchased TIX API");
         return true;
       }
 
       if (player.money < getStockMarketTixApiCost()) {
-        ctx.log(() => "Not enough money to purchase TIX API Access");
+        helpers.log(ctx, () => "Not enough money to purchase TIX API Access");
         return false;
       }
 
       player.hasTixApiAccess = true;
       player.loseMoney(getStockMarketTixApiCost(), "stock");
-      ctx.log(() => "Purchased TIX API");
+      helpers.log(ctx, () => "Purchased TIX API");
       return true;
     },
   };
diff --git a/src/NetscriptFunctions/UserInterface.ts b/src/NetscriptFunctions/UserInterface.ts
index 9175ffcf4..530247ba0 100644
--- a/src/NetscriptFunctions/UserInterface.ts
+++ b/src/NetscriptFunctions/UserInterface.ts
@@ -10,8 +10,9 @@ import { defaultTheme } from "../Themes/Themes";
 import { defaultStyles } from "../Themes/Styles";
 import { CONSTANTS } from "../Constants";
 import { hash } from "../hash/hash";
-import { InternalAPI, NetscriptContext } from "src/Netscript/APIWrapper";
+import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
 import { Terminal } from "../../src/Terminal";
+import { helpers } from "../Netscript/NetscriptHelpers";
 
 export function NetscriptUserInterface(): InternalAPI<IUserInterface> {
   return {
@@ -43,9 +44,9 @@ export function NetscriptUserInterface(): InternalAPI<IUserInterface> {
         if (errors.length === 0) {
           Object.assign(Settings.theme, currentTheme);
           ThemeEvents.emit();
-          ctx.log(() => `Successfully set theme`);
+          helpers.log(ctx, () => `Successfully set theme`);
         } else {
-          ctx.log(() => `Failed to set theme. Errors: ${errors.join(", ")}`);
+          helpers.log(ctx, () => `Failed to set theme. Errors: ${errors.join(", ")}`);
         }
       },
 
@@ -66,22 +67,22 @@ export function NetscriptUserInterface(): InternalAPI<IUserInterface> {
         if (errors.length === 0) {
           Object.assign(Settings.styles, currentStyles);
           ThemeEvents.emit();
-          ctx.log(() => `Successfully set styles`);
+          helpers.log(ctx, () => `Successfully set styles`);
         } else {
-          ctx.log(() => `Failed to set styles. Errors: ${errors.join(", ")}`);
+          helpers.log(ctx, () => `Failed to set styles. Errors: ${errors.join(", ")}`);
         }
       },
 
     resetTheme: (ctx: NetscriptContext) => (): void => {
       Settings.theme = { ...defaultTheme };
       ThemeEvents.emit();
-      ctx.log(() => `Reinitialized theme to default`);
+      helpers.log(ctx, () => `Reinitialized theme to default`);
     },
 
     resetStyles: (ctx: NetscriptContext) => (): void => {
       Settings.styles = { ...defaultStyles };
       ThemeEvents.emit();
-      ctx.log(() => `Reinitialized styles to default`);
+      helpers.log(ctx, () => `Reinitialized styles to default`);
     },
 
     getGameInfo: () => (): GameInfo => {
@@ -99,7 +100,7 @@ export function NetscriptUserInterface(): InternalAPI<IUserInterface> {
     },
 
     clearTerminal: (ctx: NetscriptContext) => (): void => {
-      ctx.log(() => `Clearing terminal`);
+      helpers.log(ctx, () => `Clearing terminal`);
       Terminal.clear();
     },
   };
diff --git a/src/NetscriptJSEvaluator.ts b/src/NetscriptJSEvaluator.ts
index cb5102b55..d3e31f1d2 100644
--- a/src/NetscriptJSEvaluator.ts
+++ b/src/NetscriptJSEvaluator.ts
@@ -5,7 +5,7 @@
 import * as walk from "acorn-walk";
 import { parse } from "acorn";
 
-import { makeRuntimeRejectMsg } from "./NetscriptEvaluator";
+import { helpers } from "./Netscript/NetscriptHelpers";
 import { ScriptUrl } from "./Script/ScriptUrl";
 import { WorkerScript } from "./Netscript/WorkerScript";
 import { Script } from "./Script/Script";
@@ -74,18 +74,21 @@ export async function executeJSScript(
   const ns = workerScript.env.vars;
 
   if (!loadedModule) {
-    throw makeRuntimeRejectMsg(workerScript, `${script.filename} cannot be run because the script module won't load`);
+    throw helpers.makeRuntimeRejectMsg(
+      workerScript,
+      `${script.filename} cannot be run because the script module won't load`,
+    );
   }
   // TODO: putting await in a non-async function yields unhelpful
   // "SyntaxError: unexpected reserved word" with no line number information.
   if (!loadedModule.main) {
-    throw makeRuntimeRejectMsg(
+    throw helpers.makeRuntimeRejectMsg(
       workerScript,
       `${script.filename} cannot be run because it does not have a main function.`,
     );
   }
   if (!ns) {
-    throw makeRuntimeRejectMsg(
+    throw helpers.makeRuntimeRejectMsg(
       workerScript,
       `${script.filename} cannot be run because the NS object hasn't been constructed properly.`,
     );
diff --git a/src/NetscriptWorker.ts b/src/NetscriptWorker.ts
index 5c8f8ad93..cff1b83d2 100644
--- a/src/NetscriptWorker.ts
+++ b/src/NetscriptWorker.ts
@@ -11,7 +11,6 @@ import { generateNextPid } from "./Netscript/Pid";
 
 import { CONSTANTS } from "./Constants";
 import { Interpreter } from "./ThirdParty/JSInterpreter";
-import { isScriptErrorMessage, makeRuntimeRejectMsg } from "./NetscriptEvaluator";
 import { NetscriptFunctions } from "./NetscriptFunctions";
 import { executeJSScript, Node } from "./NetscriptJSEvaluator";
 import { NetscriptPort, IPort } from "./NetscriptPort";
@@ -29,7 +28,6 @@ import { dialogBoxCreate } from "./ui/React/DialogBox";
 import { arrayToString } from "./utils/helpers/arrayToString";
 import { roundToTwo } from "./utils/helpers/roundToTwo";
 import { isString } from "./utils/helpers/isString";
-import { sprintf } from "sprintf-js";
 
 import { parse } from "acorn";
 import { simple as walksimple } from "acorn-walk";
@@ -38,6 +36,8 @@ import { Player } from "./Player";
 import { Terminal } from "./Terminal";
 import { IPlayer } from "./PersonObjects/IPlayer";
 import { ScriptArg } from "./Netscript/ScriptArg";
+import { helpers } from "./Netscript/NetscriptHelpers";
+import { NS } from "./ScriptEditor/NetscriptDefinitions";
 
 // Netscript Ports are instantiated here
 export const NetscriptPorts: IPort[] = [];
@@ -63,83 +63,6 @@ export function prestigeWorkerScripts(): void {
 // that resolves or rejects when the corresponding worker script is done.
 function startNetscript2Script(player: IPlayer, workerScript: WorkerScript): Promise<void> {
   workerScript.running = true;
-
-  // The name of the currently running netscript function, to prevent concurrent
-  // calls to hack, grow, etc.
-  let runningFn: string | null = null;
-
-  // We need to go through the environment and wrap each function in such a way that it
-  // can be called at most once at a time. This will prevent situations where multiple
-  // hack promises are outstanding, for example.
-  function wrap(propName: string, f: (...args: unknown[]) => Promise<void>): (...args: unknown[]) => Promise<void> {
-    // This function unfortunately cannot be an async function, because we don't
-    // know if the original one was, and there's no way to tell.
-    return function (...args: unknown[]) {
-      // Wrap every netscript function with a check for the stop flag.
-      // This prevents cases where we never stop because we are only calling
-      // netscript functions that don't check this.
-      // This is not a problem for legacy Netscript because it also checks the
-      // stop flag in the evaluator.
-      if (workerScript.env.stopFlag) {
-        throw new ScriptDeath(workerScript);
-      }
-
-      if (propName === "asleep") return f(...args); // OK for multiple simultaneous calls to sleep.
-
-      const msg =
-        "Concurrent calls to Netscript functions are not allowed! " +
-        "Did you forget to await hack(), grow(), or some other " +
-        "promise-returning function? (Currently running: %s tried to run: %s)";
-      if (runningFn) {
-        workerScript.errorMessage = makeRuntimeRejectMsg(workerScript, sprintf(msg, runningFn, propName));
-        throw new ScriptDeath(workerScript);
-      }
-      runningFn = propName;
-
-      // If the function throws an error, clear the runningFn flag first, and then re-throw it
-      // This allows people to properly catch errors thrown by NS functions without getting
-      // the concurrent call error above
-      let result;
-      try {
-        result = f(...args);
-      } catch (e: unknown) {
-        runningFn = null;
-        throw e;
-      }
-
-      if (result && result.finally !== undefined) {
-        return result.finally(function () {
-          runningFn = null;
-        });
-      } else {
-        runningFn = null;
-        return result;
-      }
-    };
-  }
-
-  function wrapObject(vars: unknown, ...tree: string[]): void {
-    const isObject = (x: unknown): x is { [key: string]: unknown } => typeof x === "object";
-    if (!isObject(vars)) throw new Error("wrong argument sent to wrapObject");
-    for (const prop of Object.keys(vars)) {
-      let e = vars[prop];
-      switch (typeof e) {
-        case "function": {
-          e = wrap([...tree, prop].join("."), e as any);
-          break;
-        }
-        case "object": {
-          if (Array.isArray(e)) continue;
-          wrapObject(e, ...tree, prop);
-          break;
-        }
-      }
-    }
-  }
-  wrapObject(workerScript.env.vars);
-
-  // Note: the environment that we pass to the JS script only needs to contain the functions visible
-  // to that script, which env.vars does at this point.
   return new Promise<void>((resolve, reject) => {
     executeJSScript(player, workerScript.getServer().scripts, workerScript)
       .then(() => {
@@ -149,15 +72,18 @@ function startNetscript2Script(player: IPlayer, workerScript: WorkerScript): Pro
   }).catch((e) => {
     if (e instanceof Error) {
       if (e instanceof SyntaxError) {
-        workerScript.errorMessage = makeRuntimeRejectMsg(workerScript, e.message + " (sorry we can't be more helpful)");
+        workerScript.errorMessage = helpers.makeRuntimeRejectMsg(
+          workerScript,
+          e.message + " (sorry we can't be more helpful)",
+        );
       } else {
-        workerScript.errorMessage = makeRuntimeRejectMsg(
+        workerScript.errorMessage = helpers.makeRuntimeRejectMsg(
           workerScript,
           e.message + ((e.stack && "\nstack:\n" + e.stack.toString()) || ""),
         );
       }
       throw new ScriptDeath(workerScript);
-    } else if (isScriptErrorMessage(e)) {
+    } else if (helpers.isScriptErrorMessage(e)) {
       workerScript.errorMessage = e;
       throw new ScriptDeath(workerScript);
     } else if (e instanceof ScriptDeath) {
@@ -165,7 +91,7 @@ function startNetscript2Script(player: IPlayer, workerScript: WorkerScript): Pro
     }
 
     // Don't know what to do with it, let's try making an error message out of it
-    workerScript.errorMessage = makeRuntimeRejectMsg(workerScript, "" + e);
+    workerScript.errorMessage = helpers.makeRuntimeRejectMsg(workerScript, "" + e);
     throw new ScriptDeath(workerScript);
   });
 }
@@ -189,8 +115,11 @@ function startNetscript1Script(workerScript: WorkerScript): Promise<void> {
   }
 
   const interpreterInitialization = function (int: Interpreter, scope: unknown): void {
+    interface NS1 extends NS {
+      [key: string]: any;
+    }
     //Add the Netscript environment
-    const ns = NetscriptFunctions(workerScript);
+    const ns = NetscriptFunctions(workerScript) as NS1;
     for (const name of Object.keys(ns)) {
       const entry = ns[name];
       if (typeof entry === "function") {
@@ -242,7 +171,7 @@ function startNetscript1Script(workerScript: WorkerScript): Promise<void> {
           name === "vsprintf" ||
           name === "scp" ||
           name == "write" ||
-          name === "tryWrite" ||
+          name === "tryWritePort" ||
           name === "run" ||
           name === "exec"
         ) {
@@ -319,8 +248,8 @@ function startNetscript1Script(workerScript: WorkerScript): Promise<void> {
         }
       } catch (_e: unknown) {
         let e = String(_e);
-        if (!isScriptErrorMessage(e)) {
-          e = makeRuntimeRejectMsg(workerScript, e);
+        if (!helpers.isScriptErrorMessage(e)) {
+          e = helpers.makeRuntimeRejectMsg(workerScript, e);
         }
         workerScript.errorMessage = e;
         return reject(new ScriptDeath(workerScript));
@@ -598,7 +527,7 @@ function createAndAddWorkerScript(
         console.error("Evaluating workerscript returns an Error. THIS SHOULDN'T HAPPEN: " + e.toString());
         return;
       } else if (e instanceof ScriptDeath) {
-        if (isScriptErrorMessage(workerScript.errorMessage)) {
+        if (helpers.isScriptErrorMessage(workerScript.errorMessage)) {
           const errorTextArray = workerScript.errorMessage.split("|DELIMITER|");
           if (errorTextArray.length != 4) {
             console.error("ERROR: Something wrong with Error text in evaluator...");
@@ -622,7 +551,7 @@ function createAndAddWorkerScript(
           workerScript.log("", () => "Script killed");
           return; // Already killed, so stop here
         }
-      } else if (isScriptErrorMessage(e)) {
+      } else if (helpers.isScriptErrorMessage(e)) {
         dialogBoxCreate("Script runtime unknown error. This is a bug please contact game developer");
         console.error(
           "ERROR: Evaluating workerscript returns only error message rather than WorkerScript object. THIS SHOULDN'T HAPPEN: " +
diff --git a/src/ScriptEditor/NetscriptDefinitions.d.ts b/src/ScriptEditor/NetscriptDefinitions.d.ts
index 391044699..b20415c1c 100644
--- a/src/ScriptEditor/NetscriptDefinitions.d.ts
+++ b/src/ScriptEditor/NetscriptDefinitions.d.ts
@@ -4281,7 +4281,7 @@ export interface InfiltrationReward {
  * @public
  */
 export interface ILocation {
-  city: CityName | null;
+  city: string;
   name: string;
 }
 
@@ -6920,6 +6920,31 @@ export interface Corporation extends WarehouseAPI, OfficeAPI {
    * @returns An offer of investment
    */
   getInvestmentOffer(): InvestmentOffer;
+  /**
+   * Get list of materials
+   * @returns material names
+   */
+  getMaterialNames(): string[];
+  /**
+   * Get list of industry types
+   * @returns industry names
+   */
+  getIndustryTypes(): string[];
+  /**
+   * Get list of one-time unlockable upgrades
+   * @returns unlockable upgrades names
+   */
+  getUnlockables(): string[];
+  /**
+   * Get list of upgrade names
+   * @returns upgrade names
+   */
+  getUpgradeNames(): string[];
+  /**
+   * Get list of research names
+   * @returns research names
+   */
+  getResearchNames(): string[];
   /**
    * Accept investment based on you companies current valuation
    * @remarks
diff --git a/src/Terminal/determineAllPossibilitiesForTabCompletion.ts b/src/Terminal/determineAllPossibilitiesForTabCompletion.ts
index 321eb6983..81a94390f 100644
--- a/src/Terminal/determineAllPossibilitiesForTabCompletion.ts
+++ b/src/Terminal/determineAllPossibilitiesForTabCompletion.ts
@@ -309,7 +309,7 @@ export async function determineAllPossibilitiesForTabCompletion(
           return "--" + f[0];
         });
         try {
-          return flagFunc()(schema);
+          return flagFunc(schema);
         } catch (err) {
           return {};
         }
diff --git a/src/UncaughtPromiseHandler.ts b/src/UncaughtPromiseHandler.ts
index 775f92fca..e37404a33 100644
--- a/src/UncaughtPromiseHandler.ts
+++ b/src/UncaughtPromiseHandler.ts
@@ -1,10 +1,10 @@
 import { ScriptDeath } from "./Netscript/ScriptDeath";
-import { isScriptErrorMessage } from "./NetscriptEvaluator";
+import { helpers } from "./Netscript/NetscriptHelpers";
 import { dialogBoxCreate } from "./ui/React/DialogBox";
 
 export function setupUncaughtPromiseHandler(): void {
   window.addEventListener("unhandledrejection", function (e) {
-    if (isScriptErrorMessage(e.reason)) {
+    if (helpers.isScriptErrorMessage(e.reason)) {
       const errorTextArray = e.reason.split("|DELIMITER|");
       const hostname = errorTextArray[1];
       const scriptName = errorTextArray[2];
diff --git a/src/ui/InteractiveTutorial/InteractiveTutorialRoot.tsx b/src/ui/InteractiveTutorial/InteractiveTutorialRoot.tsx
index 6135ea103..dd7f168b1 100644
--- a/src/ui/InteractiveTutorial/InteractiveTutorialRoot.tsx
+++ b/src/ui/InteractiveTutorial/InteractiveTutorialRoot.tsx
@@ -381,7 +381,7 @@ export function InteractiveTutorialRoot(): React.ReactElement {
           <Typography>
             Scripts must end with the {tutorialScriptExtension} extension. Let's make a script now by entering{" "}
           </Typography>
-          <Typography classes={{ root: classes.textfield }}>{`[home ~/]> nano ${tutorialScriptName}`}</Typography>
+          <Typography classes={{ root: classes.textfield }}>{`[n00dles ~/]> nano ${tutorialScriptName}`}</Typography>
 
           <Typography>
             after the hack command finishes running (Sidenote: Pressing ctrl + c will end a command like hack early)
@@ -439,7 +439,7 @@ export function InteractiveTutorialRoot(): React.ReactElement {
             <br />
             To check how much RAM is available on this machine, enter
           </Typography>
-          <Typography classes={{ root: classes.textfield }}>{"[home ~/]> free"}</Typography>
+          <Typography classes={{ root: classes.textfield }}>{"[n00dles ~/]> free"}</Typography>
         </>
       ),
       canNext: false,
@@ -448,9 +448,9 @@ export function InteractiveTutorialRoot(): React.ReactElement {
       content: (
         <>
           <Typography>
-            We have 8GB of free RAM on this machine, which is enough to run our script. Let's run our script using
+            We have 4GB of free RAM on this machine, which is enough to run our script. Let's run our script using
           </Typography>
-          <Typography classes={{ root: classes.textfield }}>{`[home ~/]> run ${tutorialScriptName}`}</Typography>
+          <Typography classes={{ root: classes.textfield }}>{`[n00dles ~/]> run ${tutorialScriptName}`}</Typography>
         </>
       ),
       canNext: false,
@@ -497,7 +497,7 @@ export function InteractiveTutorialRoot(): React.ReactElement {
             One last thing about scripts, each active script contains logs that detail what it's doing. We can check
             these logs using the tail command. Do that now for the script we just ran by typing{" "}
           </Typography>
-          <Typography classes={{ root: classes.textfield }}>{`[home ~/]> tail ${tutorialScriptName}`}</Typography>
+          <Typography classes={{ root: classes.textfield }}>{`[n00dles ~/]> tail ${tutorialScriptName}`}</Typography>
         </>
       ),
       canNext: false,
diff --git a/src/ui/React/PromptManager.tsx b/src/ui/React/PromptManager.tsx
index de16b38a4..66b83522e 100644
--- a/src/ui/React/PromptManager.tsx
+++ b/src/ui/React/PromptManager.tsx
@@ -139,6 +139,10 @@ function PromptMenuSelect({ prompt, resolve }: IContentProps): React.ReactElemen
     return content;
   };
 
+  if (!Array.isArray(prompt?.options?.choices)) {
+    return <Typography>Error: Please provide an array of string choices</Typography>;
+  }
+
   return (
     <>
       <div style={{ display: "flex", alignItems: "center", paddingTop: "10px" }}>
diff --git a/test/cypress/integration/tutorial.spec.ts b/test/cypress/integration/tutorial.spec.ts
index a2a779aa4..d9b1c4619 100644
--- a/test/cypress/integration/tutorial.spec.ts
+++ b/test/cypress/integration/tutorial.spec.ts
@@ -60,7 +60,7 @@ describe("tutorial", () => {
     cy.findByText(/now we'll run the script/i);
     cy.findByRole("textbox").type("free{enter}");
 
-    cy.findByText(/We have 8GB of free RAM on this machine/i);
+    cy.findByText(/We have 4GB of free RAM on this machine/i);
     cy.findByRole("textbox").type("run n00dles.script{enter}");
 
     cy.findByText(/Your script is now running/i);