@taqueria/plugin-ligo 0.37.21 → 0.37.34

package/index.mjs

@@ -8,109 +8,33 @@ import { writeFile } from "fs/promises";
 // ligo_templates.ts
 var mligo_template = `
 type storage = int
-
-type parameter =
-  Increment of int
-| Decrement of int
-| Reset
-
 type return = operation list * storage
 
-// Two entrypoints
-
-let add (store, delta : storage * int) : storage = store + delta
-let sub (store, delta : storage * int) : storage = store - delta
-
-(* Main access point that dispatches to the entrypoints according to
-   the smart contract parameter. *)
-   
-let main (action, store : parameter * storage) : return =
- ([] : operation list),    // No operations
- (match action with
-   Increment (n) -> add (store, n)
- | Decrement (n) -> sub (store, n)
- | Reset         -> 0)
-`;
-var pascaligo_template = `
-type storage is int
-
-type parameter is
-  Increment of int
-| Decrement of int
-| Reset
-
-type return is list (operation) * storage
-
-// Two entrypoints
-
-function add (const store : storage; const delta : int) : storage is 
-  store + delta
-
-function sub (const store : storage; const delta : int) : storage is 
-  store - delta
-
-(* Main access point that dispatches to the entrypoints according to
-   the smart contract parameter. *)
-   
-function main (const action : parameter; const store : storage) : return is
- ((nil : list (operation)),    // No operations
-  case action of [
-    Increment (n) -> add (store, n)
-  | Decrement (n) -> sub (store, n)
-  | Reset         -> 0
-  ])
-`;
-var religo_template = `
-type storage = int;
-
-type parameter =
-  Increment (int)
-| Decrement (int)
-| Reset;
-
-type return = (list (operation), storage);
-
-// Two entrypoints
-
-let add = ((store, delta) : (storage, int)) : storage => store + delta;
-let sub = ((store, delta) : (storage, int)) : storage => store - delta;
-
-/* Main access point that dispatches to the entrypoints according to
-   the smart contract parameter. */
-   
-let main = ((action, store) : (parameter, storage)) : return => {
- (([] : list (operation)),    // No operations
- (switch (action) {
-  | Increment (n) => add ((store, n))
-  | Decrement (n) => sub ((store, n))
-  | Reset         => 0}))
-};
+(* Three entrypoints *)
+[@entry] let increment (delta : int) (store : storage) : return =
+  [], store + delta
+[@entry] let decrement (delta : int) (store : storage) : return =
+  [], store - delta
+[@entry] let reset (() : unit) (_ : storage) : return =
+  [], 0
 `;
 var jsligo_template = `
 type storage = int;
-
-type parameter =
-  ["Increment", int]
-| ["Decrement", int]
-| ["Reset"];
-
 type ret = [list<operation>, storage];
 
-// Two entrypoints
+// Three entrypoints
 
-const add = ([store, delta] : [storage, int]) : storage => store + delta;
-const sub = ([store, delta] : [storage, int]) : storage => store - delta;
+// @entry
+const increment = (delta : int, store : storage) : ret =>
+  [list([]), store + delta];
 
-/* Main access point that dispatches to the entrypoints according to
-   the smart contract parameter. */
+// @entry
+const decrement = (delta : int, store : storage) : ret =>
+  [list([]), store - delta];
 
-const main = ([action, store] : [parameter, storage]) : ret => {
- return [list([]) as list<operation>,    // No operations
- match (action, {
-  Increment:(n: int) => add ([store, n]),
-  Decrement:(n: int) => sub ([store, n]),
-  Reset    :()  => 0})]
-};
+// @entry
+const reset = (_ : unit, _ : storage) : ret =>
+  [list([]), 0];
 `;
 
 // createContract.ts
