@latticexyz/cli 2.0.0-alpha.49 → 2.0.0-alpha.5

package/dist/{chunk-O6HOO6WA.js → chunk-L4YLJHLJ.js}

@@ -4,14 +4,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw new Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -32,7 +25,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 export {
-  __require,
   __commonJS,
   __toESM
 };

package/dist/{chunk-KPBNUPK6.js → chunk-SKNB74MT.js}

@@ -1,145 +1,3 @@
-// src/config/validation.ts
-import { ethers } from "ethers";
-import { ZodIssueCode } from "zod";
-function validateName(name, ctx) {
-  if (!/^\w+$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must contain only alphanumeric & underscore characters`
-    });
-  }
-}
-function validateCapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[A-Z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a capital letter`
-    });
-  }
-}
-function validateUncapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[a-z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a lowercase letter`
-    });
-  }
-}
-function validateEnum(members, ctx) {
-  if (members.length === 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not be empty`
-    });
-  }
-  if (members.length >= 256) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Length of enum must be < 256`
-    });
-  }
-  const duplicates = getDuplicates(members);
-  if (duplicates.length > 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not have duplicate names for: ${duplicates.join(", ")}`
-    });
-  }
-}
-function _factoryForValidateRoute(requireNonEmpty, requireSingleLevel) {
-  return (route, ctx) => {
-    if (route === "") {
-      if (requireNonEmpty) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not be empty`
-        });
-      }
-      return;
-    }
-    if (route[0] !== "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must start with "/"`
-      });
-    }
-    if (route[route.length - 1] === "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must not end with "/"`
-      });
-    }
-    const parts = route.split("/");
-    if (requireSingleLevel && parts.length > 2) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must only have one level (e.g. "/foo")`
-      });
-    }
-    for (let i = 1; i < parts.length; i++) {
-      if (parts[i] === "") {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not contain empty route fragments (e.g. "//")`
-        });
-      }
-      if (!/^\w+$/.test(parts[i])) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must contain only alphanumeric & underscore characters`
-        });
-      }
-    }
-  };
-}
-var validateRoute = _factoryForValidateRoute(true, false);
-var validateBaseRoute = _factoryForValidateRoute(false, false);
-var validateSingleLevelRoute = _factoryForValidateRoute(true, true);
-function validateEthereumAddress(address, ctx) {
-  if (!ethers.utils.isAddress(address)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Address must be a valid Ethereum address`
-    });
-  }
-}
-function getDuplicates(array) {
-  const checked = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const element of array) {
-    if (checked.has(element)) {
-      duplicates.add(element);
-    }
-    checked.add(element);
-  }
-  return [...duplicates];
-}
-function validateSelector(name, ctx) {
-  if (name.length > 16) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Selector must be <= 16 characters`
-    });
-  }
-  if (!/^\w*$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Selector must contain only alphanumeric & underscore characters`
-    });
-  }
-}
-function parseStaticArray(abiType) {
-  const matches = abiType.match(/^(\w+)\[(\d+)\]$/);
-  if (!matches)
-    return null;
-  return {
-    elementType: matches[1],
-    staticLength: Number.parseInt(matches[2])
-  };
-}
-
 // ../schema-type/src/typescript/SchemaType.ts
 var SchemaType = /* @__PURE__ */ ((SchemaType2) => {
   SchemaType2[SchemaType2["UINT8"] = 0] = "UINT8";
@@ -707,24 +565,162 @@ var StaticAbiTypes = AbiTypes.filter(
   (abiType) => getStaticByteLength(AbiTypeToSchemaType[abiType]) > 0
 );
 
+// src/render-solidity/userType.ts
+import { parseStaticArray } from "@latticexyz/config";
+function resolveAbiOrUserType(abiOrUserType, config) {
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    const schemaType = AbiTypeToSchemaType[abiOrUserType];
+    return {
+      schemaType,
+      renderTableType: getSchemaTypeInfo(schemaType)
+    };
+  }
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    if (staticArray.elementType in AbiTypeToSchemaType) {
+      return getStaticArrayTypeInfo(abiOrUserType, staticArray.elementType, staticArray.staticLength);
+    } else {
+      throw new Error("Static arrays of user types are not supported");
+    }
+  }
+  return getUserTypeInfo(abiOrUserType, config);
+}
+function importForAbiOrUserType(abiOrUserType, usedInDirectory, config) {
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    return void 0;
+  }
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    return void 0;
+  }
+  return {
+    symbol: abiOrUserType,
+    fromPath: config.userTypesPath + ".sol",
+    usedInPath: usedInDirectory
+  };
+}
+function getSchemaTypeInfo(schemaType) {
+  const staticByteLength = getStaticByteLength(schemaType);
+  const isDynamic = staticByteLength === 0;
+  const typeId = SchemaTypeToAbiType[schemaType];
+  return {
+    typeId,
+    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
+    enumName: SchemaType[schemaType],
+    staticByteLength,
+    isDynamic,
+    typeWrap: "",
+    typeUnwrap: "",
+    internalTypeId: typeId
+  };
+}
+function getUserTypeInfo(userType, config) {
+  if (userType in config.enums) {
+    const schemaType = 0 /* UINT8 */;
+    const staticByteLength = getStaticByteLength(schemaType);
+    const isDynamic = staticByteLength === 0;
+    const typeId = userType;
+    return {
+      schemaType,
+      renderTableType: {
+        typeId,
+        typeWithLocation: typeId,
+        enumName: SchemaType[schemaType],
+        staticByteLength,
+        isDynamic,
+        typeWrap: `${userType}`,
+        typeUnwrap: `uint8`,
+        internalTypeId: `${SchemaTypeToAbiType[schemaType]}`
+      }
+    };
+  }
+  throw new Error(`User type "${userType}" does not exist`);
+}
+function getStaticArrayTypeInfo(abiType, elementType, staticLength) {
+  const internalTypeId = elementType + "[]";
+  const schemaType = AbiTypeToSchemaType[internalTypeId];
+  return {
+    schemaType,
+    renderTableType: {
+      typeId: abiType,
+      typeWithLocation: `${abiType} memory`,
+      enumName: SchemaType[schemaType],
+      staticByteLength: 0,
+      isDynamic: true,
+      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
+      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
+      typeWrappingData: {
+        kind: "staticArray",
+        elementType,
+        staticLength
+      },
+      internalTypeId
+    }
+  };
+}
+
+// src/utils/format.ts
+import chalk from "chalk";
+import prettier from "prettier";
+import prettierPluginSolidity from "prettier-plugin-solidity";
+async function formatSolidity(content, prettierConfigPath) {
+  let config;
+  if (prettierConfigPath) {
+    config = await prettier.resolveConfig(prettierConfigPath);
+  }
+  try {
+    return prettier.format(content, {
+      plugins: [prettierPluginSolidity],
+      parser: "solidity-parse",
+      printWidth: 120,
+      semi: true,
+      tabWidth: 2,
+      useTabs: false,
+      bracketSpacing: true,
+      ...config
+    });
+  } catch (error) {
+    let message;
+    if (error instanceof Error) {
+      message = error.message;
+    } else {
+      message = error;
+    }
+    console.log(chalk.yellow(`Error during output formatting: ${message}`));
+    return content;
+  }
+}
+async function formatTypescript(content) {
+  return prettier.format(content, {
+    parser: "typescript"
+  });
+}
+
+// src/utils/formatAndWrite.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+async function formatAndWriteSolidity(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatSolidity(output);
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
+async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatTypescript(output);
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
+
 export {
-  SchemaType,
-  getStaticByteLength,
   encodeSchema,
   SchemaTypeArrayToElement,
-  SchemaTypeToAbiType,
-  AbiTypeToSchemaType,
-  AbiTypes,
-  StaticAbiTypes,
-  validateName,
-  validateCapitalizedName,
-  validateUncapitalizedName,
-  validateEnum,
-  validateRoute,
-  validateBaseRoute,
-  validateSingleLevelRoute,
-  validateEthereumAddress,
-  getDuplicates,
-  validateSelector,
-  parseStaticArray
+  resolveAbiOrUserType,
+  importForAbiOrUserType,
+  getSchemaTypeInfo,
+  getUserTypeInfo,
+  formatSolidity,
+  formatTypescript,
+  formatAndWriteSolidity,
+  formatAndWriteTypescript
 };

