@clarigen/cli 4.0.1 → 4.0.2-alpha.0

package/dist/run-cli.cjs

@@ -1,1512 +1,243 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+const require_esm = require('./esm-CRbGFHSR.cjs');
+let __clarigen_core = require("@clarigen/core");
+let fs_promises = require("fs/promises");
+let arktype = require("arktype");
+let clipanion = require("clipanion");
+let __stacks_clarinet_sdk = require("@stacks/clarinet-sdk");
+let chokidar = require("chokidar");
+chokidar = require_esm.__toESM(chokidar);
+let node_path = require("node:path");
+
+//#region src/commands/base-command.ts
+var BaseCommand = class extends clipanion.Command {
+	verbose = clipanion.Option.Boolean("-v,--verbose", false, { description: "Enable verbose logging" });
+	preexecute() {
+		if (this.verbose) require_esm.logger.level = "debug";
+	}
+	async catch(error) {
+		if (error instanceof arktype.type.errors) {
+			require_esm.logger.error("Your configuration file is invalid.", error.summary);
+			return;
+		}
+		require_esm.logger.error(error);
+		if (error instanceof Error) require_esm.logger.error(error.stack);
+		throw error;
+	}
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 
-// src/run-cli.ts
-var import_clipanion6 = require("clipanion");
-
-// src/commands/session-info.ts
-var import_clipanion2 = require("clipanion");
-
-// src/config.ts
-var import_arktype2 = require("arktype");
-
-// src/logger.ts
-var import_pino = require("pino");
-var import_pino_pretty = __toESM(require("pino-pretty"), 1);
-var colorizedClarigen = `\x1B[33m[Clarigen]\x1B[0m`;
-var logger = (0, import_pino.pino)(
-  (0, import_pino_pretty.default)({
-    colorize: true,
-    ignore: "pid,hostname,time",
-    messageFormat: `${colorizedClarigen} {msg}`,
-    minimumLevel: "debug"
-  })
-);
-logger.level = "info";
-var log = logger;
-
-// src/utils.ts
-var import_core = require("@clarigen/core");
-var import_promises = require("fs/promises");
-var import_path = require("path");
-function encodeVariableName(name) {
-  if (/^[A-Z\-_]*$/.test(name)) return name.replaceAll("-", "_");
-  return (0, import_core.toCamelCase)(name);
-}
-async function fileExists(filename) {
-  try {
-    await (0, import_promises.stat)(filename);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-async function writeFile(path, contents) {
-  const dir = (0, import_path.dirname)(path);
-  await (0, import_promises.mkdir)(dir, { recursive: true });
-  await (0, import_promises.writeFile)(path, contents, "utf-8");
-  return path;
-}
-function sortContracts(contracts) {
-  const nameSorted = [...contracts].sort((a, b) => {
-    if ((0, import_core.getContractName)(a.contract_id, false) < (0, import_core.getContractName)(b.contract_id, false)) {
-      return -1;
-    }
-    return 1;
-  });
-  return nameSorted;
-}
-
-// src/clarinet-config.ts
-var import_arktype = require("arktype");
-var import_promises2 = require("fs/promises");
-var import_toml = require("@iarna/toml");
-var ClarinetConfig = (0, import_arktype.type)({
-  project: (0, import_arktype.type)({
-    requirements: (0, import_arktype.type)({
-      contract_id: (0, import_arktype.type)("string").describe("Contract ID")
-    }).array().describe("Project requirements").optional(),
-    cache_location: (0, import_arktype.type)({
-      path: (0, import_arktype.type)("string").describe("Cache location path")
-    }).optional()
-  }),
-  contracts: (0, import_arktype.type)({
-    "[string]": (0, import_arktype.type)({
-      path: (0, import_arktype.type)("string").describe("Contract path")
-    })
-  }).optional()
-});
-async function getClarinetConfig(path) {
-  const file = await (0, import_promises2.readFile)(path, "utf-8");
-  const config = ClarinetConfig.assert((0, import_toml.parse)(file));
-  return config;
-}
-
-// src/config.ts
-var import_path2 = require("path");
-var import_toml2 = require("@iarna/toml");
-var import_promises3 = require("fs/promises");
-var CONFIG_FILE = "Clarigen.toml";
-var typesSchema = (0, import_arktype2.type)({
-  "output?": (0, import_arktype2.type)("string").describe("Path to the output file"),
-  "outputs?": (0, import_arktype2.type)("string[]").describe("Paths to the output files"),
-  "include_accounts?": (0, import_arktype2.type)("boolean").describe("Include accounts in the output"),
-  "after?": (0, import_arktype2.type)("string").describe("Script to run after the output is generated"),
-  "include_boot_contracts?": (0, import_arktype2.type)("boolean").describe("Include boot contracts in the output"),
-  "watch_folders?": (0, import_arktype2.type)("string[]").describe("Folders to watch for changes")
-}).optional();
-var ConfigFile = (0, import_arktype2.type)({
-  clarinet: (0, import_arktype2.type)("string").describe("Path to the Clarinet config file"),
-  ["types" /* ESM */]: typesSchema,
-  ["esm" /* ESM_OLD */]: typesSchema,
-  ["docs" /* Docs */]: (0, import_arktype2.type)({
-    "output?": (0, import_arktype2.type)("string").describe("Path to docs output folder. Defaults to ./docs"),
-    "outputs?": (0, import_arktype2.type)("string[]").describe("Paths to docs output folders"),
-    "exclude?": (0, import_arktype2.type)("string[]").describe("Contracts to exclude from docs generation"),
-    "after?": (0, import_arktype2.type)("string").describe("Script to run after docs are generated")
-  }).optional()
-});
-var defaultConfigFile = {
-  clarinet: "./Clarinet.toml"
-};
-var Config = class {
-  configFile;
-  clarinet;
-  cwd;
-  constructor(config, clarinet, cwd) {
-    this.configFile = config;
-    this.clarinet = clarinet;
-    this.cwd = cwd ?? process.cwd();
-  }
-  static async load(cwd) {
-    const config = await getConfig(cwd);
-    if (config["esm" /* ESM_OLD */]) {
-      config["types" /* ESM */] = config["esm" /* ESM_OLD */];
-      delete config["esm" /* ESM_OLD */];
-    }
-    const clarinet = await getClarinetConfig((0, import_path2.resolve)(cwd ?? "", config.clarinet));
-    return new this(config, clarinet, cwd);
-  }
-  getOutputs(type4) {
-    var _a, _b;
-    const singlePath = (_a = this.configFile[type4]) == null ? void 0 : _a.output;
-    const multiPath = ((_b = this.configFile[type4]) == null ? void 0 : _b.outputs) || [];
-    if (singlePath !== void 0) return [singlePath];
-    return multiPath;
-  }
-  outputResolve(type4, filePath) {
-    const outputs = this.getOutputs(type4);
-    if (!this.supports(type4)) return null;
-    return outputs.map((path) => {
-      return (0, import_path2.resolve)(this.cwd, path, filePath || "");
-    });
-  }
-  async writeOutput(type4, contents, filePath) {
-    const paths = this.outputResolve(type4, filePath);
-    if (paths === null) return null;
-    await Promise.all(
-      paths.map(async (path) => {
-        await writeFile(path, contents);
-        log.debug(`Generated ${type4} file at ${(0, import_path2.relative)(this.cwd, path)}`);
-      })
-    );
-    return paths;
-  }
-  supports(type4) {
-    return this.getOutputs(type4).length > 0;
-  }
-  type(type4) {
-    return this.configFile[type4];
-  }
-  get esm() {
-    return this.configFile["types" /* ESM */];
-  }
-  get docs() {
-    return this.configFile["docs" /* Docs */];
-  }
-  clarinetFile() {
-    return (0, import_path2.resolve)(this.cwd, this.configFile.clarinet);
-  }
-  joinFromClarinet(filePath) {
-    const baseDir = (0, import_path2.dirname)(this.clarinetFile());
-    return (0, import_path2.join)(baseDir, filePath);
-  }
-};
-function configFilePath(cwd) {
-  return (0, import_path2.resolve)(cwd ?? process.cwd(), CONFIG_FILE);
-}
-var sessionConfig;
-async function getConfig(cwd) {
-  if (typeof sessionConfig !== "undefined") return sessionConfig;
-  const path = configFilePath(cwd);
-  if (await fileExists(path)) {
-    const toml = await (0, import_promises3.readFile)(path, "utf-8");
-    const parsedToml = (0, import_toml2.parse)(toml);
-    const parsed = ConfigFile(parsedToml);
-    if (parsed instanceof import_arktype2.type.errors) {
-      logger.error(`Error parsing Clarigen config: ${parsed.summary}`);
-      throw new Error(`Error parsing Clarigen config: ${parsed.summary}`);
-    }
-    sessionConfig = parsed;
-  } else {
-    sessionConfig = defaultConfigFile;
-  }
-  return sessionConfig;
-}
-
-// src/commands/base-command.ts
-var import_clipanion = require("clipanion");
-var import_arktype3 = require("arktype");
-var BaseCommand = class extends import_clipanion.Command {
-  verbose = import_clipanion.Option.Boolean("-v,--verbose", false, {
-    description: "Enable verbose logging"
-  });
-  preexecute() {
-    if (this.verbose) {
-      logger.level = "debug";
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async catch(error) {
-    if (error instanceof import_arktype3.type.errors) {
-      logger.error("Your configuration file is invalid.", error.summary);
-      return;
-    }
-    logger.error(error);
-    if (error instanceof Error) {
-      logger.error(error.stack);
-    }
-    throw error;
-  }
-};
-
-// src/commands/session-info.ts
+//#endregion
+//#region src/commands/session-info.ts
 var SessionInfoCommand = class extends BaseCommand {
-  static paths = [["session-info"]];
-  static usage = import_clipanion2.Command.Usage({
-    description: "Log info about this project's Clarinet session"
-  });
-  cwd = import_clipanion2.Option.String({ required: false });
-  async execute() {
-    this.preexecute();
-    const config = await Config.load(this.cwd);
-    logger.info(config);
-  }
-};
-
-// src/commands/default-command.ts
-var import_clipanion3 = require("clipanion");
-
-// src/clarinet-sdk.ts
-var import_clarinet_sdk = require("@stacks/clarinet-sdk");
-var import_core7 = require("@clarigen/core");
-var import_promises4 = require("fs/promises");
-
-// src/files/variables.ts
-var import_core6 = require("@clarigen/core");
-
-// src/declaration.ts
-var import_core2 = require("@clarigen/core");
-var import_core3 = require("@clarigen/core");
-var jsTypeFromAbiType = (val, isArgument = false) => {
-  if ((0, import_core2.isClarityAbiPrimitive)(val)) {
-    if (val === "uint128") {
-      if (isArgument) return "number | bigint";
-      return "bigint";
-    } else if (val === "int128") {
-      if (isArgument) return "number | bigint";
-      return "bigint";
-    } else if (val === "bool") {
-      return "boolean";
-    } else if (val === "principal") {
-      return "string";
-    } else if (val === "none") {
-      return "null";
-    } else if (val === "trait_reference") {
-      return "string";
-    } else {
-      throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
-    }
-  } else if ((0, import_core2.isClarityAbiBuffer)(val)) {
-    return "Uint8Array";
-  } else if ((0, import_core2.isClarityAbiResponse)(val)) {
-    const ok = jsTypeFromAbiType(val.response.ok, isArgument);
-    const err = jsTypeFromAbiType(val.response.error, isArgument);
-    return `Response<${ok}, ${err}>`;
-  } else if ((0, import_core2.isClarityAbiOptional)(val)) {
-    const innerType = jsTypeFromAbiType(val.optional, isArgument);
-    return `${innerType} | null`;
-  } else if ((0, import_core2.isClarityAbiTuple)(val)) {
-    const tupleDefs = [];
-    val.tuple.forEach(({ name, type: type4 }) => {
-      const camelName = (0, import_core3.toCamelCase)(name);
-      const innerType = jsTypeFromAbiType(type4, isArgument);
-      tupleDefs.push(`"${camelName}": ${innerType};`);
-    });
-    return `{
-  ${tupleDefs.join("\n  ")}
-}`;
-  } else if ((0, import_core2.isClarityAbiList)(val)) {
-    const innerType = jsTypeFromAbiType(val.list.type, isArgument);
-    return `${innerType}[]`;
-  } else if ((0, import_core2.isClarityAbiStringAscii)(val)) {
-    return "string";
-  } else if ((0, import_core2.isClarityAbiStringUtf8)(val)) {
-    return "string";
-  } else if ((0, import_core2.isClarityAbiTraitReference)(val)) {
-    return "string";
-  } else {
-    throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
-  }
-};
-function abiArgType(arg) {
-  const nativeType = jsTypeFromAbiType(arg.type, true);
-  const argName = getArgName(arg.name);
-  return `${argName}: TypedAbiArg<${nativeType}, "${argName}">`;
-}
-function abiFunctionType(abiFunction) {
-  const args2 = abiFunction.args.map(abiArgType);
-  const retType = jsTypeFromAbiType(abiFunction.outputs.type);
-  const argsTuple = `[${args2.join(", ")}]`;
-  return `TypedAbiFunction<${argsTuple}, ${retType}>`;
-}
-function getArgName(name) {
-  const camel = (0, import_core3.toCamelCase)(name);
-  const prefix = RESERVED[camel] ? "_" : "";
-  return `${prefix}${camel}`;
-}
-function _hash(...words) {
-  const h = {};
-  for (const word of words) {
-    h[word] = true;
-  }
-  return h;
-}
-var RESERVED = _hash(
-  // Keywords, ES6 11.6.2.1, http://www.ecma-international.org/ecma-262/6.0/index.html#sec-keywords
-  "break",
-  "do",
-  "in",
-  "typeof",
-  "case",
-  "else",
-  "instanceof",
-  "var",
-  "catch",
-  "export",
-  "new",
-  "void",
-  "class",
-  "extends",
-  "return",
-  "while",
-  "const",
-  "finally",
-  "super",
-  "with",
-  "continue",
-  "for",
-  "switch",
-  "yield",
-  "debugger",
-  "function",
-  "this",
-  "default",
-  "if",
-  "throw",
-  "delete",
-  "import",
-  "try",
-  // Future Reserved Words, ES6 11.6.2.2
-  // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-future-reserved-words
-  "enum",
-  "await",
-  // NullLiteral & BooleanLiteral
-  "null",
-  "true",
-  "false"
-);
-
-// src/files/base.ts
-var import_core5 = require("@clarigen/core");
-
-// src/files/accounts.ts
-function generateAccountsCode(accounts) {
-  const sortedAccounts = sortAccounts(accounts);
-  const namedAccounts = Object.fromEntries(
-    sortedAccounts.map((a) => {
-      const { name, ...rest } = a;
-      return [name, rest];
-    })
-  );
-  return JSON.stringify(namedAccounts);
-}
-function sortAccounts(accounts) {
-  const nameSorted = [...accounts].sort((a, b) => {
-    if (a.name < b.name) {
-      return -1;
-    }
-    return 1;
-  });
-  return nameSorted;
-}
-
-// src/files/identifiers.ts
-var import_core4 = require("@clarigen/core");
-function generateIdentifiers(session) {
-  const identifiers = Object.fromEntries(
-    sortContracts(session.contracts).map((c) => {
-      const contractName = (0, import_core4.getContractName)(c.contract_id);
-      return [contractName, c.contract_id];
-    })
-  );
-  return identifiers;
-}
-function generateIdentifiersCode(session) {
-  const identifiers = generateIdentifiers(session);
-  return `export const identifiers = ${JSON.stringify(identifiers)} as const`;
-}
-
-// src/files/base.ts
-var import_util = require("util");
-function generateContractMeta(contract, constants) {
-  const abi = contract.contract_interface;
-  const functionLines = [];
-  const { functions, maps, variables, non_fungible_tokens, ...rest } = abi;
-  functions.forEach((func) => {
-    let functionLine = `${(0, import_core5.toCamelCase)(func.name)}: `;
-    const funcDef = JSON.stringify(func);
-    functionLine += funcDef;
-    const functionType = abiFunctionType(func);
-    functionLine += ` as ${functionType}`;
-    functionLines.push(functionLine);
-  });
-  const mapLines = maps.map((map) => {
-    let mapLine = `${(0, import_core5.toCamelCase)(map.name)}: `;
-    const keyType = jsTypeFromAbiType(map.key, true);
-    const valType = jsTypeFromAbiType(map.value);
-    mapLine += JSON.stringify(map);
-    mapLine += ` as TypedAbiMap<${keyType}, ${valType}>`;
-    return mapLine;
-  });
-  const otherAbi = JSON.stringify(rest);
-  const contractName = contract.contract_id.split(".")[1];
-  const variableLines = encodeVariables(variables);
-  const nftLines = non_fungible_tokens.map((nft) => {
-    return JSON.stringify(nft);
-  });
-  return `{
-  ${serializeLines("functions", functionLines)}
-  ${serializeLines("maps", mapLines)}
-  ${serializeLines("variables", variableLines)}
-  constants: ${constants},
-  ${serializeArray("non_fungible_tokens", nftLines)}
-  ${otherAbi.slice(1, -1)},
-  contractName: '${contractName}',
-  }`;
-}
-var TYPE_IMPORTS = `import type { TypedAbiArg, TypedAbiFunction, TypedAbiMap, TypedAbiVariable, Response } from '@clarigen/core';`;
-function generateBaseFile(session) {
-  const combined = session.contracts.map((c, i) => ({
-    ...c,
-    constants: session.variables[i]
-  }));
-  const contractDefs = sortContracts(combined).map((contract) => {
-    const meta = generateContractMeta(contract, contract.constants);
-    const id = contract.contract_id.split(".")[1];
-    const keyName = (0, import_core5.toCamelCase)(id);
-    return `${keyName}: ${meta}`;
-  });
-  const file = `
-${TYPE_IMPORTS}
-
-export const contracts = {
-  ${contractDefs.join(",\n")}
-} as const;
-
-export const accounts = ${generateAccountsCode(session.accounts)} as const;
-
-${generateIdentifiersCode(session)}
-
-export const simnet = {
-  accounts,
-  contracts,
-  identifiers,
-} as const;
-
-`;
-  return file;
-}
-function encodeVariables(variables) {
-  return variables.map((v) => {
-    let varLine = `${encodeVariableName(v.name)}: `;
-    const type4 = jsTypeFromAbiType(v.type);
-    const varJSON = serialize(v);
-    varLine += `${varJSON} as TypedAbiVariable<${type4}>`;
-    return varLine;
-  });
-}
-Uint8Array.prototype[import_util.inspect.custom] = function(depth, options) {
-  return `Uint8Array.from([${this.join(",")}])`;
+	static paths = [["session-info"]];
+	static usage = clipanion.Command.Usage({ description: "Log info about this project's Clarinet session" });
+	cwd = clipanion.Option.String({ required: false });
+	async execute() {
+		this.preexecute();
+		const config = await require_esm.Config.load(this.cwd);
+		require_esm.logger.info(config);
+	}
 };
-function serialize(obj) {
-  return (0, import_util.inspect)(obj, {
-    // showHidden: false,
-    // depth: 100,
-    // colors: false,
-    showHidden: false,
-    // iterableLimit: 100000,
-    compact: false,
-    // trailingComma: true,
-    depth: 100,
-    colors: false,
-    maxArrayLength: Infinity,
-    maxStringLength: Infinity,
-    breakLength: Infinity,
-    numericSeparator: true
-    // strAbbreviateSize: 100000,
-  });
-}
-function serializeLines(key, lines) {
-  return `"${key}": {
-    ${lines.join(",\n    ")}
-  },`;
-}
-function serializeArray(key, lines) {
-  return `"${key}": [
-    ${lines.join(",\n    ")}
-  ],`;
-}
-
-// src/files/variables.ts
-function clarityVersionForContract(contract) {
-  switch (contract.contract_interface.clarity_version) {
-    case "Clarity1":
-      return 1;
-    case "Clarity2":
-      return 2;
-    case "Clarity3":
-      return 3;
-    case "Clarity4":
-      return 4;
-    default:
-      return 3;
-  }
-}
-function getVariablesV2(contract, simnet, verbose) {
-  const [deployer] = contract.contract_id.split(".");
-  const fakeId = `${(0, import_core6.getContractName)(contract.contract_id)}-vars`;
-  logger.debug(`Deploying ${contract.contract_id} for variables.`);
-  if (!contract.source) {
-    logger.debug(
-      `Contract ${(0, import_core6.getContractName)(contract.contract_id)} has no source. Skipping variables.`
-    );
-    return {};
-  }
-  if (contract.contract_interface.variables.length === 0) {
-    logger.info(`Contract ${(0, import_core6.getContractName)(contract.contract_id, false)} has no variables`);
-    return {};
-  }
-  let varFn = `{
-`;
-  const varLines = contract.contract_interface.variables.map((variable) => {
-    let varLine = `${variable.name}: `;
-    if (variable.access === "constant") {
-      varLine += `${variable.name}`;
-    } else {
-      varLine += `(var-get ${variable.name})`;
-    }
-    return varLine;
-  });
-  varFn += varLines.map((l) => ` ${l},`).join("\n");
-  varFn += "\n}";
-  const fullSrc = contract.source + `
-
-${varFn}`;
-  try {
-    const receipt = simnet.deployContract(
-      fakeId,
-      fullSrc,
-      {
-        clarityVersion: clarityVersionForContract(contract)
-      },
-      deployer
-    );
-    const result = receipt.result;
-    const varsAbi = {
-      tuple: []
-    };
-    contract.contract_interface.variables.forEach((v) => {
-      const _v = v;
-      varsAbi.tuple.push({
-        type: _v.type,
-        name: _v.name
-      });
-    });
-    if (verbose) {
-      logger.info((0, import_core6.cvToValue)(result, true));
-    }
-    return (0, import_core6.cvToValue)(result, true);
-  } catch (error) {
-    logger.warn(
-      { err: error },
-      `Error getting variables for ${(0, import_core6.getContractName)(contract.contract_id, false)}`
-    );
-    return {};
-  }
-}
-function mapVariables(session, simnet) {
-  return session.contracts.map((contract) => {
-    const vars = getVariablesV2(contract, simnet);
-    return serialize(vars);
-  });
-}
 
-// src/clarinet-sdk.ts
+//#endregion
+//#region src/clarinet-sdk.ts
 async function getSession(config) {
-  const simnet = await (0, import_clarinet_sdk.initSimnet)(config.clarinetFile(), true);
-  const interfaces = simnet.getContractsInterfaces();
-  const accounts = simnet.getAccounts();
-  const allAccounts = [...accounts.entries()].map(([name, address]) => {
-    const result = simnet.runSnippet(`(stx-get-balance '${address})`);
-    const resultCV = (0, import_core7.hexToCvValue)(result);
-    if (typeof resultCV !== "bigint") {
-      throw new Error(`Unexpected result type for \`(stx-get-balance \`, got ${resultCV}`);
-    }
-    return {
-      name,
-      address,
-      balance: resultCV.toString()
-    };
-  });
-  const contracts = (await Promise.all(
-    [...interfaces.entries()].map(async ([contract_id, contract_interface]) => {
-      var _a, _b, _c;
-      if (contract_id.startsWith(import_core7.MAINNET_BURN_ADDRESS) && ((_a = config.esm) == null ? void 0 : _a.include_boot_contracts) !== true || contract_id.startsWith(import_core7.TESTNET_BURN_ADDRESS)) {
-        return void 0;
-      }
-      const name = (0, import_core7.getContractName)(contract_id, false);
-      const contractPathDef = (_c = (_b = config.clarinet.contracts) == null ? void 0 : _b[name]) == null ? void 0 : _c.path;
-      let source;
-      if (contractPathDef) {
-        const contractPathFull = config.joinFromClarinet(contractPathDef);
-        source = await (0, import_promises4.readFile)(contractPathFull, "utf-8");
-      }
-      return {
-        contract_id,
-        contract_interface: {
-          ...contract_interface,
-          epoch: contract_interface.epoch,
-          clarity_version: contract_interface.clarity_version
-        },
-        source: source ?? ""
-      };
-    })
-  )).filter((x) => x !== void 0);
-  const session = {
-    session_id: 0,
-    accounts: allAccounts,
-    contracts
-  };
-  const variables = mapVariables(session, simnet);
-  return {
-    session_id: 0,
-    accounts: allAccounts,
-    contracts,
-    variables
-    // variables: [],
-  };
-}
-
-// src/files/esm.ts
-var import_promises5 = require("fs/promises");
-var import_path3 = require("path");
-var import_yaml = require("yaml");
-
-// src/deployments.ts
-function flatBatch(batches) {
-  const txs = [];
-  batches.forEach((batch) => txs.push(...batch.transactions));
-  return txs;
-}
-function getContractTxs(batches) {
-  const txs = flatBatch(batches);
-  return txs.filter(isContractTx);
-}
-function getDeploymentContract(contractName, deployment) {
-  const txs = flatBatch(deployment.plan.batches);
-  for (const tx of txs) {
-    if (!isContractTx(tx)) continue;
-    if ("requirement-publish" in tx) {
-      const [_, name] = tx["requirement-publish"]["contract-id"].split(".");
-      if (name === contractName) {
-        return tx;
-      }
-    } else if ("emulated-contract-publish" in tx) {
-      if (tx["emulated-contract-publish"]["contract-name"] === contractName) {
-        return tx;
-      }
-    } else if ("contract-publish" in tx) {
-      const contract = tx["contract-publish"];
-      if (contract["contract-name"] === contractName) {
-        return tx;
-      }
-    }
-  }
-  throw new Error(`Unable to find deployment tx for contract '${contractName}'`);
-}
-function getDeploymentTxPath(tx) {
-  if (!isContractTx(tx)) {
-    throw new Error("Unable to get path for tx type.");
-  }
-  if ("requirement-publish" in tx) {
-    return tx["requirement-publish"].path;
-  } else if ("emulated-contract-publish" in tx) {
-    const contract = tx["emulated-contract-publish"];
-    return contract.path;
-  } else if ("contract-publish" in tx) {
-    const contract = tx["contract-publish"];
-    return contract.path;
-  }
-  throw new Error("Couldnt get path for deployment tx.");
-}
-function getIdentifier(tx) {
-  if (!isContractTx(tx)) {
-    throw new Error("Unable to get ID for tx type.");
-  }
-  if ("requirement-publish" in tx) {
-    const spec = tx["requirement-publish"];
-    const [_, name] = spec["contract-id"].split(".");
-    return `${spec["remap-sender"]}.${name}`;
-  } else if ("emulated-contract-publish" in tx) {
-    const contract = tx["emulated-contract-publish"];
-    return `${contract["emulated-sender"]}.${contract["contract-name"]}`;
-  } else if ("contract-publish" in tx) {
-    const contract = tx["contract-publish"];
-    return `${contract["expected-sender"]}.${contract["contract-name"]}`;
-  }
-  throw new Error(`Unable to find ID for contract.`);
-}
-function isContractTx(tx) {
-  if ("contract-call" in tx) return false;
-  if ("btc-transfer" in tx) return false;
-  if ("emulated-contract-call" in tx) return false;
-  return true;
-}
-
-// src/files/esm.ts
-var import_core8 = require("@clarigen/core");
-var import_child_process = require("child_process");
-async function parseDeployment(path) {
-  const contents = await (0, import_promises5.readFile)(path, "utf-8");
-  const parsed = (0, import_yaml.parse)(contents);
-  return parsed;
-}
-var DEPLOYMENT_NETWORKS = ["devnet", "simnet", "testnet", "mainnet"];
-async function getDeployments(config) {
-  const entries = await Promise.all(
-    DEPLOYMENT_NETWORKS.map(async (network) => {
-      const file = `default.${network}-plan.yaml`;
-      const path = (0, import_path3.join)((0, import_path3.dirname)(config.clarinetFile()), "deployments", file);
-      let plan;
-      try {
-        plan = await parseDeployment(path);
-      } catch (_) {
-      }
-      return [network, plan];
-    })
-  );
-  return Object.fromEntries(entries);
-}
-async function generateESMFile({
-  baseFile,
-  session,
-  config
-}) {
-  const deployments = await getDeployments(config);
-  const contractDeployments = collectContractDeployments(session, deployments, config);
-  const simnet = generateSimnetCode(config, deployments, session);
-  return `${baseFile}
-export const deployments = ${JSON.stringify(contractDeployments)} as const;
-${simnet}
-export const project = {
-  contracts,
-  deployments,
-} as const;
-  `;
-}
-function insertNetworkId(deployments, identifier, network) {
-  const name = (0, import_core8.getContractName)(identifier);
-  if (!deployments[name]) {
-    return;
-  }
-  if (deployments[name][network] === null) {
-    deployments[name][network] = identifier;
-  }
-}
-function collectContractDeployments(session, deployments, config) {
-  var _a;
-  const full = Object.fromEntries(
-    sortContracts(session.contracts).map((contract) => {
-      const contractName = (0, import_core8.getContractName)(contract.contract_id);
-      const contractDeployments = Object.fromEntries(
-        DEPLOYMENT_NETWORKS.map((network) => {
-          const deployment = deployments[network];
-          if (typeof deployment === "undefined") {
-            return [network, null];
-          }
-          try {
-            const contractName2 = contract.contract_id.split(".")[1];
-            const tx = getDeploymentContract(contractName2, deployment);
-            const id = getIdentifier(tx);
-            return [network, id];
-          } catch (_) {
-            return [network, null];
-          }
-        })
-      );
-      return [contractName, contractDeployments];
-    })
-  );
-  const deployer = session.accounts.find((a) => a.name === "deployer");
-  (_a = config.clarinet.project.requirements) == null ? void 0 : _a.forEach(({ contract_id }) => {
-    insertNetworkId(full, contract_id, "mainnet");
-    const contractName = contract_id.split(".")[1];
-    if (deployer) {
-      const devnetId = `${deployer.address}.${contractName}`;
-      insertNetworkId(full, devnetId, "devnet");
-    }
-  });
-  session.contracts.forEach((contract) => {
-    insertNetworkId(full, contract.contract_id, "devnet");
-    insertNetworkId(full, contract.contract_id, "simnet");
-  });
-  return full;
-}
-function collectDeploymentFiles(deployments, clarinetFolder, cwd) {
-  if (!deployments.simnet) return [];
-  const simnet = deployments.simnet;
-  const txs = getContractTxs(simnet.plan.batches);
-  const entries = txs.map((tx) => {
-    const id = getIdentifier(tx);
-    const contractFile = getDeploymentTxPath(tx);
-    return {
-      identifier: id,
-      file: (0, import_path3.relative)(cwd, (0, import_path3.join)(clarinetFolder, contractFile))
-    };
-  });
-  return entries;
-}
-function generateSimnetCode(config, deployments, _session) {
-  var _a;
-  if (!((_a = config.esm) == null ? void 0 : _a.include_accounts)) return "";
-  const clarinetFolder = (0, import_path3.dirname)(config.clarinetFile());
-  const files = collectDeploymentFiles(deployments, clarinetFolder, config.cwd);
-  return `
-export const simnetDeployment = ${JSON.stringify(files)};
-`;
-}
-async function afterESM(config) {
-  var _a;
-  const command = (_a = config.esm) == null ? void 0 : _a.after;
-  if (!command) return;
-  logger.debug(`Running after ESM command: ${command}`);
-  const parts = command.split(" ");
-  const [cmd, ...args2] = parts;
-  return new Promise((resolve3, reject) => {
-    const child = (0, import_child_process.spawn)(cmd, args2, {
-      cwd: config.cwd,
-      stdio: "inherit"
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve3();
-      } else {
-        reject(new Error(`Command failed with code ${code ?? "unknown"}`));
-      }
-    });
-  });
-}
-
-// src/commands/default-command.ts
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_node_path = require("path");
+	const simnet = await (0, __stacks_clarinet_sdk.initSimnet)(config.clarinetFile(), true);
+	const interfaces = simnet.getContractsInterfaces();
+	const allAccounts = [...simnet.getAccounts().entries()].map(([name, address]) => {
+		const resultCV = (0, __clarigen_core.hexToCvValue)(simnet.runSnippet(`(stx-get-balance '${address})`));
+		if (typeof resultCV !== "bigint") throw new Error(`Unexpected result type for \`(stx-get-balance \`, got ${resultCV}`);
+		return {
+			name,
+			address,
+			balance: resultCV.toString()
+		};
+	});
+	const contracts = (await Promise.all([...interfaces.entries()].map(async ([contract_id, contract_interface]) => {
+		var _config$esm, _config$clarinet$cont;
+		if (contract_id.startsWith(__clarigen_core.MAINNET_BURN_ADDRESS) && ((_config$esm = config.esm) === null || _config$esm === void 0 ? void 0 : _config$esm.include_boot_contracts) !== true || contract_id.startsWith(__clarigen_core.TESTNET_BURN_ADDRESS)) return;
+		const name = (0, __clarigen_core.getContractName)(contract_id, false);
+		const contractPathDef = (_config$clarinet$cont = config.clarinet.contracts) === null || _config$clarinet$cont === void 0 || (_config$clarinet$cont = _config$clarinet$cont[name]) === null || _config$clarinet$cont === void 0 ? void 0 : _config$clarinet$cont.path;
+		let source;
+		if (contractPathDef) source = await (0, fs_promises.readFile)(config.joinFromClarinet(contractPathDef), "utf-8");
+		return {
+			contract_id,
+			contract_interface: {
+				...contract_interface,
+				epoch: contract_interface.epoch,
+				clarity_version: contract_interface.clarity_version
+			},
+			source: source ?? ""
+		};
+	}))).filter((x) => x !== void 0);
+	return {
+		session_id: 0,
+		accounts: allAccounts,
+		contracts,
+		variables: require_esm.mapVariables({
+			session_id: 0,
+			accounts: allAccounts,
+			contracts
+		}, simnet)
+	};
+}
+
+//#endregion
+//#region src/commands/default-command.ts
 async function generate(config) {
-  const session = await getSession(config);
-  const baseFile = generateBaseFile(session);
-  if (config.supports("types" /* ESM */)) {
-    const esmFile = await generateESMFile({
-      baseFile,
-      session,
-      config
-    });
-    await config.writeOutput("types" /* ESM */, esmFile);
-    await afterESM(config);
-  }
-  if (!config.supports("types" /* ESM */)) {
-    logger.warn("no config for ESM outputs. Not outputting any generated types.");
-  }
-  logger.info("Types generated!");
-}
-async function watch(config, cwd) {
-  return new Promise(async (resolve3, reject) => {
-    var _a;
-    try {
-      await generate(config);
-    } catch (error) {
-      logger.error({ error }, "Error generating types");
-    }
-    const clarinetFolder = (0, import_node_path.dirname)(config.clarinetFile());
-    const contractsFolder = (0, import_node_path.join)(clarinetFolder, "/contracts/**/*.clar");
-    const relativeFolder = (0, import_node_path.relative)(cwd || process.cwd(), contractsFolder);
-    const watchFolders = ((_a = config.esm) == null ? void 0 : _a.watch_folders) ?? [];
-    watchFolders.push(relativeFolder);
-    logger.info(`Watching for changes in ${watchFolders}`);
-    const watcher = import_chokidar.default.watch(watchFolders, { persistent: true, cwd: clarinetFolder });
-    let running = false;
-    let start = 0;
-    const isVerbose = logger.level !== "info";
-    watcher.on("change", (path) => {
-      if (!running) {
-        start = Date.now();
-        logger.info(`File ${path} has been changed. Generating types.`);
-        running = true;
-        void generate(config).catch((e) => {
-          logger.error({ error: e }, "Error generating types");
-        }).then(() => {
-          setTimeout(() => {
-            process.stdout.moveCursor(0, -1);
-            process.stdout.clearLine(1);
-            const elapsed = Date.now() - start;
-            logger.info(
-              `Types generated (${(elapsed / 1e3).toFixed(2)}s). Watching for changes...`
-            );
-            running = false;
-          });
-        });
-      }
-    });
-  });
+	const session = await getSession(config);
+	const baseFile = require_esm.generateBaseFile(session);
+	if (config.supports(require_esm.OutputType.ESM)) {
+		const esmFile = await require_esm.generateESMFile({
+			baseFile,
+			session,
+			config
+		});
+		await config.writeOutput(require_esm.OutputType.ESM, esmFile);
+		await require_esm.afterESM(config);
+	}
+	if (!config.supports(require_esm.OutputType.ESM)) require_esm.logger.warn("no config for ESM outputs. Not outputting any generated types.");
+	require_esm.logger.info("Types generated!");
+}
+async function watch$1(config, cwd) {
+	return new Promise(async (resolve, reject) => {
+		var _config$esm;
+		try {
+			await generate(config);
+		} catch (error) {
+			require_esm.logger.error({ error }, "Error generating types");
+		}
+		const clarinetFolder = (0, node_path.dirname)(config.clarinetFile());
+		const contractsFolder = (0, node_path.join)(clarinetFolder, "/contracts/**/*.clar");
+		const relativeFolder = (0, node_path.relative)(cwd || process.cwd(), contractsFolder);
+		const watchFolders = ((_config$esm = config.esm) === null || _config$esm === void 0 ? void 0 : _config$esm.watch_folders) ?? [];
+		watchFolders.push(relativeFolder);
+		require_esm.logger.info(`Watching for changes in ${watchFolders}`);
+		const watcher = chokidar.default.watch(watchFolders, {
+			persistent: true,
+			cwd: clarinetFolder
+		});
+		let running = false;
+		let start = 0;
+		require_esm.logger.level;
+		watcher.on("change", (path) => {
+			if (!running) {
+				start = Date.now();
+				require_esm.logger.info(`File ${path} has been changed. Generating types.`);
+				running = true;
+				generate(config).catch((e) => {
+					require_esm.logger.error({ error: e }, "Error generating types");
+				}).then(() => {
+					setTimeout(() => {
+						process.stdout.moveCursor(0, -1);
+						process.stdout.clearLine(1);
+						const elapsed = Date.now() - start;
+						require_esm.logger.info(`Types generated (${(elapsed / 1e3).toFixed(2)}s). Watching for changes...`);
+						running = false;
+					});
+				});
+			}
+		});
+	});
 }
 var DefaultCommand = class extends BaseCommand {
-  static paths = [import_clipanion3.Command.Default, ["generate"]];
-  // static description = 'Generate types for your Clarity contracts';
-  static usage = import_clipanion3.Command.Usage({
-    description: "Generate types for your Clarity contracts",
-    examples: [
-      ["Basic usage:", "clarigen"],
-      ["When your `Clarigen.toml` is in a different directory:", "clarigen /path/to/your/project"],
-      ["Watch for changes and regenerate types:", "clarigen --watch"]
-    ]
-  });
-  cwd = import_clipanion3.Option.String({
-    required: false
-  });
-  watch = import_clipanion3.Option.Boolean("-w,--watch", {
-    description: "Watch for changes and regenerate types",
-    required: false
-  });
-  async execute() {
-    this.preexecute();
-    const config = await Config.load(this.cwd);
-    if (this.watch) {
-      await watch(config, this.cwd);
-    } else {
-      await generate(config);
-    }
-  }
+	static paths = [clipanion.Command.Default, ["generate"]];
+	static usage = clipanion.Command.Usage({
+		description: "Generate types for your Clarity contracts",
+		examples: [
+			["Basic usage:", "clarigen"],
+			["When your `Clarigen.toml` is in a different directory:", "clarigen /path/to/your/project"],
+			["Watch for changes and regenerate types:", "clarigen --watch"]
+		]
+	});
+	cwd = clipanion.Option.String({ required: false });
+	watch = clipanion.Option.Boolean("-w,--watch", {
+		description: "Watch for changes and regenerate types",
+		required: false
+	});
+	async execute() {
+		this.preexecute();
+		const config = await require_esm.Config.load(this.cwd);
+		if (this.watch) await watch$1(config, this.cwd);
+		else await generate(config);
+	}
 };
 
-// src/commands/docs-command.ts
-var import_clipanion4 = require("clipanion");
-
-// src/files/docs.ts
-var import_core10 = require("@clarigen/core");
-var import_path5 = require("path");
-
-// src/docs/markdown.ts
-var import_core9 = require("@clarigen/core");
-
-// src/docs/index.ts
-var import_child_process2 = require("child_process");
-var FN_TYPES = ["read-only", "public", "private"];
-var VAR_TYPES = ["map", "data-var", "constant"];
-function createContractDocInfo({
-  contractSrc,
-  abi
-}) {
-  const lines = contractSrc.split("\n");
-  let comments = [];
-  let parensCount = 0;
-  let currentFn;
-  const contract = {
-    comments: [],
-    functions: [],
-    variables: [],
-    maps: []
-  };
-  lines.forEach((line, lineNumber) => {
-    if (currentFn) {
-      currentFn.source.push(line);
-      parensCount = traceParens(line, parensCount);
-      if (parensCount === 0) {
-        pushItem(contract, currentFn);
-        currentFn = void 0;
-      }
-      return;
-    }
-    if (isComment(line)) {
-      const comment = line.replace(/^\s*;;\s*/g, "");
-      if (contract.comments.length === lineNumber) {
-        contract.comments.push(comment);
-      } else {
-        comments.push(comment);
-      }
-      return;
-    }
-    const name = findItemNameFromLine(line);
-    if (typeof name === "undefined") {
-      comments = [];
-    } else {
-      const abiFn = findAbiItemByName(abi, name);
-      if (!abiFn) {
-        console.debug(`[claridoc]: Unable to find ABI for function \`${name}\`. Probably a bug.`);
-        return;
-      }
-      parensCount = traceParens(line, 0);
-      const metaComments = parseComments(comments, abiFn);
-      currentFn = {
-        abi: abiFn,
-        comments: metaComments,
-        startLine: lineNumber,
-        source: [line]
-      };
-      if (parensCount === 0) {
-        pushItem(contract, currentFn);
-        currentFn = void 0;
-      }
-      comments = [];
-    }
-  });
-  return contract;
-}
-function pushItem(contract, item) {
-  if ("args" in item.abi) {
-    contract.functions.push(item);
-  } else if ("key" in item.abi) {
-    contract.maps.push(item);
-  } else if ("access" in item.abi) {
-    contract.variables.push(item);
-  }
-}
-function clarityNameMatcher(line) {
-  return /[\w|\-|\?|\!]+/.exec(line);
-}
-function findItemNameFromLine(line) {
-  const fnType = FN_TYPES.find((type4) => {
-    return line.startsWith(`(define-${type4}`);
-  });
-  if (fnType) {
-    const prefix = `(define-${fnType} (`;
-    const startString = line.slice(prefix.length);
-    const match = clarityNameMatcher(startString);
-    if (!match) {
-      console.debug(`[claridocs]: Unable to determine function name from line:
-  \`${line}\``);
-      return;
-    }
-    return match[0];
-  }
-  for (const type4 of VAR_TYPES) {
-    const prefix = `(define-${type4} `;
-    if (!line.startsWith(prefix)) continue;
-    const startString = line.slice(prefix.length);
-    const match = clarityNameMatcher(startString);
-    if (!match) {
-      console.debug(`[claridocs]: Unable to determine ${type4} name from line:
-  \`${line}\``);
-      return;
-    }
-    return match[0];
-  }
-  return void 0;
-}
-function findAbiItemByName(abi, name) {
-  const fn = abi.functions.find((fn2) => {
-    return fn2.name === name;
-  });
-  if (fn) return fn;
-  const map = abi.maps.find((m) => m.name === name);
-  if (map) return map;
-  const v = abi.variables.find((v2) => v2.name === name);
-  return v;
-}
-function isComment(line) {
-  return line.startsWith(";;");
-}
-function traceParens(line, count) {
-  let newCount = count;
-  line.split("").forEach((char) => {
-    if (char === "(") newCount++;
-    if (char === ")") newCount--;
-  });
-  return newCount;
-}
-function parseComments(comments, abi) {
-  let curParam;
-  const parsed = {
-    text: [],
-    params: {}
-  };
-  comments.forEach((line) => {
-    const paramMatches = /\s*@param\s([\w|\-]+)([;|-|\s]*)(.*)/.exec(line);
-    if (paramMatches === null) {
-      if (!curParam || line.trim() === "") {
-        curParam = void 0;
-        parsed.text.push(line);
-      } else {
-        parsed.params[curParam].comments.push(line);
-      }
-      return;
-    }
-    if (!("args" in abi)) return;
-    const [_full, name, _separator, rest] = paramMatches;
-    const arg = abi.args.find((arg2) => arg2.name === name);
-    if (!arg) {
-      console.debug(`[claridocs]: Unable to find ABI for @param ${name}`);
-      return;
-    }
-    curParam = name;
-    parsed.params[curParam] = {
-      abi: arg,
-      comments: [rest]
-    };
-  });
-  if ("args" in abi) {
-    abi.args.forEach((arg) => {
-      if (!parsed.params[arg.name]) {
-        parsed.params[arg.name] = {
-          abi: arg,
-          comments: []
-        };
-      }
-    });
-  }
-  return parsed;
-}
-async function afterDocs(config) {
-  var _a;
-  const command = (_a = config.docs) == null ? void 0 : _a.after;
-  if (!command) return;
-  logger.debug(`Running after docs command: ${command}`);
-  const parts = command.split(" ");
-  const [cmd, ...args2] = parts;
-  return new Promise((resolve3, reject) => {
-    const child = (0, import_child_process2.spawn)(cmd, args2, {
-      cwd: config.cwd,
-      stdio: "inherit"
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve3();
-      } else {
-        reject(new Error(`Command failed with code ${code ?? "unknown"}`));
-      }
-    });
-  });
-}
-
-// src/docs/markdown.ts
-var import_path4 = require("path");
-function generateMarkdown({
-  contract,
-  contractFile,
-  withToc = true
-}) {
-  const contractName = (0, import_core9.getContractName)(contract.contract_id, false);
-  const doc = createContractDocInfo({
-    contractSrc: contract.source,
-    abi: contract.contract_interface
-  });
-  const functions = doc.functions.map((fn) => markdownFunction(fn, contractFile));
-  const maps = doc.maps.map((map) => markdownMap(map, contractFile));
-  const vars = doc.variables.filter((v) => v.abi.access === "variable").map((v) => markdownVar(v, contractFile));
-  const constants = doc.variables.filter((v) => v.abi.access === "constant").map((v) => markdownVar(v, contractFile));
-  let fileLine = "";
-  if (contractFile) {
-    const fileName = (0, import_path4.basename)(contractFile);
-    fileLine = `
-[\`${fileName}\`](${contractFile})`;
-  }
-  return `
-# ${contractName}
-${fileLine}
-
-${doc.comments.join("\n\n")}
-
-${withToc ? markdownTOC(doc) : ""}
-
-## Functions
-
-${functions.join("\n\n")}
-
-## Maps
-
-${maps.join("\n\n")}
-
-## Variables
-
-${vars.join("\n\n")}
-
-## Constants
-
-${constants.join("\n\n")}
-  `;
-}
-function markdownFunction(fn, contractFile) {
-  const params = mdParams(fn);
-  const returnType = (0, import_core9.getTypeString)(fn.abi.outputs.type);
-  const paramSigs = fn.abi.args.map((arg) => {
-    return `(${arg.name} ${(0, import_core9.getTypeString)(arg.type)})`;
-  });
-  const startLine = fn.startLine + 1;
-  let link = "";
-  if (contractFile) {
-    link = `[View in file](${contractFile}#L${startLine})`;
-  }
-  const source = `<details>
-  <summary>Source code:</summary>
-
-\`\`\`clarity
-${fn.source.join("\n")}
-\`\`\`
-</details>
-`;
-  const sig = `(define-${fn.abi.access.replace("_", "-")} (${fn.abi.name} (${paramSigs.join(
-    " "
-  )}) ${returnType})`;
-  return `### ${fn.abi.name}
-
-${link}
-
-\`${sig}\`
-
-${fn.comments.text.join("\n")}
-
-${source}
-
-${params}`;
-}
-function mdParams(fn) {
-  if (fn.abi.args.length === 0) return "";
-  const hasDescription = Object.values(fn.comments.params).some((p) => p.comments.length > 0);
-  const params = Object.values(fn.comments.params).map((p) => markdownParam(p, hasDescription));
-  return `**Parameters:**
-
-| Name | Type | ${hasDescription ? "Description |" : ""}
-| --- | --- | ${hasDescription ? "--- |" : ""}
-${params.join("\n")}`;
-}
-function markdownParam(param, withDescription) {
-  const typeString = (0, import_core9.getTypeString)(param.abi.type);
-  const base = `| ${param.abi.name} | ${typeString} |`;
-  if (!withDescription) return base;
-  return `${base} ${param.comments.join(" ")} |`;
-}
-function markdownMap(map, contractFile) {
-  const startLine = map.startLine + 1;
-  let link = "";
-  if (contractFile) {
-    link = `[View in file](${contractFile}#L${startLine})`;
-  }
-  return `### ${map.abi.name}
-
-${map.comments.text.join("\n")}
-
-\`\`\`clarity
-${map.source.join("\n")}
-\`\`\`
-
-${link}`;
-}
-function markdownVar(variable, contractFile) {
-  const startLine = variable.startLine + 1;
-  let link = "";
-  if (contractFile) {
-    link = `[View in file](${contractFile}#L${startLine})`;
-  }
-  const sig = variable.abi.access === "variable" ? (0, import_core9.getTypeString)(variable.abi.type) : "";
-  return `### ${variable.abi.name}
-
-${sig}
-
-${variable.comments.text.join("\n")}
-
-\`\`\`clarity
-${variable.source.join("\n")}
-\`\`\`
-
-${link}`;
-}
-function markdownTOC(contract) {
-  const publics = contract.functions.filter((fn) => fn.abi.access === "public");
-  const readOnly = contract.functions.filter((fn) => fn.abi.access === "read_only");
-  const privates = contract.functions.filter((fn) => fn.abi.access === "private");
-  const maps = contract.maps;
-  const constants = contract.variables.filter((v) => v.abi.access === "constant");
-  const vars = contract.variables.filter((v) => v.abi.access === "variable");
-  function tocLine(fn) {
-    const name = fn.abi.name;
-    return `- [\`${name}\`](#${name.toLowerCase().replaceAll("?", "")})`;
-  }
-  return `**Public functions:**
-
-${publics.map(tocLine).join("\n")}
-
-**Read-only functions:**
-
-${readOnly.map(tocLine).join("\n")}
-
-**Private functions:**
-
-${privates.map(tocLine).join("\n")}
-
-**Maps**
-
-${maps.map(tocLine).join("\n")}
-
-**Variables**
-
-${vars.map(tocLine).join("\n")}
-
-**Constants**
-
-${constants.map(tocLine).join("\n")}
-`;
-}
-function generateReadme(session, excluded) {
-  const contractLines = [];
-  sortContracts(session.contracts).forEach((contract) => {
-    const name = (0, import_core9.getContractName)(contract.contract_id, false);
-    if (excluded[name]) return;
-    const fileName = `${name}.md`;
-    const line = `- [\`${name}\`](${fileName})`;
-    contractLines.push(line);
-  });
-  const fileContents = `# Contracts
-
-${contractLines.join("\n")}
-  `;
-  return fileContents;
-}
-
-// src/files/docs.ts
-async function generateDocs({
-  session,
-  config
-}) {
-  const docs = config.configFile["docs" /* Docs */];
-  const docsBase = docs == null ? void 0 : docs.output;
-  if (!docsBase) {
-    warnNoDocs();
-    return;
-  }
-  const docsPathExt = (0, import_path5.extname)(docsBase);
-  if (docsPathExt) {
-    log.warn(`Docs output path ('${docsBase}') looks like a file - it needs to be a directory.`);
-  }
-  const excluded = Object.fromEntries(
-    (docs.exclude || []).map((e) => {
-      return [e, true];
-    })
-  );
-  log.debug(`Generating docs at path \`${docsBase}\``);
-  const docsBaseFolder = config.outputResolve("docs" /* Docs */, "./")[0];
-  const paths = await Promise.all(
-    session.contracts.map(async (contract) => {
-      var _a, _b;
-      const name = (0, import_core10.getContractName)(contract.contract_id, false);
-      if (excluded[name]) return null;
-      const docFile = `${name}.md`;
-      const contractPathDef = (_b = (_a = config.clarinet.contracts) == null ? void 0 : _a[name]) == null ? void 0 : _b.path;
-      let contractFile;
-      if (contractPathDef) {
-        const contractPathFull = config.joinFromClarinet(contractPathDef);
-        contractFile = (0, import_path5.relative)(docsBaseFolder, contractPathFull);
-      } else {
-        log.debug(`Couldn't find contract file from Clarinet.toml for contract ${name}`);
-      }
-      const md = generateMarkdown({ contract, contractFile });
-      const path = await config.writeOutput("docs" /* Docs */, md, docFile);
-      return path[0];
-    })
-  );
-  const readme = generateReadme(session, excluded);
-  paths.push((await config.writeOutput("docs" /* Docs */, readme, "README.md"))[0]);
-  await afterDocs(config);
-}
-function warnNoDocs() {
-  log.warn(
-    `
-Clarigen config file doesn't include an output directory for docs.
-
-To generate docs, specify 'docs.output' in your config file:
-
-[docs]
-output = "docs/"
-  `.trimEnd()
-  );
-}
-
-// src/commands/docs-command.ts
-var import_node_path2 = require("path");
-var import_chokidar2 = __toESM(require("chokidar"), 1);
-async function watch2(config, cwd) {
-  return new Promise(async (resolve3, reject) => {
-    var _a;
-    const session = await getSession(config);
-    try {
-      await generateDocs({
-        session,
-        config
-      });
-    } catch (error) {
-      logger.error({ error }, "Error generating types");
-    }
-    const clarinetFolder = (0, import_node_path2.dirname)(config.clarinetFile());
-    const contractsFolder = (0, import_node_path2.join)(clarinetFolder, "/contracts/**/*.clar");
-    const relativeFolder = (0, import_node_path2.relative)(cwd || process.cwd(), contractsFolder);
-    const watchFolders = ((_a = config.esm) == null ? void 0 : _a.watch_folders) ?? [];
-    watchFolders.push(relativeFolder);
-    logger.info(`Watching for changes in ${watchFolders}`);
-    const watcher = import_chokidar2.default.watch(watchFolders, { persistent: true, cwd: clarinetFolder });
-    let running = false;
-    let start = 0;
-    const isVerbose = logger.level !== "info";
-    watcher.on("change", async (path) => {
-      if (!running) {
-        start = Date.now();
-        logger.info(`File ${path} has been changed. Generating types.`);
-        running = true;
-        const session2 = await getSession(config);
-        void generateDocs({
-          session: session2,
-          config
-        }).catch((e) => {
-          logger.error({ error: e }, "Error generating types");
-        }).then(() => {
-          setTimeout(() => {
-            process.stdout.moveCursor(0, -1);
-            process.stdout.clearLine(1);
-            const elapsed = Date.now() - start;
-            logger.info(
-              `Docs generated (${(elapsed / 1e3).toFixed(2)}s). Watching for changes...`
-            );
-            running = false;
-          });
-        });
-      }
-    });
-  });
+//#endregion
+//#region src/commands/docs-command.ts
+async function watch(config, cwd) {
+	return new Promise(async (resolve, reject) => {
+		var _config$esm;
+		const session = await getSession(config);
+		try {
+			await require_esm.generateDocs({
+				session,
+				config
+			});
+		} catch (error) {
+			require_esm.logger.error({ error }, "Error generating types");
+		}
+		const clarinetFolder = (0, node_path.dirname)(config.clarinetFile());
+		const contractsFolder = (0, node_path.join)(clarinetFolder, "/contracts/**/*.clar");
+		const relativeFolder = (0, node_path.relative)(cwd || process.cwd(), contractsFolder);
+		const watchFolders = ((_config$esm = config.esm) === null || _config$esm === void 0 ? void 0 : _config$esm.watch_folders) ?? [];
+		watchFolders.push(relativeFolder);
+		require_esm.logger.info(`Watching for changes in ${watchFolders}`);
+		const watcher = chokidar.default.watch(watchFolders, {
+			persistent: true,
+			cwd: clarinetFolder
+		});
+		let running = false;
+		let start = 0;
+		require_esm.logger.level;
+		watcher.on("change", async (path) => {
+			if (!running) {
+				start = Date.now();
+				require_esm.logger.info(`File ${path} has been changed. Generating types.`);
+				running = true;
+				require_esm.generateDocs({
+					session: await getSession(config),
+					config
+				}).catch((e) => {
+					require_esm.logger.error({ error: e }, "Error generating types");
+				}).then(() => {
+					setTimeout(() => {
+						process.stdout.moveCursor(0, -1);
+						process.stdout.clearLine(1);
+						const elapsed = Date.now() - start;
+						require_esm.logger.info(`Docs generated (${(elapsed / 1e3).toFixed(2)}s). Watching for changes...`);
+						running = false;
+					});
+				});
+			}
+		});
+	});
 }
 var DocsCommand = class extends BaseCommand {
-  static paths = [["docs"]];
-  static usage = BaseCommand.Usage({
-    description: "Generate markdown documentation for your Clarity contracts"
-  });
-  cwd = import_clipanion4.Option.String({ required: false });
-  watch = import_clipanion4.Option.Boolean("-w,--watch", {
-    description: "Watch for changes and regenerate docs",
-    required: false
-  });
-  async execute() {
-    this.preexecute();
-    const config = await Config.load(this.cwd);
-    if (this.watch) {
-      await watch2(config, this.cwd);
-    } else {
-      const session = await getSession(config);
-      await generateDocs({
-        session: {
-          ...session,
-          variables: []
-        },
-        config
-      });
-    }
-  }
+	static paths = [["docs"]];
+	static usage = BaseCommand.Usage({ description: "Generate markdown documentation for your Clarity contracts" });
+	cwd = clipanion.Option.String({ required: false });
+	watch = clipanion.Option.Boolean("-w,--watch", {
+		description: "Watch for changes and regenerate docs",
+		required: false
+	});
+	async execute() {
+		this.preexecute();
+		const config = await require_esm.Config.load(this.cwd);
+		if (this.watch) await watch(config, this.cwd);
+		else await require_esm.generateDocs({
+			session: {
+				...await getSession(config),
+				variables: []
+			},
+			config
+		});
+	}
 };
 
-// src/commands/init-config-command.ts
-var import_clipanion5 = require("clipanion");
-var import_promises6 = require("fs/promises");
-
-// src/generated/init-config.ts
-var tomlInit = `
+//#endregion
+//#region src/generated/init-config.ts
+const tomlInit = `
 # Set to your project's Clarinet config file
 clarinet = "./Clarinet.toml"
 
@@ -1538,53 +269,53 @@ output = "docs"
 # after = "npm run prettier -w ./docs"
 `;
 
-// src/commands/init-config-command.ts
+//#endregion
+//#region src/commands/init-config-command.ts
 var InitConfigCommand = class extends BaseCommand {
-  static paths = [["init-config"], ["init"]];
-  static usage = {
-    description: "Initialize a Clarigen configuration file"
-  };
-  cwd = import_clipanion5.Option.String({ required: false });
-  overwrite = import_clipanion5.Option.Boolean("--overwrite", false, {
-    description: "Overwrite the configuration file if it already exists"
-  });
-  async execute() {
-    this.preexecute();
-    const path = configFilePath(this.cwd);
-    const configExists = await fileExists(path);
-    if (configExists && !this.overwrite) {
-      logger.warn("Configuration file already exists. Use --overwrite to overwrite it.");
-      return 1;
-    }
-    logger.debug(`Writing configuration file to ${path}`);
-    await (0, import_promises6.writeFile)(path, tomlInit, "utf-8");
-  }
+	static paths = [["init-config"], ["init"]];
+	static usage = { description: "Initialize a Clarigen configuration file" };
+	cwd = clipanion.Option.String({ required: false });
+	overwrite = clipanion.Option.Boolean("--overwrite", false, { description: "Overwrite the configuration file if it already exists" });
+	async execute() {
+		this.preexecute();
+		const path = require_esm.configFilePath(this.cwd);
+		if (await require_esm.fileExists(path) && !this.overwrite) {
+			require_esm.logger.warn("Configuration file already exists. Use --overwrite to overwrite it.");
+			return 1;
+		}
+		require_esm.logger.debug(`Writing configuration file to ${path}`);
+		await (0, fs_promises.writeFile)(path, tomlInit, "utf-8");
+	}
 };
 
-// src/generated/version.ts
-var version = "4.0.1";
-
-// src/run-cli.ts
-var [node, script, ...args] = process.argv;
-var cli = new import_clipanion6.Cli({
-  binaryLabel: "Clarigen",
-  binaryName: "clarigen",
-  binaryVersion: version
+//#endregion
+//#region src/generated/version.ts
+const version = "4.0.2-alpha.0";
+
+//#endregion
+//#region src/run-cli.ts
+const [node, script, ...args] = process.argv;
+const cli = new clipanion.Cli({
+	binaryLabel: "Clarigen",
+	binaryName: "clarigen",
+	binaryVersion: version
 });
-cli.register(import_clipanion6.Builtins.HelpCommand);
-cli.register(import_clipanion6.Builtins.VersionCommand);
+cli.register(clipanion.Builtins.HelpCommand);
+cli.register(clipanion.Builtins.VersionCommand);
 cli.register(DefaultCommand);
 cli.register(DocsCommand);
 cli.register(InitConfigCommand);
 cli.register(SessionInfoCommand);
 async function run() {
-  await cli.runExit(args, import_clipanion6.Cli.defaultContext);
+	await cli.runExit(args, clipanion.Cli.defaultContext);
 }
 process.on("SIGINT", () => {
-  logger.info("Bye! \u{1F44B}");
-  process.exit();
+	require_esm.logger.info("Bye! 👋");
+	process.exit();
 });
 run().catch(console.error).finally(() => {
-  process.exit();
+	process.exit();
 });
+
+//#endregion
 //# sourceMappingURL=run-cli.cjs.map