@@ -119,19 +43,11 @@ var getLigoTemplate = async (contractName, syntax) => {
   const ext = matchResult ? matchResult[0].substring(1) : null;
   if (syntax === "mligo")
     return mligo_template;
-  if (syntax === "ligo")
-    return pascaligo_template;
-  if (syntax === "religo")
-    return religo_template;
   if (syntax === "jsligo")
     return jsligo_template;
   if (syntax === void 0) {
     if (ext === "mligo")
       return mligo_template;
-    if (ext === "ligo")
-      return pascaligo_template;
-    if (ext === "religo")
-      return religo_template;
     if (ext === "jsligo")
       return jsligo_template;
     return sendAsyncErr(
@@ -156,7 +72,7 @@ import { sendAsyncErr as sendAsyncErr5, sendAsyncRes } from "@taqueria/node-sdk"
 // common.ts
 import { getDockerImage, sendErr } from "@taqueria/node-sdk";
 import { join } from "path";
-var LIGO_DEFAULT_IMAGE = "ligolang/ligo:0.69.0";
+var LIGO_DEFAULT_IMAGE = "ligolang/ligo:0.71.0";
 var LIGO_IMAGE_ENV_VAR = "TAQ_LIGO_IMAGE";
 var getLigoDockerImage = () => getDockerImage(LIGO_DEFAULT_IMAGE, LIGO_IMAGE_ENV_VAR);
 var getInputFilenameAbsPath = (parsedArgs, sourceFile) => join(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts", sourceFile);
@@ -170,22 +86,75 @@ var emitExternalError = (err, sourceFile) => {
 };
 
 // compile.ts
-import { execCmd, getArch, getArtifactsDir, sendAsyncErr as sendAsyncErr2, sendErr as sendErr2, sendJsonRes, sendWarn } from "@taqueria/node-sdk";
+import {
+  execCmd,
+  getArch,
+  getArtifactsDir,
+  sendErr as sendErr2,
+  sendJsonRes,
+  sendWarn
+} from "@taqueria/node-sdk";
 import { access, readFile, writeFile as writeFile2 } from "fs/promises";
-import { basename, extname, join as join2 } from "path";
+import { basename, join as join2 } from "path";
 var COMPILE_ERR_MSG = "Not compiled";
 var isStorageKind = (exprKind) => exprKind === "storage" || exprKind === "default_storage";
-var isLIGOFile = (sourceFile) => /.+\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
+var isSupportedLigoSyntax = (sourceFile) => /\.(mligo|jsligo)$/.test(sourceFile);
+var isUnsupportedLigoSyntax = (sourceFile) => /\.(ligo|religo)$/.test(sourceFile);
+var isLIGOFile = (sourceFile) => isSupportedLigoSyntax(sourceFile) || isUnsupportedLigoSyntax(sourceFile);
 var isStorageListFile = (sourceFile) => /.+\.(storageList|storages)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
 var isParameterListFile = (sourceFile) => /.+\.(parameterList|parameters)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
-var isContractFile = (sourceFile) => isLIGOFile(sourceFile) && !isStorageListFile(sourceFile) && !isParameterListFile(sourceFile);
-var getModuleName = async (parsedArgs, sourceFile) => {
-  const fileContent = await readFile(getInputFilenameAbsPath(parsedArgs, sourceFile), "utf8");
-  if (fileContent.includes("@entry") && fileContent.includes("module")) {
-    const match = fileContent.match(/module ([^\s]+)/);
-    return match ? match[1] : void 0;
+var listContractModules = async (parsedArgs, sourceFile) => {
+  try {
+    await getArch();
+    const cmd = await getListDeclarationsCmd(parsedArgs, sourceFile);
+    const { stderr, stdout } = await execCmd(cmd);
+    if (stderr.length > 0)
+      return Promise.reject(stderr);
+    return JSON.parse(stdout).declarations.reduce(
+      (acc, decl) => {
+        const srcFile = removeExt(basename(sourceFile));
+        const syntax = extractExt(sourceFile).replace(".", "");
+        if (decl === "main") {
+          return [...acc, { moduleName: srcFile, sourceName: sourceFile, sourceFile, type: "file-main", syntax }];
+        } else if (decl === "$main") {
+          return [...acc, { moduleName: srcFile, sourceName: sourceFile, sourceFile, type: "file-entry", syntax }];
+        } else if (decl.endsWith(".main")) {
+          const moduleName = decl.replace(/\.main$/, "");
+          return [...acc, {
+            moduleName,
+            sourceName: `${sourceFile}/${moduleName}`,
+            sourceFile,
+            type: "module-main",
+            syntax
+          }];
+        } else if (decl.endsWith(".$main")) {
+          const moduleName = decl.replace(/\.\$main$/, "");
+          return [...acc, {
+            moduleName,
+            sourceName: `${sourceFile}/${moduleName}`,
+            sourceFile,
+            type: "module-entry",
+            syntax
+          }];
+        }
+        return acc;
+      },
+      []
+    );
+  } catch (err) {
+    emitExternalError(err, sourceFile);
+    return [];
   }
-  return void 0;
+};
+var getListDeclarationsCmd = async (parsedArgs, sourceFile) => {
+  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
+  if (!projectDir)
+    throw new Error(`No project directory provided`);
+  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} info list-declarations`;
+  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
+  const flags = "--display-format json";
+  const cmd = `${baseCmd} ${inputFile} ${flags}`;
+  return cmd;
 };
 var extractExt = (path) => {
   const matchResult = path.match(/\.(ligo|religo|mligo|jsligo)$/);
@@ -196,291 +165,396 @@ var removeExt = (path) => {
   return path.replace(extRegex, "");
 };
 var isOutputFormatJSON = (parsedArgs) => parsedArgs.json;
-var getOutputContractFilename = (parsedArgs, sourceFile) => {
-  const outputFile = basename(sourceFile, extname(sourceFile));
+var getOutputContractFilename = (parsedArgs, module) => {
   const ext = isOutputFormatJSON(parsedArgs) ? ".json" : ".tz";
-  return join2(getArtifactsDir(parsedArgs), `${outputFile}${ext}`);
+  return join2(getArtifactsDir(parsedArgs), `${module.moduleName}${ext}`);
 };
-var getContractNameForExpr = (sourceFile, exprKind) => {
-  try {
-    return isStorageKind(exprKind) ? sourceFile.match(/.+(?=\.(?:storageList|storages)\.(ligo|religo|mligo|jsligo))/).join(".") : sourceFile.match(/.+(?=\.(?:parameterList|parameters)\.(ligo|religo|mligo|jsligo))/).join(".");
-  } catch (err) {
-    throw new Error(`Something went wrong internally when dealing with filename format: ${err}`);
-  }
-};
-var getOutputExprFilename = (parsedArgs, sourceFile, exprKind, exprName) => {
-  const contractName = basename(getContractNameForExpr(sourceFile, exprKind), extname(sourceFile));
+var getOutputExprFilename = (parsedArgs, module, exprKind, exprName) => {
+  const contractName = module.moduleName;
   const ext = isOutputFormatJSON(parsedArgs) ? ".json" : ".tz";
   const outputFile = exprKind === "default_storage" ? `${contractName}.default_storage${ext}` : `${contractName}.${exprKind}.${exprName}${ext}`;
   return join2(getArtifactsDir(parsedArgs), `${outputFile}`);
 };
-var getCompileContractCmd = async (parsedArgs, sourceFile) => {
+var getCompileContractCmd = async (parsedArgs, sourceFile, module) => {
   const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
   if (!projectDir)
-    throw `No project directory provided`;
+    throw new Error(`No project directory provided`);
   const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile contract`;
   const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-  const outputFile = `-o ${getOutputContractFilename(parsedArgs, sourceFile)}`;
+  const outputFile = `-o ${getOutputContractFilename(parsedArgs, module)}`;
   const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
-  const moduleName = await getModuleName(parsedArgs, sourceFile);
-  const entryFlag = moduleName ? `-m ${moduleName}` : "";
-  const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}${entryFlag}`;
+  const moduleFlag = module.type.startsWith("file-") ? "" : `-m ${module.moduleName}`;
+  const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}${moduleFlag}`;
   return cmd;
 };
-var getCompileExprCmd = (parsedArgs, sourceFile, exprKind, exprName) => {
+var getCompileExprCmd = (parsedArgs, sourceFile, module, exprKind, exprName) => {
   const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
   if (!projectDir)
-    throw `No project directory provided`;
+    throw new Error(`No project directory provided`);
   const compilerType = isStorageKind(exprKind) ? "storage" : "parameter";
   const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile ${compilerType}`;
   const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-  const outputFile = `-o ${getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName)}`;
+  const outputFile = `-o ${getOutputExprFilename(parsedArgs, module, exprKind, exprName)}`;
   const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
-  const cmd = `${baseCmd} ${inputFile} ${exprName} ${outputFile} ${flags}`;
+  const moduleFlag = (() => {
+    switch (module.type) {
+      case "file-main":
+      case "file-entry":
+        return "-m Contract";
+      default:
+        return `-m Contract.${module.moduleName}`;
+    }
+  })();
+  const cmd = `${baseCmd} ${inputFile} ${exprName} ${outputFile} ${flags} ${moduleFlag}`;
   return cmd;
 };
-var compileContract = async (parsedArgs, sourceFile) => {
+var compileContract = async (parsedArgs, sourceFile, module) => {
   try {
     await getArch();
-    const cmd = await getCompileContractCmd(parsedArgs, sourceFile);
+    const cmd = await getCompileContractCmd(parsedArgs, sourceFile, module);
     const { stderr } = await execCmd(cmd);
     if (stderr.length > 0)
       sendWarn(stderr);
     return {
-      contract: sourceFile,
-      artifact: getOutputContractFilename(parsedArgs, sourceFile)
+      source: module.sourceName,
+      artifact: getOutputContractFilename(parsedArgs, module)
     };
   } catch (err) {
     emitExternalError(err, sourceFile);
     return {
-      contract: sourceFile,
+      source: module.sourceName,
       artifact: COMPILE_ERR_MSG
     };
   }
 };
-var compileExpr = (parsedArgs, sourceFile, exprKind) => (exprName) => getArch().then(() => getCompileExprCmd(parsedArgs, sourceFile, exprKind, exprName)).then(execCmd).then(({ stderr }) => {
-  if (stderr.length > 0)
-    sendWarn(stderr);
-  const artifactName = getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName);
-  return {
-    contract: sourceFile,
-    artifact: artifactName
-  };
-}).catch((err) => {
-  emitExternalError(err, sourceFile);
-  return {
-    contract: sourceFile,
-    artifact: COMPILE_ERR_MSG
-  };
-});
+var compileExpr = (parsedArgs, sourceFile, module, exprKind) => (exprName) => {
+  return getArch().then(() => getCompileExprCmd(parsedArgs, sourceFile, module, exprKind, exprName)).then(execCmd).then(({ stderr }) => {
+    if (stderr.length > 0)
+      sendWarn(stderr);
+    const artifactName = getOutputExprFilename(parsedArgs, module, exprKind, exprName);
+    return {
+      source: module.sourceName,
+      artifact: artifactName
+    };
+  }).catch((err) => {
+    emitExternalError(err, sourceFile);
+    return {
+      source: module.sourceName,
+      artifact: `${sourceFile} not compiled`
+    };
+  });
+};
 var getExprNames = (parsedArgs, sourceFile) => readFile(getInputFilenameAbsPath(parsedArgs, sourceFile), "utf8").then((data) => data.match(/(?<=\n\s*(let|const)\s+)[a-zA-Z0-9_]+/g) ?? []);
-var compileExprs = (parsedArgs, sourceFile, exprKind) => getExprNames(parsedArgs, sourceFile).then((exprNames) => {
+var compileExprs = (parsedArgs, sourceFile, module, exprKind) => getExprNames(parsedArgs, sourceFile).then((exprNames) => {
   if (exprNames.length === 0)
     return [];
   const firstExprName = exprNames.slice(0, 1)[0];
   const restExprNames = exprNames.slice(1, exprNames.length);
   const firstExprKind = isStorageKind(exprKind) ? "default_storage" : "parameter";
   const restExprKind = isStorageKind(exprKind) ? "storage" : "parameter";
-  const firstExprResult = compileExpr(parsedArgs, sourceFile, firstExprKind)(firstExprName);
-  const restExprResults = restExprNames.map(compileExpr(parsedArgs, sourceFile, restExprKind));
+  const firstExprResult = compileExpr(parsedArgs, sourceFile, module, firstExprKind)(firstExprName);
+  const restExprResults = restExprNames.map(compileExpr(parsedArgs, sourceFile, module, restExprKind));
   return Promise.all([firstExprResult].concat(restExprResults));
 }).catch((err) => {
   emitExternalError(err, sourceFile);
   return [{
-    contract: sourceFile,
+    source: module.sourceName,
     artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions compiled`
   }];
 }).then(
   (results) => results.length > 0 ? results : [{
-    contract: sourceFile,
+    source: module.sourceName,
     artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions found`
   }]
-).then(mergeArtifactsOutput(sourceFile));
-var tryLegacyStorageNamingConvention = (parsedArgs, sourceFile) => {
-  const storageListFile = `${removeExt(sourceFile)}.storages${extractExt(sourceFile)}`;
-  const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
-  return access(storageListFilename).then(() => {
-    sendWarn(
-      `Warning: The naming convention of "<CONTRACT>.storages.<EXTENSION>" is deprecated and renamed to "<CONTRACT>.storageList.<EXTENSION>". Please adjust your storage file names accordingly
-`
-    );
-    return compileExprs(parsedArgs, storageListFile, "storage");
-  });
-};
-var tryLegacyParameterNamingConvention = (parsedArgs, sourceFile) => {
-  const parameterListFile = `${removeExt(sourceFile)}.parameters${extractExt(sourceFile)}`;
-  const parameterListFilename = getInputFilenameAbsPath(parsedArgs, parameterListFile);
-  return access(parameterListFilename).then(() => {
-    sendWarn(
-      `Warning: The naming convention of "<CONTRACT>.parameters.<EXTENSION>" is deprecated and renamed to "<CONTRACT>.parameterList.<EXTENSION>". Please adjust your parameter file names accordingly
-`
-    );
-    return compileExprs(parsedArgs, parameterListFile, "parameter");
-  });
-};
-var initContentForStorage = (sourceFile) => {
-  const linkToContract = `#include "${sourceFile}"
+);
+var initContentForStorage = (module) => {
+  const linkToContract = `#import "${module.sourceFile}" "Contract"
 
 `;
-  const instruction = "// Define your initial storage values as a list of LIGO variable definitions,\n// the first of which will be considered the default value to be used for origination later on\n";
-  const ext = extractExt(sourceFile);
-  let syntax = "";
-  if (ext === ".ligo")
-    syntax = "// E.g. const aStorageValue : aStorageType = 10;\n\n";
-  else if (ext === ".religo")
-    syntax = "// E.g. let aStorageValue : aStorageType = 10;\n\n";
-  else if (ext === ".mligo")
-    syntax = "// E.g. let aStorageValue : aStorageType = 10\n\n";
-  else if (ext === ".jsligo")
-    syntax = "// E.g. const aStorageValue : aStorageType = 10;\n\n";
-  return linkToContract + instruction + syntax;
+  const instruction = "// Define your initial storage values as a list of LIGO variable definitions, the first of which will be considered the default value to be used for origination later on\n";
+  const syntax = (() => {
+    const pair = [module.syntax, module.type].join("-");
+    switch (pair) {
+      case "mligo-file-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was not within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. let storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract",
+          "// E.g. let storage : Contract.storage = 10"
+        ];
+        break;
+      case "mligo-file-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. let storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract",
+          "// E.g. let storage : Contract.storage = 10"
+        ];
+        break;
+      case "mligo-module-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. let storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract",
+          `// E.g. let storage : Contract.${module.moduleName}.storage = 10`
+        ];
+        break;
+      case "mligo-module-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. let storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract",
+          `// E.g. let storage : Contract.${module.moduleName}.storage = 10`
+        ];
+        break;
+      case "jsligo-file-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was not within a namespace. As such, the examples below are written with that assumption in mind.",
+          `// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. const storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.",
+          "// E.g. const storage : Contract.storage = 10"
+        ];
+        break;
+      case "jsligo-file-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a namespace. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. const storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.",
+          "// E.g. const storage : Contract.storage = 10"
+        ];
+        break;
+      case "jsligo-module-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was within a namespace. As such, the examples below are written with that assumption in mind.",
+          `// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. const storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.",
+          `// E.g. const storage : Contract.${module.moduleName}.storage = 10`
+        ];
+        break;
+      case "jsligo-module-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a namespace. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your storage is a simple value, you can define it directly",
+          "// E.g. const storage = 10",
+          "",
+          "// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.",
+          `// E.g. const storage : Contract.${module.moduleName}.storage = 10`
+        ];
+        break;
+      default:
+        return [];
+    }
+  })();
+  return linkToContract + instruction + syntax.join("\n");
 };