package/dist/chunk-VQTZJIFF.js

@@ -0,0 +1,353 @@
+import {
+  getOutDirectory,
+  getSrcDirectory
+} from "./chunk-FPG73MVN.js";
+
+// src/utils/deprecated/exec.ts
+import { execa } from "execa";
+function execLog(command, options) {
+  console.log("Cmd:");
+  console.log([command, ...options].join(" "));
+  return execa(command, options, {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+}
+
+// src/utils/deprecated/ids.ts
+import { keccak256 as keccak256Bytes, toUtf8Bytes } from "ethers/lib/utils.js";
+import { readFileSync } from "fs";
+var IDregex = new RegExp(/(?<=uint256 constant ID = uint256\(keccak256\(")(.*)(?="\))/);
+function extractIdFromFile(path5) {
+  const content = readFileSync(path5).toString();
+  const regexResult = IDregex.exec(content);
+  return regexResult && regexResult[0];
+}
+function keccak256(data) {
+  return keccak256Bytes(toUtf8Bytes(data));
+}
+
+// src/utils/deprecated/codegen.ts
+import { readFile, writeFile } from "fs/promises";
+import ejs from "ejs";
+import path from "path";
+var contractsDirectory = new URL("../src/contracts", import.meta.url).pathname;
+var stubLibDeploy = readFile(path.join(contractsDirectory, "LibDeployStub.sol"));
+async function generateLibDeploy(configPath, out, systems) {
+  const config = JSON.parse(await readFile(configPath, { encoding: "utf8" }));
+  config.initializers ??= [];
+  if (systems) {
+    const systemsArray = Array.isArray(systems) ? systems : [systems];
+    config.systems = config.systems.filter((system) => systemsArray.includes(system.name));
+  }
+  console.log(`Deploy config: 
+`, JSON.stringify(config, null, 2));
+  console.log("Generating deployment script");
+  const LibDeploy = await ejs.renderFile(path.join(contractsDirectory, "LibDeploy.ejs"), config, { async: true });
+  const libDeployPath = path.join(out, "LibDeploy.sol");
+  await writeFile(libDeployPath, LibDeploy);
+  return libDeployPath;
+}
+async function resetLibDeploy(out) {
+  await writeFile(path.join(out, "LibDeploy.sol"), await stubLibDeploy);
+}
+
+// src/utils/deprecated/deploy.ts
+import { constants, Wallet } from "ethers";
+
+// src/utils/deprecated/findLog.ts
+function findLog(deployLogLines, log) {
+  for (const logLine of deployLogLines) {
+    if (logLine.includes(log)) {
+      return logLine.split(log)[1].trim();
+    }
+  }
+  throw new Error("Can not find log");
+}
+
+// src/utils/deprecated/typegen.ts
+import { runTypeChain, glob as typechainGlob } from "typechain";
+import glob from "glob";
+import { rmSync as rmSync2, writeFileSync } from "fs";
+import path3 from "path";
+
+// src/utils/deprecated/build.ts
+import { execa as execa2 } from "execa";
+import { copyFileSync, mkdirSync, readdirSync, rmSync } from "fs";
+import path2 from "path";
+async function forgeBuild(options) {
+  if (options?.clear) {
+    const out = await getOutDirectory();
+    console.log("Clearing forge build output directory", out);
+    rmSync(out, { recursive: true, force: true });
+  }
+  console.log("Running forge build");
+  const child = execa2("forge", ["build"], {
+    stdio: ["inherit", "pipe", "inherit"]
+  });
+  return (await child).stdout;
+}
+function getContractsInDirectory(dir, exclude) {
+  return readdirSync(dir).filter((item) => item.includes(".sol")).map((item) => item.replace(".sol", "")).filter((item) => !exclude?.includes(item));
+}
+function copyAbi(inDir, outDir, contract) {
+  try {
+    return copyFileSync(path2.join(inDir, contract + ".sol", contract + ".json"), path2.join(outDir, contract + ".json"));
+  } catch (e) {
+    console.log("Skipping", contract);
+  }
+}
+function filterAbi(abiIn = "./out", abiOut = "./abi", exclude = ["Component", "IComponent"]) {
+  console.log(`Cleaning output directory (${abiOut}})`);
+  rmSync(abiOut, { recursive: true, force: true });
+  mkdirSync(abiOut);
+  const include = ["Component", "System", "World", "LibQuery"];
+  const contracts = getContractsInDirectory(abiIn, exclude).filter((item) => include.find((i) => item.includes(i)));
+  console.log("Selected ABIs: ", contracts);
+  for (const contract of contracts) {
+    if (contract.includes(".t"))
+      continue;
+    copyAbi(abiIn, abiOut, contract);
+  }
+  console.log("Successfully moved selected ABIs to ./abi");
+}
+
+// src/utils/deprecated/constants.ts
+var systemsDir = "systems";
+var componentsDir = "components";
+
+// src/utils/deprecated/typegen.ts
+async function generateAbiTypes(inputDir, outputDir, options) {
+  if (options?.clear) {
+    console.log("Clearing typechain output directory", outputDir);
+    rmSync2(outputDir, { recursive: true, force: true });
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const allFiles = typechainGlob(cwd, [`${inputDir}/**/+([a-zA-Z0-9_]).json`]);
+  const result = await runTypeChain({
+    cwd,
+    filesToProcess: allFiles,
+    allFiles,
+    outDir: outputDir,
+    target: "ethers-v5"
+  });
+  console.log(`Successfully generated ${result.filesGenerated} files`);
+}
+async function generateSystemTypes(outputDir, options) {
+  if (options?.clear) {
+    console.log("Clearing system type output files", outputDir);
+    rmSync2(path3.join(outputDir, "/SystemTypes.ts"), { force: true });
+    rmSync2(path3.join(outputDir, "/SystemAbis.mts"), { force: true });
+    rmSync2(path3.join(outputDir, "/SystemAbis.mjs"), { force: true });
+    rmSync2(path3.join(outputDir, "/SystemMappings.ts"), { force: true });
+  }
+  let abis = [];
+  let systems = [];
+  let ids = [];
+  let typePaths = [];
+  const srcDir = await getSrcDirectory();
+  const systemsPath = path3.join(srcDir, systemsDir, "*.sol");
+  const matches = glob.sync(systemsPath);
+  systems = matches.map((path5) => {
+    const fragments = path5.split("/");
+    return fragments[fragments.length - 1].split(".sol")[0];
+  });
+  ids = matches.map((path5, index) => {
+    const id = extractIdFromFile(path5);
+    if (!id) {
+      console.log("Path:", path5);
+      console.log("ID:", id);
+      throw new Error(
+        "No ID found for" + matches[index] + ". Make sure your system source file includes a ID definition (uint256 constant ID = uint256(keccak256(<ID>));)"
+      );
+    }
+    return id;
+  });
+  abis = systems.map((system) => `../abi/${system}.json`);
+  typePaths = systems.map((system) => `./ethers-contracts/${system}.ts`);
+  console.log("Matches", systems);
+  console.log("Solidity", ids);
+  console.log("Type paths", typePaths);
+  console.log("ABIs", abis);
+  const SystemMappings = `// Autogenerated using mud system-types
+export const systemToId = {
+${systems.map((system, index) => `  ${system}: "${ids[index]}",`).join("\n")}
+};
+
+export const idToSystem = {
+${ids.map((id, index) => `  "${id}": "${systems[index]}",`).join("\n")}
+};
+  `;
+  const SystemTypes = `// Autogenerated using mud system-types
+${typePaths.map((path5, index) => `import { ${systems[index]} } from "${path5.replace(".ts", "")}";`).join("\n")}
+ 
+export type SystemTypes = {
+${systems.map((system, index) => `  "${ids[index]}": ${system};`).join("\n")}
+};
+`;
+  const SystemAbis = `// Autogenerated using mud system-types
+${abis.map((path5, index) => `import ${systems[index]} from "${path5}";`).join("\n")}
+
+export const SystemAbis = {
+${systems.map((system, index) => `  "${ids[index]}": ${system}.abi,`).join("\n")}
+};
+`;
+  console.log("Generating files:");
+  console.log("SystemTypes.ts", SystemTypes);
+  console.log("SystemAbis.mts", SystemAbis);
+  console.log("SystemMappings.ts", SystemMappings);
+  writeFileSync(`${outputDir}/SystemTypes.ts`, SystemTypes);
+  writeFileSync(`${outputDir}/SystemAbis.mts`, SystemAbis);
+  writeFileSync(`${outputDir}/SystemAbis.mjs`, SystemAbis);
+  writeFileSync(`${outputDir}/SystemMappings.ts`, SystemMappings);
+}
+async function generateTypes(abiDir, outputDir = "./types", options) {
+  if (!abiDir) {
+    console.log("Compiling contracts");
+    const buildOutput = await getOutDirectory();
+    abiDir = "./abi";
+    await forgeBuild(options);
+    filterAbi(buildOutput, abiDir);
+  }
+  await generateAbiTypes(abiDir, path3.join(outputDir, "ethers-contracts"), options);
+  await generateSystemTypes(outputDir, options);
+}
+
+// src/utils/deprecated/deploy.ts
+import { execa as execa3 } from "execa";
+import { StaticJsonRpcProvider } from "@ethersproject/providers";
+import path4 from "path";
+var contractsDirectory2 = new URL("../src/contracts", import.meta.url).pathname;
+async function deploy(deployerPrivateKey, rpc = "http://localhost:8545", worldAddress, reuseComponents, gasPrice) {
+  const address = deployerPrivateKey ? new Wallet(deployerPrivateKey).address : constants.AddressZero;
+  if (gasPrice == null) {
+    try {
+      console.log("Fetching gas price...");
+      const provider = new StaticJsonRpcProvider(rpc, { name: "AnyNetwork", chainId: 1234 });
+      gasPrice = (await provider.getGasPrice()).toNumber() * 1.3;
+      console.log("Gas price:", gasPrice);
+    } catch (e) {
+      console.log("Could not fetch gas price");
+    }
+  }
+  const child = execa3(
+    "forge",
+    [
+      "script",
+      path4.join(contractsDirectory2, "/Deploy.sol"),
+      "--target-contract",
+      "Deploy",
+      "-vvv",
+      ...!deployerPrivateKey ? [] : ["--broadcast", "--private-keys", deployerPrivateKey],
+      "--sig",
+      "broadcastDeploy(address,address,bool)",
+      address,
+      // Deployer
+      worldAddress || constants.AddressZero,
+      // World address (0 = deploy a new world)
+      reuseComponents ? "true" : "false",
+      // Reuse components?
+      "--fork-url",
+      rpc,
+      ...gasPrice != null ? ["--with-gas-price", String(Math.round(gasPrice))] : []
+    ],
+    { stdio: ["inherit", "pipe", "pipe"] }
+  );
+  child.stderr?.on("data", (data) => console.log("stderr:", data.toString()));
+  child.stdout?.on("data", (data) => console.log(data.toString()));
+  const lines = (await child).stdout?.split("\n");
+  const deployedWorldAddress = findLog(lines, "world: address");
+  const initialBlockNumber = findLog(lines, "initialBlockNumber: uint256");
+  return { child: await child, deployedWorldAddress, initialBlockNumber };
+}
+async function generateAndDeploy(args) {
+  let libDeployPath;
+  let deployedWorldAddress;
+  let initialBlockNumber;
+  try {
+    libDeployPath = await generateLibDeploy(args.config, contractsDirectory2, args.systems);
+    await generateTypes(void 0, "./types", { clear: args.clear });
+    const result = await deploy(
+      args.deployerPrivateKey,
+      args.rpc,
+      args.worldAddress,
+      Boolean(args.reuseComponents),
+      args.gasPrice
+    );
+    deployedWorldAddress = result.deployedWorldAddress;
+    initialBlockNumber = result.initialBlockNumber;
+  } finally {
+    console.log("Cleaning up deployment script");
+    if (libDeployPath)
+      await resetLibDeploy(contractsDirectory2);
+  }
+  return { deployedWorldAddress, initialBlockNumber };
+}
+
+// src/utils/deprecated/hsr.ts
+import chokidar from "chokidar";
+import { readFileSync as readFileSync2 } from "fs";
+var ImportsRegex = new RegExp(/(?<=import ").*(?=";)|(?<=from ").*(?=";)/g);
+function extractImports(path5) {
+  const content = readFileSync2(path5).toString();
+  const regexResult = [...content.matchAll(ImportsRegex)].map((match) => match[0]).map((path6) => path6.split("/").at(-1));
+  return regexResult;
+}
+function findDependencies(file, dependencyGraph, visited = []) {
+  const dependencies = dependencyGraph[file] ?? [];
+  const subDependencies = dependencies.flatMap((d) => {
+    if (visited.includes(d)) {
+      console.warn("Circular dependency detected: ", d, dependencyGraph[d]);
+      return [];
+    }
+    return findDependencies(d, dependencyGraph, [...visited, d]);
+  });
+  return [.../* @__PURE__ */ new Set([...dependencies, ...subDependencies])];
+}
+function hsr(root, replaceSystems) {
+  const dependencyGraph = {};
+  const systems = /* @__PURE__ */ new Set();
+  console.log("Watching system file changes...");
+  chokidar.watch(root).on("all", async (event, path5) => {
+    console.log(`[${event}]: ${path5}`);
+    const changedFile = path5.split("/").at(-1);
+    if (["add", "change"].includes(event)) {
+      const imports = extractImports(path5);
+      for (const importedFile of imports) {
+        dependencyGraph[importedFile] ??= [];
+        dependencyGraph[importedFile].push(changedFile);
+      }
+      if (path5.includes("systems") && path5.includes(".sol"))
+        systems.add(changedFile);
+    }
+    if (event === "change") {
+      const dependencies = findDependencies(changedFile, dependencyGraph);
+      const changedSystems = [
+        ...new Set([changedFile, ...dependencies].filter((f) => systems.has(f)).map((f) => f.replace(".sol", "")))
+      ];
+      console.log("Systems to replace", changedSystems);
+      if (changedSystems.length > 0)
+        await replaceSystems(changedSystems);
+      console.log("Watching system file changes...");
+    }
+  });
+}
+
+export {
+  execLog,
+  IDregex,
+  extractIdFromFile,
+  keccak256,
+  generateLibDeploy,
+  resetLibDeploy,
+  findLog,
+  forgeBuild,
+  filterAbi,
+  systemsDir,
+  componentsDir,
+  generateAbiTypes,
+  generateSystemTypes,
+  generateTypes,
+  deploy,
+  generateAndDeploy,
+  hsr
+};