@clarigen/cli 4.0.0 → 4.0.2-alpha.0

package/dist/esm-CO92uOgU.mjs

@@ -0,0 +1,917 @@
+import { cvToValue, getContractName, getTypeString, isClarityAbiBuffer, isClarityAbiList, isClarityAbiOptional, isClarityAbiPrimitive, isClarityAbiResponse, isClarityAbiStringAscii, isClarityAbiStringUtf8, isClarityAbiTraitReference, isClarityAbiTuple, toCamelCase } from "@clarigen/core";
+import { pino } from "pino";
+import pinoPretty from "pino-pretty";
+import { spawn } from "child_process";
+import { basename, dirname, extname, join, relative, resolve } from "path";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { type } from "arktype";
+import { parse, stringify } from "@iarna/toml";
+import { inspect } from "util";
+import { parse as parse$1 } from "yaml";
+import { getContractTxs, getDeploymentContract, getDeploymentTxPath, getIdentifierForDeploymentTx } from "@clarigen/core/deployment";
+
+//#region src/logger.ts
+const colorizedClarigen = `\x1b[33m[Clarigen]\x1b[0m`;
+const logger = pino(pinoPretty({
+	colorize: true,
+	ignore: "pid,hostname,time",
+	messageFormat: `${colorizedClarigen} {msg}`,
+	minimumLevel: "debug"
+}));
+logger.level = "info";
+const log = logger;
+
+//#endregion
+//#region src/docs/index.ts
+const FN_TYPES = [
+	"read-only",
+	"public",
+	"private"
+];
+const 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);
+			currentFn = {
+				abi: abiFn,
+				comments: parseComments(comments, abiFn),
+				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((type$1) => {
+		return line.startsWith(`(define-${type$1}`);
+	});
+	if (fnType) {
+		const prefix = `(define-${fnType} (`;
+		const match = clarityNameMatcher(line.slice(prefix.length));
+		if (!match) {
+			console.debug(`[claridocs]: Unable to determine function name from line:\n  \`${line}\``);
+			return;
+		}
+		return match[0];
+	}
+	for (const type$1 of VAR_TYPES) {
+		const prefix = `(define-${type$1} `;
+		if (!line.startsWith(prefix)) continue;
+		const match = clarityNameMatcher(line.slice(prefix.length));
+		if (!match) {
+			console.debug(`[claridocs]: Unable to determine ${type$1} name from line:\n  \`${line}\``);
+			return;
+		}
+		return match[0];
+	}
+}
+function findAbiItemByName(abi, name) {
+	const fn = abi.functions.find((fn$1) => {
+		return fn$1.name === name;
+	});
+	if (fn) return fn;
+	const map = abi.maps.find((m) => m.name === name);
+	if (map) return map;
+	return abi.variables.find((v) => v.name === name);
+}
+function isComment(line) {
+	return line.startsWith(";;");
+}
+function getFnName(line) {
+	const fnType = FN_TYPES.find((type$1) => {
+		return line.startsWith(`(define-${type$1}`);
+	});
+	if (typeof fnType === "undefined") return;
+	const prefix = `(define-${fnType} (`;
+	const match = clarityNameMatcher(line.slice(prefix.length));
+	if (!match) {
+		console.debug(`[claridocs]: Unable to determine function name from line:\n  \`${line}\``);
+		return;
+	}
+	return match[0];
+}
+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((arg$1) => arg$1.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 _config$docs;
+	const command = (_config$docs = config.docs) === null || _config$docs === void 0 ? void 0 : _config$docs.after;
+	if (!command) return;
+	logger.debug(`Running after docs command: ${command}`);
+	const [cmd, ...args] = command.split(" ");
+	return new Promise((resolve$1, reject) => {
+		const child = spawn(cmd, args, {
+			cwd: config.cwd,
+			stdio: "inherit"
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) resolve$1();
+			else reject(/* @__PURE__ */ new Error(`Command failed with code ${code ?? "unknown"}`));
+		});
+	});
+}
+
+//#endregion
+//#region src/utils.ts
+function encodeVariableName(name) {
+	if (/^[A-Z\-_]*$/.test(name)) return name.replaceAll("-", "_");
+	return toCamelCase(name);
+}
+async function fileExists(filename) {
+	try {
+		await stat(filename);
+		return true;
+	} catch (error) {
+		return false;
+	}
+}
+async function writeFile$1(path, contents) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, contents, "utf-8");
+	return path;
+}
+function cwdRelative(path) {
+	return relative(process.cwd(), path);
+}
+function sortContracts(contracts) {
+	return [...contracts].sort((a, b) => {
+		if (getContractName(a.contract_id, false) < getContractName(b.contract_id, false)) return -1;
+		return 1;
+	});
+}
+
+//#endregion
+//#region src/docs/markdown.ts
+function generateMarkdown({ contract, contractFile, withToc = true }) {
+	const contractName = 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) fileLine = `\n[\`${basename(contractFile)}\`](${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 = getTypeString(fn.abi.outputs.type);
+	const paramSigs = fn.abi.args.map((arg) => {
+		return `(${arg.name} ${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 = 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" ? 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 = getContractName(contract.contract_id, false);
+		if (excluded[name]) return;
+		const line = `- [\`${name}\`](${`${name}.md`})`;
+		contractLines.push(line);
+	});
+	return `# Contracts
+
+${contractLines.join("\n")}
+  `;
+}
+
+//#endregion
+//#region src/clarinet-config.ts
+const ClarinetConfig = type({
+	project: type({
+		requirements: type({ contract_id: type("string").describe("Contract ID") }).array().describe("Project requirements").optional(),
+		cache_location: type({ path: type("string").describe("Cache location path") }).optional()
+	}),
+	contracts: type({ "[string]": type({ path: type("string").describe("Contract path") }) }).optional()
+});
+async function getClarinetConfig(path) {
+	const file = await readFile(path, "utf-8");
+	return ClarinetConfig.assert(parse(file));
+}
+
+//#endregion
+//#region src/config.ts
+const CONFIG_FILE = "Clarigen.toml";
+let OutputType = /* @__PURE__ */ function(OutputType$1) {
+	OutputType$1["ESM"] = "types";
+	OutputType$1["ESM_OLD"] = "esm";
+	OutputType$1["Docs"] = "docs";
+	return OutputType$1;
+}({});
+const typesSchema = type({
+	"output?": type("string").describe("Path to the output file"),
+	"outputs?": type("string[]").describe("Paths to the output files"),
+	"include_accounts?": type("boolean").describe("Include accounts in the output"),
+	"after?": type("string").describe("Script to run after the output is generated"),
+	"include_boot_contracts?": type("boolean").describe("Include boot contracts in the output"),
+	"watch_folders?": type("string[]").describe("Folders to watch for changes")
+}).optional();
+const ConfigFile = type({
+	clarinet: type("string").describe("Path to the Clarinet config file"),
+	[OutputType.ESM]: typesSchema,
+	[OutputType.ESM_OLD]: typesSchema,
+	[OutputType.Docs]: type({
+		"output?": type("string").describe("Path to docs output folder. Defaults to ./docs"),
+		"outputs?": type("string[]").describe("Paths to docs output folders"),
+		"exclude?": type("string[]").describe("Contracts to exclude from docs generation"),
+		"after?": type("string").describe("Script to run after docs are generated")
+	}).optional()
+});
+const 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[OutputType.ESM_OLD]) {
+			config[OutputType.ESM] = config[OutputType.ESM_OLD];
+			delete config[OutputType.ESM_OLD];
+		}
+		const clarinet = await getClarinetConfig(resolve(cwd ?? "", config.clarinet));
+		return new this(config, clarinet, cwd);
+	}
+	getOutputs(type$1) {
+		var _this$configFile$type, _this$configFile$type2;
+		const singlePath = (_this$configFile$type = this.configFile[type$1]) === null || _this$configFile$type === void 0 ? void 0 : _this$configFile$type.output;
+		const multiPath = ((_this$configFile$type2 = this.configFile[type$1]) === null || _this$configFile$type2 === void 0 ? void 0 : _this$configFile$type2.outputs) || [];
+		if (singlePath !== void 0) return [singlePath];
+		return multiPath;
+	}
+	outputResolve(type$1, filePath) {
+		const outputs = this.getOutputs(type$1);
+		if (!this.supports(type$1)) return null;
+		return outputs.map((path) => {
+			return resolve(this.cwd, path, filePath || "");
+		});
+	}
+	async writeOutput(type$1, contents, filePath) {
+		const paths = this.outputResolve(type$1, filePath);
+		if (paths === null) return null;
+		await Promise.all(paths.map(async (path) => {
+			await writeFile$1(path, contents);
+			log.debug(`Generated ${type$1} file at ${relative(this.cwd, path)}`);
+		}));
+		return paths;
+	}
+	supports(type$1) {
+		return this.getOutputs(type$1).length > 0;
+	}
+	type(type$1) {
+		return this.configFile[type$1];
+	}
+	get esm() {
+		return this.configFile[OutputType.ESM];
+	}
+	get docs() {
+		return this.configFile[OutputType.Docs];
+	}
+	clarinetFile() {
+		return resolve(this.cwd, this.configFile.clarinet);
+	}
+	joinFromClarinet(filePath) {
+		return join(dirname(this.clarinetFile()), filePath);
+	}
+};
+function configFilePath(cwd) {
+	return resolve(cwd ?? process.cwd(), CONFIG_FILE);
+}
+async function saveConfig(config) {
+	const configToml = stringify({ ...config });
+	await writeFile$1(configFilePath(), configToml);
+}
+let sessionConfig;
+async function getConfig(cwd) {
+	if (typeof sessionConfig !== "undefined") return sessionConfig;
+	const path = configFilePath(cwd);
+	if (await fileExists(path)) {
+		const parsed = ConfigFile(parse(await readFile(path, "utf-8")));
+		if (parsed instanceof 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;
+}
+
+//#endregion
+//#region src/files/docs.ts
+async function generateDocs({ session, config }) {
+	const docs = config.configFile[OutputType.Docs];
+	const docsBase = docs === null || docs === void 0 ? void 0 : docs.output;
+	if (!docsBase) {
+		warnNoDocs();
+		return;
+	}
+	if (extname(docsBase)) 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(OutputType.Docs, "./")[0];
+	const paths = await Promise.all(session.contracts.map(async (contract) => {
+		var _config$clarinet$cont;
+		const name = getContractName(contract.contract_id, false);
+		if (excluded[name]) return null;
+		const docFile = `${name}.md`;
+		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 contractFile;
+		if (contractPathDef) contractFile = relative(docsBaseFolder, config.joinFromClarinet(contractPathDef));
+		else log.debug(`Couldn't find contract file from Clarinet.toml for contract ${name}`);
+		const md = generateMarkdown({
+			contract,
+			contractFile
+		});
+		return (await config.writeOutput(OutputType.Docs, md, docFile))[0];
+	}));
+	const readme = generateReadme(session, excluded);
+	paths.push((await config.writeOutput(OutputType.Docs, readme, "README.md"))[0]);
+	await afterDocs(config);
+}
+function warnNoDocs() {
+	log.warn(`\nClarigen config file doesn't include an output directory for docs.
+
+To generate docs, specify 'docs.output' in your config file:
+
+[docs]
+output = "docs/"
+  `.trimEnd());
+}
+
+//#endregion
+//#region src/declaration.ts
+const jsTypeFromAbiType = (val, isArgument = false) => {
+	if (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 (isClarityAbiBuffer(val)) return "Uint8Array";
+	else if (isClarityAbiResponse(val)) return `Response<${jsTypeFromAbiType(val.response.ok, isArgument)}, ${jsTypeFromAbiType(val.response.error, isArgument)}>`;
+	else if (isClarityAbiOptional(val)) return `${jsTypeFromAbiType(val.optional, isArgument)} | null`;
+	else if (isClarityAbiTuple(val)) {
+		const tupleDefs = [];
+		val.tuple.forEach(({ name, type: type$1 }) => {
+			const camelName = toCamelCase(name);
+			const innerType = jsTypeFromAbiType(type$1, isArgument);
+			tupleDefs.push(`"${camelName}": ${innerType};`);
+		});
+		return `{
+  ${tupleDefs.join("\n  ")}
+}`;
+	} else if (isClarityAbiList(val)) return `${jsTypeFromAbiType(val.list.type, isArgument)}[]`;
+	else if (isClarityAbiStringAscii(val)) return "string";
+	else if (isClarityAbiStringUtf8(val)) return "string";
+	else if (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 args = abiFunction.args.map(abiArgType);
+	const retType = jsTypeFromAbiType(abiFunction.outputs.type);
+	return `TypedAbiFunction<${`[${args.join(", ")}]`}, ${retType}>`;
+}
+function getArgName(name) {
+	const camel = toCamelCase(name);
+	return `${RESERVED[camel] ? "_" : ""}${camel}`;
+}
+function _hash(...words) {
+	const h = {};
+	for (const word of words) h[word] = true;
+	return h;
+}
+const RESERVED = _hash("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", "enum", "await", "null", "true", "false");
+
+//#endregion
+//#region 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) {
+	return [...accounts].sort((a, b) => {
+		if (a.name < b.name) return -1;
+		return 1;
+	});
+}
+
+//#endregion
+//#region src/files/identifiers.ts
+function generateIdentifiers(session) {
+	return Object.fromEntries(sortContracts(session.contracts).map((c) => {
+		return [getContractName(c.contract_id), c.contract_id];
+	}));
+}
+function generateIdentifiersCode(session) {
+	const identifiers = generateIdentifiers(session);
+	return `export const identifiers = ${JSON.stringify(identifiers)} as const`;
+}
+
+//#endregion
+//#region src/files/base.ts
+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 = `${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 = `${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}',
+  }`;
+}
+const TYPE_IMPORTS = `import type { TypedAbiArg, TypedAbiFunction, TypedAbiMap, TypedAbiVariable, Response } from '@clarigen/core';`;
+function generateBaseFile(session) {
+	return `
+${TYPE_IMPORTS}
+
+export const contracts = {
+  ${sortContracts(session.contracts.map((c, i) => ({
+		...c,
+		constants: session.variables[i]
+	}))).map((contract) => {
+		const meta = generateContractMeta(contract, contract.constants);
+		const id = contract.contract_id.split(".")[1];
+		return `${toCamelCase(id)}: ${meta}`;
+	}).join(",\n")}
+} as const;
+
+export const accounts = ${generateAccountsCode(session.accounts)} as const;
+
+${generateIdentifiersCode(session)}
+
+export const simnet = {
+  accounts,
+  contracts,
+  identifiers,
+} as const;
+
+`;
+}
+function encodeVariables(variables) {
+	return variables.map((v) => {
+		let varLine = `${encodeVariableName(v.name)}: `;
+		const type$1 = jsTypeFromAbiType(v.type);
+		const varJSON = serialize(v);
+		varLine += `${varJSON} as TypedAbiVariable<${type$1}>`;
+		return varLine;
+	});
+}
+Uint8Array.prototype[inspect.custom] = function(depth, options) {
+	return `Uint8Array.from([${this.join(",")}])`;
+};
+function serialize(obj) {
+	return inspect(obj, {
+		showHidden: false,
+		compact: false,
+		depth: 100,
+		colors: false,
+		maxArrayLength: Infinity,
+		maxStringLength: Infinity,
+		breakLength: Infinity,
+		numericSeparator: true
+	});
+}
+function serializeLines(key, lines) {
+	return `"${key}": {
+    ${lines.join(",\n    ")}
+  },`;
+}
+function serializeArray(key, lines) {
+	return `"${key}": [
+    ${lines.join(",\n    ")}
+  ],`;
+}
+
+//#endregion
+//#region 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 = `${getContractName(contract.contract_id)}-vars`;
+	logger.debug(`Deploying ${contract.contract_id} for variables.`);
+	if (!contract.source) {
+		logger.debug(`Contract ${getContractName(contract.contract_id)} has no source. Skipping variables.`);
+		return {};
+	}
+	if (contract.contract_interface.variables.length === 0) {
+		logger.info(`Contract ${getContractName(contract.contract_id, false)} has no variables`);
+		return {};
+	}
+	let varFn = `{\n`;
+	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 + `\n\n${varFn}`;
+	try {
+		const result = simnet.deployContract(fakeId, fullSrc, { clarityVersion: clarityVersionForContract(contract) }, deployer).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(cvToValue(result, true));
+		return cvToValue(result, true);
+	} catch (error) {
+		logger.warn({ err: error }, `Error getting variables for ${getContractName(contract.contract_id, false)}`);
+		return {};
+	}
+}
+function mapVariables(session, simnet) {
+	return session.contracts.map((contract) => {
+		return serialize(getVariablesV2(contract, simnet));
+	});
+}
+
+//#endregion
+//#region src/files/esm.ts
+async function parseDeployment(path) {
+	return parse$1(await readFile(path, "utf-8"));
+}
+const 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 = join(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 = getContractName(identifier);
+	if (!deployments[name]) return;
+	if (deployments[name][network] === null) deployments[name][network] = identifier;
+}
+function collectContractDeployments(session, deployments, config) {
+	var _config$clarinet$proj;
+	const full = Object.fromEntries(sortContracts(session.contracts).map((contract) => {
+		return [getContractName(contract.contract_id), Object.fromEntries(DEPLOYMENT_NETWORKS.map((network) => {
+			const deployment = deployments[network];
+			if (typeof deployment === "undefined") return [network, null];
+			try {
+				const contractName = contract.contract_id.split(".")[1];
+				return [network, getIdentifierForDeploymentTx(getDeploymentContract(contractName, deployment))];
+			} catch (_) {
+				return [network, null];
+			}
+		}))];
+	}));
+	const deployer = session.accounts.find((a) => a.name === "deployer");
+	(_config$clarinet$proj = config.clarinet.project.requirements) === null || _config$clarinet$proj === void 0 || _config$clarinet$proj.forEach(({ contract_id }) => {
+		insertNetworkId(full, contract_id, "mainnet");
+		const contractName = contract_id.split(".")[1];
+		if (deployer) insertNetworkId(full, `${deployer.address}.${contractName}`, "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;
+	return getContractTxs(simnet.plan.batches).map((tx) => {
+		return {
+			identifier: getIdentifierForDeploymentTx(tx),
+			file: relative(cwd, join(clarinetFolder, getDeploymentTxPath(tx)))
+		};
+	});
+}
+function generateSimnetCode(config, deployments, _session) {
+	var _config$esm;
+	if (!((_config$esm = config.esm) === null || _config$esm === void 0 ? void 0 : _config$esm.include_accounts)) return "";
+	const files = collectDeploymentFiles(deployments, dirname(config.clarinetFile()), config.cwd);
+	return `
+export const simnetDeployment = ${JSON.stringify(files)};
+`;
+}
+async function afterESM(config) {
+	var _config$esm2;
+	const command = (_config$esm2 = config.esm) === null || _config$esm2 === void 0 ? void 0 : _config$esm2.after;
+	if (!command) return;
+	logger.debug(`Running after ESM command: ${command}`);
+	const [cmd, ...args] = command.split(" ");
+	return new Promise((resolve$1, reject) => {
+		const child = spawn(cmd, args, {
+			cwd: config.cwd,
+			stdio: "inherit"
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) resolve$1();
+			else reject(/* @__PURE__ */ new Error(`Command failed with code ${code ?? "unknown"}`));
+		});
+	});
+}
+
+//#endregion
+export { generateMarkdown as A, afterDocs as B, OutputType as C, saveConfig as D, getConfig as E, fileExists as F, traceParens as G, getFnName as H, sortContracts as I, logger as K, writeFile$1 as L, markdownFunction as M, cwdRelative as N, ClarinetConfig as O, encodeVariableName as P, FN_TYPES as R, ConfigFile as S, defaultConfigFile as T, isComment as U, createContractDocInfo as V, parseComments as W, getArgName as _, generateESMFile as a, CONFIG_FILE as b, getVariablesV2 as c, encodeVariables as d, generateBaseFile as f, abiFunctionType as g, abiArgType as h, collectDeploymentFiles as i, generateReadme as j, getClarinetConfig as k, mapVariables as l, serialize as m, afterESM as n, getDeployments as o, generateContractMeta as p, collectContractDeployments as r, parseDeployment as s, DEPLOYMENT_NETWORKS as t, TYPE_IMPORTS as u, jsTypeFromAbiType as v, configFilePath as w, Config as x, generateDocs as y, VAR_TYPES as z };
+//# sourceMappingURL=esm-CO92uOgU.mjs.map