-var initContentForParameter = (sourceFile) => {
-  const linkToContract = `#include "${sourceFile}"
+var initContentForParameter = (module) => {
+  const linkToContract = `#import "${module.sourceFile}" "Contract"
 
 `;
   const instruction = "// Define your parameter values as a list of LIGO variable definitions\n";
-  const ext = extractExt(sourceFile);
-  let syntax = "";
-  if (ext === ".ligo")
-    syntax = "// E.g. const aParameterValue : aParameterType = Increment(1);\n\n";
-  else if (ext === ".religo")
-    syntax = "// E.g. let aParameterValue : aParameterType = (Increment (1));\n\n";
-  else if (ext === ".mligo")
-    syntax = "// E.g. let aParameterValue : aParameterType = Increment 1\n\n";
-  else if (ext === ".jsligo")
-    syntax = "// E.g. const aParameterValue : aParameterType = (Increment (1));\n\n";
-  return linkToContract + instruction + syntax;
+  const syntax = (() => {
+    const pair = [module.syntax, module.type].join("-");
+    switch (pair) {
+      case "mligo-file-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was not within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. let default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          "// E.g. let default_parameter : Contract.parameter = 10"
+        ];
+        break;
+      case "mligo-file-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. let default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          "// E.g. let default_parameter : parameter_of Contract = 10"
+        ];
+        break;
+      case "mligo-module-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. let default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          `// E.g. let default_parameter : Contract.${module.moduleName}.parameter = 10`
+        ];
+        break;
+      case "mligo-module-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a named module. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. let default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          `// E.g. let default_parameter : parameter_of Contract.${module.moduleName} = 10`
+        ];
+        break;
+      case "jsligo-file-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was not within a namespace. As such, the examples below are written with that assumption in mind.",
+          `// NOTE: The "parameter" type should be exported from the contract file (${module.sourceFile})`,
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. const default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          "// E.g. const default_parameter : Contract.parameter = 10"
+        ];
+        break;
+      case "jsligo-file-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a namespace. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. const default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          "// E.g. const default_parameter : parameter_of Contract = 10"
+        ];
+        break;
+      case "jsligo-module-main":
+        return [
+          "// When this file was created, the smart contract was defined with a main function that was within a namespace. As such, the examples below are written with that assumption in mind.",
+          `// NOTE: The "parameter" type should be exported from the contract file (${module.sourceFile})`,
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. const default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          `// E.g. const default_parameter : Contract.${module.moduleName}.parameter = 10`
+        ];
+        break;
+      case "jsligo-module-entry":
+        return [
+          "// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a namespace. As such, the examples below are written with that assumption in mind.",
+          "",
+          "// If your parameter is a simple value, you can define it directly",
+          "// E.g. const default_parameter = 10",
+          "",
+          "// For added type-safety, you can reference the type of your parameter from the contract",
+          `// E.g. const default_parameter : parameter_of Contract.${module.moduleName} = 10`
+        ];
+        break;
+      default:
+        return [];
+    }
+  })();
+  return linkToContract + instruction + syntax.join("\n");
 };
-var compileContractWithStorageAndParameter = async (parsedArgs, sourceFile) => {
-  const contractCompileResult = await compileContract(parsedArgs, sourceFile);
+var compileContractWithStorageAndParameter = async (parsedArgs, sourceFile, module) => {
+  const contractCompileResult = await compileContract(parsedArgs, sourceFile, module);
   if (contractCompileResult.artifact === COMPILE_ERR_MSG)
     return [contractCompileResult];
-  const storageListFile = `${removeExt(sourceFile)}.storageList${extractExt(sourceFile)}`;
+  const storageListFile = `${module.moduleName}.storageList${extractExt(sourceFile)}`;
   const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
-  const storageCompileResult = await access(storageListFilename).then(() => compileExprs(parsedArgs, storageListFile, "storage")).catch(() => tryLegacyStorageNamingConvention(parsedArgs, sourceFile)).catch(() => {
+  const storageCompileResult = await access(storageListFilename).then(() => compileExprs(parsedArgs, storageListFile, module, "storage")).catch(() => {
     sendWarn(
-      `Note: storage file associated with "${sourceFile}" can't be found, so "${storageListFile}" has been created for you. Use this file to define all initial storage values for this contract
+      `Note: storage file associated with "${module.moduleName}" can't be found, so "${storageListFile}" has been created for you. Use this file to define all initial storage values for this contract
 `
     );
-    writeFile2(storageListFilename, initContentForStorage(sourceFile), "utf8");
+    return writeFile2(storageListFilename, initContentForStorage(module), "utf8");
   });
-  const parameterListFile = `${removeExt(sourceFile)}.parameterList${extractExt(sourceFile)}`;
+  const parameterListFile = `${module.moduleName}.parameterList${extractExt(sourceFile)}`;
   const parameterListFilename = getInputFilenameAbsPath(parsedArgs, parameterListFile);
-  const parameterCompileResult = await access(parameterListFilename).then(() => compileExprs(parsedArgs, parameterListFile, "parameter")).catch(() => tryLegacyParameterNamingConvention(parsedArgs, sourceFile)).catch(() => {
+  const parameterCompileResult = await access(parameterListFilename).then(() => compileExprs(parsedArgs, parameterListFile, module, "parameter")).catch(() => {
     sendWarn(
-      `Note: parameter file associated with "${sourceFile}" can't be found, so "${parameterListFile}" has been created for you. Use this file to define all parameter values for this contract
+      `Note: parameter file associated with "${module.moduleName}" can't be found, so "${parameterListFile}" has been created for you. Use this file to define all parameter values for this contract
 `
     );
-    writeFile2(parameterListFilename, initContentForParameter(sourceFile), "utf8");
+    return writeFile2(parameterListFilename, initContentForParameter(module), "utf8");
   });
-  let compileResults = [contractCompileResult];
-  if (storageCompileResult)
-    compileResults = compileResults.concat(storageCompileResult);
-  if (parameterCompileResult)
-    compileResults = compileResults.concat(parameterCompileResult);
-  return compileResults;
-};
-var mergeArtifactsOutput = (sourceFile) => (tableRows) => {
-  const artifactsOutput = tableRows.reduce(
-    (acc, row) => row.artifact === COMPILE_ERR_MSG ? acc : `${acc}${row.artifact}
-`,
-    ""
-  );
-  return [{
-    contract: sourceFile,
-    artifact: artifactsOutput
-  }];
+  const storageArtifacts = storageCompileResult ? storageCompileResult.map((res) => res.artifact).join("\n") : "";
+  const parameterArtifacts = parameterCompileResult ? parameterCompileResult.map((res) => res.artifact).join("\n") : "";
+  const combinedArtifact = [
+    contractCompileResult.artifact,
+    storageArtifacts,
+    parameterArtifacts
+  ].filter(Boolean).join("\n");
+  const combinedRow = {
+    source: module.sourceName,
+    artifact: combinedArtifact
+  };
+  return [combinedRow];
 };
-var compile = (parsedArgs) => {
+var compile = async (parsedArgs) => {
   const sourceFile = parsedArgs.sourceFile;
-  let p;
-  if (isStorageListFile(sourceFile))
-    p = compileExprs(parsedArgs, sourceFile, "storage");
-  else if (isParameterListFile(sourceFile))
-    p = compileExprs(parsedArgs, sourceFile, "parameter");
-  else if (isContractFile(sourceFile))
-    p = compileContractWithStorageAndParameter(parsedArgs, sourceFile);
-  else {
-    return sendAsyncErr2(
-      `${sourceFile} doesn't have a valid LIGO extension ('.ligo', '.religo', '.mligo' or '.jsligo')`
-    );
+  if (!isLIGOFile(sourceFile)) {
+    sendErr2(`${sourceFile} is not a LIGO file`);
+    return;
+  }
+  if (isStorageListFile(sourceFile) || isParameterListFile(sourceFile)) {
+    sendErr2(`Storage and parameter list files are not meant to be compiled directly`);
+    return;
+  }
+  if (isUnsupportedLigoSyntax(sourceFile)) {
+    sendErr2(`Unsupported LIGO syntax detected in ${sourceFile}. Note, we only support .jsligo and .mligo files.`);
+    return;
+  }
+  try {
+    const modules = await listContractModules(parsedArgs, sourceFile);
+    if (modules.length === 0) {
+      return sendJsonRes([
+        {
+          source: sourceFile,
+          artifact: `No contract modules found in "${sourceFile}"`
+        }
+      ]);
+    }
+    let allCompileResults = [];
+    for (const module of modules) {
+      if (parsedArgs.module && parsedArgs.module !== module.moduleName)
+        continue;
+      const compileResults = await compileContractWithStorageAndParameter(parsedArgs, sourceFile, module);
+      allCompileResults = allCompileResults.concat(compileResults);
+    }
+    sendJsonRes(allCompileResults, { footer: `
+Compiled ${allCompileResults.length} contract(s) in "${sourceFile}"` });
+  } catch (err) {
+    sendErr2(`Error processing "${sourceFile}": ${err}`);
   }
-  return p.then(sendJsonRes).catch((err) => sendErr2(err, false));
 };
 var compile_default = compile;
 
 // compile-all.ts
 import { sendErr as sendErr3, sendJsonRes as sendJsonRes2 } from "@taqueria/node-sdk";
 import glob from "fast-glob";
-import { readFile as readFile2 } from "fs/promises";
 import { join as join3 } from "path";
-var isMainContract = async (parsedArgs, contractFilename) => {
-  if (/storageList\.\w{0,2}ligo$/.test(contractFilename))
-    return false;
-  const fileContent = await readFile2(getInputFilenameAbsPath(parsedArgs, contractFilename), "utf8");
-  const entryOrMainFunctionRegex = /@entry|((const|let|function)\s+main)/g;
-  return entryOrMainFunctionRegex.test(fileContent);
-};
-var parseIncludes = async (parsedArgs, contractFilename) => {
-  const fileContent = await readFile2(getInputFilenameAbsPath(parsedArgs, contractFilename), "utf8");
-  const includeRegex = /#include\s+"([^"]+\.m?ligo)"/g;
-  let match;
-  const includes = [];
-  while ((match = includeRegex.exec(fileContent)) !== null) {
-    includes.push(match[1]);
-  }
-  return includes;
-};
-var buildDependencyGraph = async (parsedArgs, contractFilenames) => {
-  const graph = /* @__PURE__ */ new Map();
-  for (const filename of contractFilenames) {
-    const includes = await parseIncludes(parsedArgs, filename);
-    graph.set(filename, new Set(includes));
-  }
-  return graph;
-};
-var visit = (node, graph, visited, stack) => {
-  if (stack.has(node))
-    return [true, visited];
-  if (!visited.has(node)) {
-    const newVisited = new Set(visited).add(node);
-    const newStack = new Set(stack).add(node);
-    const [circular, updatedVisited] = Array.from(graph.get(node) || []).reduce(
-      ([circularFound, vSet], dependency) => {
-        const [result, v] = visit(dependency, graph, vSet, newStack);
-        return [circularFound || result, v];
-      },
-      [false, newVisited]
-    );
-    if (!circular)
-      return [false, updatedVisited];
-  }
-  return [false, visited];
-};
-var detectCircularDependencies = (graph) => {
-  const { safeFiles, circularFiles, visited } = Array.from(graph.keys()).reduce(
-    (acc, filename) => {
-      const [isCircular, updatedVisited] = visit(
-        filename,
-        graph,
-        acc.visited,
-        /* @__PURE__ */ new Set()
-      );
-      if (isCircular) {
-        acc.circularFiles.push(filename);
-      } else {
-        acc.safeFiles.push(filename);
-      }
-      acc.visited = updatedVisited;
-      return acc;
-    },
-    { safeFiles: [], circularFiles: [], visited: /* @__PURE__ */ new Set() }
-  );
-  return { safeFiles, circularFiles };
-};
 var compileAll = async (parsedArgs) => {
-  let p = [];
+  let compilePromises = [];
   const contractFilenames = await glob(
     ["**/*.ligo", "**/*.religo", "**/*.mligo", "**/*.jsligo"],
     {
@@ -488,27 +562,20 @@ var compileAll = async (parsedArgs) => {
       absolute: false
     }
   );
-  const dependencyGraph = await buildDependencyGraph(parsedArgs, contractFilenames);
-  const { safeFiles, circularFiles } = detectCircularDependencies(dependencyGraph);
-  for (const filename of safeFiles) {
-    if (await isMainContract(parsedArgs, filename)) {
-      p.push(compileContractWithStorageAndParameter(parsedArgs, filename));
+  for (const filename of contractFilenames) {
+    if (isStorageListFile(filename) || isParameterListFile(filename))
+      continue;
+    const moduleNames = await listContractModules(parsedArgs, filename);
+    for (const moduleName of moduleNames) {
+      compilePromises.push(compileContractWithStorageAndParameter(parsedArgs, filename, moduleName));
     }
   }
-  return Promise.all(p).then((tables) => tables.flat()).then((table) => {
-    if (circularFiles.length > 0) {
-      console.warn(
-        "Warning: Circular dependencies detected in the following files. They have been skipped:"
-      );
-      console.warn(circularFiles.join(", "));
-    }
-    return table;
-  }).then(sendJsonRes2).catch((err) => sendErr3(err, false));
+  return Promise.all(compilePromises).then((tables) => tables.flat()).then(sendJsonRes2).catch((err) => sendErr3(err, false));
 };
 var compile_all_default = compileAll;
 
 // ligo.ts
-import { execCmd as execCmd2, getArch as getArch2, sendAsyncErr as sendAsyncErr3, sendRes, spawnCmd } from "@taqueria/node-sdk";
+import { execCmd as execCmd2, getArch as getArch2, sendAsyncErr as sendAsyncErr3, sendRes as sendRes2, spawnCmd } from "@taqueria/node-sdk";
 import { readJsonFile, writeJsonFile } from "@taqueria/node-sdk";
 import { join as join4 } from "path";
 var getArbitraryLigoCmd = (parsedArgs, uid, gid, userArgs) => {
@@ -531,7 +598,7 @@ var getArbitraryLigoCmd = (parsedArgs, uid, gid, userArgs) => {
   const processedUserArgs = userArgs.split(" ").map((arg) => arg.startsWith("\\-") ? arg.substring(1) : arg).filter(
     (arg) => arg
   );
-  const args = baseArgs.concat(processedUserArgs);
+  const args = [...baseArgs, ...processedUserArgs, "--skip-analytics"];
   const envVars = { "DOCKER_DEFAULT_PLATFORM": "linux/amd64" };
   return [
     [binary, ...args].join(" "),
@@ -555,7 +622,7 @@ var runArbitraryLigoCmd = (parsedArgs, cmd) => ensureEsyExists(parsedArgs).then(
 ).catch((err) => sendAsyncErr3(`An internal error has occurred: ${err.message}`));
 var ligo = (parsedArgs) => {
   const args = parsedArgs.command;
-  return runArbitraryLigoCmd(parsedArgs, args).then(sendRes).catch((err) => sendAsyncErr3(err, false));
+  return runArbitraryLigoCmd(parsedArgs, args).then(sendRes2).catch((err) => sendAsyncErr3(err, false));
 };
 var ligo_default = ligo;
 
@@ -648,6 +715,12 @@ Plugin.create((i18n) => ({
           flag: "json",
           boolean: true,
           description: "Emit JSON-encoded Michelson"
+        }),
+        Option.create({
+          flag: "module",
+          shortFlag: "m",
+          type: "string",
+          description: "The LIGO module to be compiled"
         })
       ],
       handler: "proxy",
@@ -705,6 +778,7 @@ Plugin.create((i18n) => ({
       handler: createContract_default
     })
   ],
-  proxy: main_default
+  proxy: main_default,
+  postInstall: `node ${__dirname}/postinstall.js`
 }), process.argv);
 //# sourceMappingURL=index.mjs.map