@codama/renderers-rust 1.2.8 → 2.0.0

package/dist/index.node.cjs

@@ -1,44 +1,25 @@
-"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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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;
-};
-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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('@codama/errors');
+var nodes = require('@codama/nodes');
+var renderersCore = require('@codama/renderers-core');
+var visitorsCore = require('@codama/visitors-core');
+var toml = require('@iarna/toml');
+var semver = require('semver');
+var codecsStrings = require('@solana/codecs-strings');
+var path = require('path');
+require('url');
+var nunjucks = require('nunjucks');
+var child_process = require('child_process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ImportMap: () => ImportMap,
-  default: () => renderVisitor,
-  getRenderMapVisitor: () => getRenderMapVisitor,
-  getTypeManifestVisitor: () => getTypeManifestVisitor,
-  renderVisitor: () => renderVisitor
-});
-module.exports = __toCommonJS(index_exports);
+var nunjucks__default = /*#__PURE__*/_interopDefault(nunjucks);
 
 // src/ImportMap.ts
+var RUST_CORE_IMPORTS = /* @__PURE__ */ new Set(["std", "crate", "super", "self", "core", "alloc", "clippy"]);
 var DEFAULT_MODULE_MAP = {
   generated: "crate::generated",
   generatedAccounts: "crate::generated::accounts",
@@ -98,6 +79,10 @@ var ImportMap = class _ImportMap {
     this._aliases.forEach((alias, i) => newImportMap.addAlias(resolveDependency(i), alias));
     return newImportMap;
   }
+  getExternalDependencies(dependencyMap) {
+    const resolvedMap = this.resolveDependencyMap(dependencyMap);
+    return new Set([...resolvedMap._imports].map((i) => i.split("::")[0]).filter((i) => !RUST_CORE_IMPORTS.has(i)));
+  }
   toString(dependencies) {
     const resolvedMap = this.resolveDependencyMap(dependencies);
     const importStatements = [...resolvedMap.imports].map((i) => {
@@ -108,48 +93,274 @@ var ImportMap = class _ImportMap {
     return importStatements.join("\n");
   }
 };
-
-// src/getRenderMapVisitor.ts
-var import_errors3 = require("@codama/errors");
-var import_nodes6 = require("@codama/nodes");
-var import_renderers_core = require("@codama/renderers-core");
-var import_visitors_core4 = require("@codama/visitors-core");
-
-// src/getTypeManifestVisitor.ts
-var import_errors2 = require("@codama/errors");
-var import_nodes5 = require("@codama/nodes");
-var import_visitors_core3 = require("@codama/visitors-core");
-
-// src/utils/codecs.ts
-var import_codecs_strings = require("@solana/codecs-strings");
+var DEFAULT_DEPENDENCY_VERSIONS = {
+  "anchor-lang": { optional: true, version: "~0.31" },
+  borsh: "^0.10",
+  kaigan: { features: ["serde"], version: "^0.3" },
+  "num-derive": "^0.4",
+  "num-traits": "^0.2",
+  serde: { features: ["derive"], optional: true, version: "^1.0" },
+  "serde-big-array": "^0.5",
+  serde_with: { optional: true, version: "^3.0" },
+  "solana-account": "~2.2",
+  "solana-account-info": "~2.3",
+  "solana-client": { optional: true, version: "^2.2" },
+  "solana-cpi": "~2.2",
+  "solana-decode-error": "~2.3",
+  "solana-instruction": "~2.3",
+  "solana-program-error": "~2.2",
+  "solana-pubkey": { features: ["curve25519", "borsh"], version: "~2.3" },
+  "solana-sdk": { optional: true, version: "^2.3" },
+  thiserror: "^1.0"
+};
+function syncCargoToml(renderMap, crateFolder, options) {
+  const shouldSyncCargoToml = options.syncCargoToml ?? false;
+  const cargoTomlPath = renderersCore.joinPath(crateFolder, "Cargo.toml");
+  const usedDependencies = getUsedDependencyVersions(
+    renderMap,
+    options.dependencyMap ?? {},
+    options.dependencyVersions ?? {}
+  );
+  if (!shouldSyncCargoToml) {
+    if (renderersCore.fileExists(cargoTomlPath)) {
+      checkExistingCargoToml(readCargoToml(cargoTomlPath), usedDependencies);
+    }
+    return;
+  }
+  if (renderersCore.fileExists(cargoTomlPath)) {
+    const cargoToml = updateExistingCargoToml(readCargoToml(cargoTomlPath), usedDependencies);
+    renderersCore.writeFile(cargoTomlPath, toml.stringify(cargoToml) + "\n");
+  } else {
+    const cargoToml = createNewCargoToml(usedDependencies);
+    renderersCore.writeFile(cargoTomlPath, toml.stringify(cargoToml) + "\n");
+  }
+}
+function createNewCargoToml(usedDependencies) {
+  return updateExistingCargoToml(
+    {
+      name: "rust-client",
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      description: "",
+      version: "1.0.0",
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      repository: { workspace: true },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      edition: { workspace: true },
+      license: { workspace: true },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      features: {
+        anchor: ["dep:anchor-lang"],
+        "anchor-idl-build": ["anchor", "anchor-lang?/idl-build"],
+        fetch: ["dep:solana-client", "dep:solana-sdk"],
+        serde: ["dep:serde", "dep:serde_with"]
+      },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      dependencies: {}
+    },
+    usedDependencies
+  );
+}
+function updateExistingCargoToml(cargoToml, usedDependencies) {
+  const foundUsedDependencies = /* @__PURE__ */ new Set();
+  const updatedCargoToml = updateCargoDependencies(cargoToml, (dependencyGroup) => {
+    return Object.fromEntries(
+      Object.entries(dependencyGroup).map(([dependencyKey, dependency]) => {
+        const foundUsedDependency = findCargoDependencyByImportName(
+          usedDependencies,
+          getCargoDependencyImportName(dependencyKey)
+        );
+        if (!foundUsedDependency) {
+          return [dependencyKey, dependency];
+        }
+        const [usedDependencyKey, usedDependency] = foundUsedDependency;
+        foundUsedDependencies.add(usedDependencyKey);
+        const usedDependencyCrateName = getCargoDependencyCrateName(usedDependencyKey, usedDependency);
+        if (!shouldUpdateDependency(usedDependencyCrateName, dependency, usedDependency)) {
+          return [dependencyKey, dependency];
+        }
+        const newVersion = getCargoDependencyVersion(usedDependency);
+        return [
+          dependencyKey,
+          typeof dependency === "string" ? newVersion : { ...dependency, version: newVersion }
+        ];
+      })
+    );
+  });
+  const usedDependenciesToAdd = Object.entries(usedDependencies).filter(
+    ([usedDependencyKey]) => !foundUsedDependencies.has(usedDependencyKey)
+  );
+  for (const [usedDependencyKey, usedDependency] of usedDependenciesToAdd) {
+    updatedCargoToml.dependencies = updatedCargoToml.dependencies ?? {};
+    updatedCargoToml.dependencies[usedDependencyKey] = usedDependency;
+  }
+  return updatedCargoToml;
+}
+function checkExistingCargoToml(cargoToml, usedDependencies) {
+  const missingDependencies = [];
+  const dependenciesToUpdate = [];
+  const existingDependencies = {
+    ...cargoToml["build-dependencies"],
+    ...cargoToml["dev-dependencies"],
+    ...cargoToml.dependencies,
+    ...cargoToml.workspace?.dependencies,
+    ...Object.values(cargoToml.target ?? {}).reduce((acc, target) => {
+      return {
+        ...acc,
+        ...target["build-dependencies"],
+        ...target["dev-dependencies"],
+        ...target.dependencies
+      };
+    }, {})
+  };
+  for (const [usedDependencyKey, usedDependency] of Object.entries(usedDependencies)) {
+    const foundExistingDependency = findCargoDependencyByImportName(
+      existingDependencies,
+      getCargoDependencyImportName(usedDependencyKey)
+    );
+    if (!foundExistingDependency) {
+      missingDependencies.push(usedDependencyKey);
+    } else if (shouldUpdateDependency(foundExistingDependency[0], foundExistingDependency[1], usedDependency)) {
+      dependenciesToUpdate.push(usedDependencyKey);
+    }
+  }
+  if (missingDependencies.length === 0 && dependenciesToUpdate.length === 0) return;
+  const missingList = missingDependencies.map((d) => `- ${d} missing: ${getCargoDependencyVersion(usedDependencies[d])}
+`).join("");
+  const outdatedList = dependenciesToUpdate.map(
+    (d) => `- ${d} outdated: ${getCargoDependencyVersion(existingDependencies[d])} -> ${getCargoDependencyVersion(usedDependencies[d])}
+`
+  ).join("");
+  errors.logWarn(
+    `The following dependencies in your \`Cargo.toml\` are out-of-date or missing:
+${missingList}${outdatedList}`
+  );
+}
+function getUsedDependencyVersions(renderMap, dependencyMap, dependencyVersions) {
+  const usedImportNames = getUsedImportNames(renderMap, dependencyMap);
+  const dependencyVersionsWithDefaults = {
+    ...DEFAULT_DEPENDENCY_VERSIONS,
+    ...dependencyVersions
+  };
+  const [usedDependencyVersion, missingDependencies] = [...usedImportNames].reduce(
+    ([acc, missingDependencies2], usedImportName) => {
+      const usedDependency = findCargoDependencyByImportName(dependencyVersionsWithDefaults, usedImportName);
+      if (usedDependency) {
+        acc[usedDependency[0]] = usedDependency[1];
+      } else {
+        missingDependencies2.add(usedImportName);
+      }
+      return [acc, missingDependencies2];
+    },
+    [{}, /* @__PURE__ */ new Set()]
+  );
+  if (missingDependencies.size > 0) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS, {
+      dependencies: [...missingDependencies],
+      message: "Please add these dependencies to the `dependencyVersions` option."
+    });
+  }
+  return usedDependencyVersion;
+}
+function getUsedImportNames(renderMap, dependencyMap) {
+  const fragments = [...renderMap.values()];
+  const fromImportMap = new ImportMap().mergeWith(...fragments.map(({ imports }) => imports)).getExternalDependencies(dependencyMap);
+  const PATH_REGEX = /\b(?:::)?([a-z_][a-z0-9_]*)(?:::[a-zA-Z0-9_]+)+/g;
+  const fromContent = fragments.flatMap(({ content }) => {
+    return [...content.matchAll(PATH_REGEX)].map((match) => match[1]).filter((crateName) => !RUST_CORE_IMPORTS.has(crateName));
+  });
+  return /* @__PURE__ */ new Set([...fromImportMap, ...fromContent]);
+}
+function shouldUpdateDependency(dependency, currentDependency, requiredDependency) {
+  const currentRange = getCargoDependencyVersion(currentDependency);
+  const requiredRange = getCargoDependencyVersion(requiredDependency);
+  return !!currentRange && !!requiredRange && shouldUpdateRange(dependency, currentRange, requiredRange);
+}
+function shouldUpdateRange(dependency, currentRange, requiredRange) {
+  currentRange = cargoToNpmSemver(currentRange);
+  requiredRange = cargoToNpmSemver(requiredRange);
+  try {
+    if (semver.subset(currentRange, requiredRange)) {
+      return false;
+    }
+    const minRequiredVersion = semver.minVersion(requiredRange);
+    const minCurrentVersion = semver.minVersion(currentRange);
+    if (!minCurrentVersion || !minRequiredVersion) {
+      throw new Error("Could not determine minimum versions.");
+    }
+    if (semver.lt(minCurrentVersion, minRequiredVersion)) {
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.warn(
+      `Could not parse the following ranges for dependency "${dependency}": [${currentRange}] and/or [${requiredRange}]. Caused by: ${error.message}`
+    );
+    return false;
+  }
+}
+function updateCargoDependencies(cargoToml, updateFn) {
+  const updatedCargoToml = JSON.parse(JSON.stringify(cargoToml));
+  const standardSections = ["dependencies", "dev-dependencies", "build-dependencies"];
+  for (const section of standardSections) {
+    if (updatedCargoToml[section]) {
+      updatedCargoToml[section] = updateFn(updatedCargoToml[section]);
+    }
+  }
+  if (updatedCargoToml.target) {
+    for (const targetKey of Object.keys(updatedCargoToml.target)) {
+      for (const section of standardSections) {
+        if (updatedCargoToml.target[targetKey][section]) {
+          updatedCargoToml.target[targetKey][section] = updateFn(updatedCargoToml.target[targetKey][section]);
+        }
+      }
+    }
+  }
+  if (updatedCargoToml.workspace?.dependencies) {
+    updatedCargoToml.workspace.dependencies = updateFn(updatedCargoToml.workspace.dependencies);
+  }
+  return updatedCargoToml;
+}
+function cargoToNpmSemver(cargoVersion) {
+  const version = cargoVersion.trim();
+  return /^\d+(\.\d+)?(\.\d+)?/.test(version) ? `^${version}` : version;
+}
+function getCargoDependencyVersion(dependency) {
+  return typeof dependency === "string" ? dependency : dependency.version;
+}
+function getCargoDependencyCrateName(key, dependency) {
+  return typeof dependency !== "string" && dependency.package ? dependency.package : key;
+}
+function getCargoDependencyImportName(key) {
+  return key.replace(/-/g, "_");
+}
+function findCargoDependencyByImportName(dependencies, importName) {
+  return Object.entries(dependencies).find(([key]) => {
+    return getCargoDependencyImportName(key) === importName;
+  });
+}
+function readCargoToml(path) {
+  return toml.parse(renderersCore.readFile(path));
+}
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
-      return (0, import_codecs_strings.getUtf8Encoder)().encode(node.data);
+      return codecsStrings.getUtf8Encoder().encode(node.data);
     case "base16":
-      return (0, import_codecs_strings.getBase16Encoder)().encode(node.data);
+      return codecsStrings.getBase16Encoder().encode(node.data);
     case "base58":
-      return (0, import_codecs_strings.getBase58Encoder)().encode(node.data);
+      return codecsStrings.getBase58Encoder().encode(node.data);
     case "base64":
     default:
-      return (0, import_codecs_strings.getBase64Encoder)().encode(node.data);
+      return codecsStrings.getBase64Encoder().encode(node.data);
   }
 }
-
-// src/utils/discriminatorConstant.ts
-var import_nodes2 = require("@codama/nodes");
-var import_visitors_core2 = require("@codama/visitors-core");
-
-// src/renderValueNodeVisitor.ts
-var import_nodes = require("@codama/nodes");
-var import_visitors_core = require("@codama/visitors-core");
 function renderValueNode(value, getImportFrom, useStr = false) {
-  return (0, import_visitors_core.visit)(value, renderValueNodeVisitor(getImportFrom, useStr));
+  return visitorsCore.visit(value, renderValueNodeVisitor(getImportFrom, useStr));
 }
 function renderValueNodeVisitor(getImportFrom, useStr = false) {
   return {
     visitArrayValue(node) {
-      const list = node.items.map((v) => (0, import_visitors_core.visit)(v, this));
+      const list = node.items.map((v) => visitorsCore.visit(v, this));
       return {
         imports: new ImportMap().mergeWith(...list.map((c) => c.imports)),
         render: `[${list.map((c) => c.render).join(", ")}]`
@@ -163,18 +374,18 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
     },
     visitBytesValue(node) {
       const bytes = getBytesFromBytesValueNode(node);
-      const numbers = Array.from(bytes).map(import_nodes.numberValueNode);
-      return (0, import_visitors_core.visit)((0, import_nodes.arrayValueNode)(numbers), this);
+      const numbers = Array.from(bytes).map(nodes.numberValueNode);
+      return visitorsCore.visit(nodes.arrayValueNode(numbers), this);
     },
     visitConstantValue(node) {
-      if ((0, import_nodes.isNode)(node.value, "bytesValueNode")) {
-        return (0, import_visitors_core.visit)(node.value, this);
+      if (nodes.isNode(node.value, "bytesValueNode")) {
+        return visitorsCore.visit(node.value, this);
       }
-      if ((0, import_nodes.isNode)(node.type, "stringTypeNode") && (0, import_nodes.isNode)(node.value, "stringValueNode")) {
-        return (0, import_visitors_core.visit)((0, import_nodes.bytesValueNode)(node.type.encoding, node.value.string), this);
+      if (nodes.isNode(node.type, "stringTypeNode") && nodes.isNode(node.value, "stringValueNode")) {
+        return visitorsCore.visit(nodes.bytesValueNode(node.type.encoding, node.value.string), this);
       }
-      if ((0, import_nodes.isNode)(node.type, "numberTypeNode") && (0, import_nodes.isNode)(node.value, "numberValueNode")) {
-        const numberManifest = (0, import_visitors_core.visit)(node.value, this);
+      if (nodes.isNode(node.type, "numberTypeNode") && nodes.isNode(node.value, "numberValueNode")) {
+        const numberManifest = visitorsCore.visit(node.value, this);
         const { format, endian } = node.type;
         const byteFunction = endian === "le" ? "to_le_bytes" : "to_be_bytes";
         numberManifest.render = `${numberManifest.render}${format}.${byteFunction}()`;
@@ -184,14 +395,14 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
     },
     visitEnumValue(node) {
       const imports = new ImportMap();
-      const enumName = (0, import_nodes.pascalCase)(node.enum.name);
-      const variantName = (0, import_nodes.pascalCase)(node.variant);
+      const enumName = nodes.pascalCase(node.enum.name);
+      const variantName = nodes.pascalCase(node.variant);
       const importFrom = getImportFrom(node.enum);
       imports.add(`${importFrom}::${enumName}`);
       if (!node.value) {
         return { imports, render: `${enumName}::${variantName}` };
       }
-      const enumValue = (0, import_visitors_core.visit)(node.value, this);
+      const enumValue = visitorsCore.visit(node.value, this);
       const fields = enumValue.render;
       return {
         imports: imports.mergeWith(enumValue.imports),
@@ -199,15 +410,15 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitMapEntryValue(node) {
-      const mapKey = (0, import_visitors_core.visit)(node.key, this);
-      const mapValue = (0, import_visitors_core.visit)(node.value, this);
+      const mapKey = visitorsCore.visit(node.key, this);
+      const mapValue = visitorsCore.visit(node.value, this);
       return {
         imports: mapKey.imports.mergeWith(mapValue.imports),
         render: `[${mapKey.render}, ${mapValue.render}]`
       };
     },
     visitMapValue(node) {
-      const map = node.entries.map((entry) => (0, import_visitors_core.visit)(entry, this));
+      const map = node.entries.map((entry) => visitorsCore.visit(entry, this));
       const imports = new ImportMap().add("std::collection::HashMap");
       return {
         imports: imports.mergeWith(...map.map((c) => c.imports)),
@@ -233,7 +444,7 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitSetValue(node) {
-      const set = node.items.map((v) => (0, import_visitors_core.visit)(v, this));
+      const set = node.items.map((v) => visitorsCore.visit(v, this));
       const imports = new ImportMap().add("std::collection::HashSet");
       return {
         imports: imports.mergeWith(...set.map((c) => c.imports)),
@@ -241,7 +452,7 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitSomeValue(node) {
-      const child = (0, import_visitors_core.visit)(node.value, this);
+      const child = visitorsCore.visit(node.value, this);
       return {
         ...child,
         render: `Some(${child.render})`
@@ -254,21 +465,21 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitStructFieldValue(node) {
-      const structValue = (0, import_visitors_core.visit)(node.value, this);
+      const structValue = visitorsCore.visit(node.value, this);
       return {
         imports: structValue.imports,
         render: `${node.name}: ${structValue.render}`
       };
     },
     visitStructValue(node) {
-      const struct = node.fields.map((field) => (0, import_visitors_core.visit)(field, this));
+      const struct = node.fields.map((field) => visitorsCore.visit(field, this));
       return {
         imports: new ImportMap().mergeWith(...struct.map((c) => c.imports)),
         render: `{ ${struct.map((c) => c.render).join(", ")} }`
       };
     },
     visitTupleValue(node) {
-      const tuple = node.items.map((v) => (0, import_visitors_core.visit)(v, this));
+      const tuple = node.items.map((v) => visitorsCore.visit(v, this));
       return {
         imports: new ImportMap().mergeWith(...tuple.map((c) => c.imports)),
         render: `(${tuple.map((c) => c.render).join(", ")})`
@@ -299,31 +510,28 @@ function getDiscriminatorConstant(discriminatorNode, scope) {
 }
 function getConstantDiscriminatorConstant(discriminatorNode, scope) {
   const { discriminatorNodes, getImportFrom, prefix, typeManifestVisitor } = scope;
-  const index = discriminatorNodes.filter((0, import_nodes2.isNodeFilter)("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const index = discriminatorNodes.filter(nodes.isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = (0, import_nodes2.camelCase)(`${prefix}_discriminator${suffix}`);
-  const typeManifest = (0, import_visitors_core2.visit)(discriminatorNode.constant.type, typeManifestVisitor);
+  const name = nodes.camelCase(`${prefix}_discriminator${suffix}`);
+  const typeManifest = visitorsCore.visit(discriminatorNode.constant.type, typeManifestVisitor);
   const value = renderValueNode(discriminatorNode.constant.value, getImportFrom);
   return getConstant(name, typeManifest, value);
 }
 function getFieldDiscriminatorConstant(discriminatorNode, scope) {
   const { fields, prefix, getImportFrom, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !(0, import_nodes2.isNode)(field.defaultValue, import_nodes2.VALUE_NODES)) {
+  if (!field || !field.defaultValue || !nodes.isNode(field.defaultValue, nodes.VALUE_NODES)) {
     return null;
   }
-  const name = (0, import_nodes2.camelCase)(`${prefix}_${discriminatorNode.name}`);
-  const typeManifest = (0, import_visitors_core2.visit)(field.type, typeManifestVisitor);
+  const name = nodes.camelCase(`${prefix}_${discriminatorNode.name}`);
+  const typeManifest = visitorsCore.visit(field.type, typeManifestVisitor);
   const value = renderValueNode(field.defaultValue, getImportFrom);
   return getConstant(name, typeManifest, value);
 }
 function getConstant(name, typeManifest, value) {
   const type = { imports: typeManifest.imports, render: typeManifest.type };
-  return mergeFragments([type, value], ([t, v]) => `pub const ${(0, import_nodes2.snakeCase)(name).toUpperCase()}: ${t} = ${v};`);
+  return mergeFragments([type, value], ([t, v]) => `pub const ${nodes.snakeCase(name).toUpperCase()}: ${t} = ${v};`);
 }
-
-// src/utils/linkOverrides.ts
-var import_errors = require("@codama/errors");
 function getImportFromFactory(overrides) {
   const linkOverrides = {
     accounts: overrides.accounts ?? {},
@@ -349,7 +557,7 @@ function getImportFromFactory(overrides) {
       case "resolverValueNode":
         return linkOverrides.resolvers[node.name] ?? "hooked";
       default:
-        throw new import_errors.CodamaError(import_errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
           expectedKinds: [
             "AccountLinkNode",
             "DefinedTypeLinkNode",
@@ -364,12 +572,6 @@ function getImportFromFactory(overrides) {
     }
   };
 }
-
-// src/utils/render.ts
-var import_node_path = require("path");
-var import_node_url = require("url");
-var import_nodes3 = require("@codama/nodes");
-var import_nunjucks = __toESM(require("nunjucks"));
 function rustDocblock(docs) {
   if (docs.length <= 0) return "";
   const lines = docs.map((doc) => `/// ${doc}`);
@@ -377,14 +579,14 @@ function rustDocblock(docs) {
 `;
 }
 var render = (template, context, options) => {
-  const dirname = false ? pathDirname(fileURLToPath(import_meta.url)) : __dirname;
-  const templates = false ? (0, import_node_path.join)(dirname, "..", "..", "public", "templates") : (0, import_node_path.join)(dirname, "templates");
-  const env = import_nunjucks.default.configure(templates, { autoescape: false, trimBlocks: true, ...options });
-  env.addFilter("pascalCase", import_nodes3.pascalCase);
-  env.addFilter("camelCase", import_nodes3.camelCase);
-  env.addFilter("snakeCase", import_nodes3.snakeCase);
-  env.addFilter("kebabCase", import_nodes3.kebabCase);
-  env.addFilter("titleCase", import_nodes3.titleCase);
+  const dirname = __dirname;
+  const templates = path.join(dirname, "templates");
+  const env = nunjucks__default.default.configure(templates, { autoescape: false, trimBlocks: true, ...options });
+  env.addFilter("pascalCase", nodes.pascalCase);
+  env.addFilter("camelCase", nodes.camelCase);
+  env.addFilter("snakeCase", nodes.snakeCase);
+  env.addFilter("kebabCase", nodes.kebabCase);
+  env.addFilter("titleCase", nodes.titleCase);
   env.addFilter("rustDocblock", rustDocblock);
   env.addFilter("hasTrait", (traits, ...traitNames) => {
     if (typeof traits !== "string") return false;
@@ -392,9 +594,6 @@ var render = (template, context, options) => {
   });
   return env.render(template, context);
 };
-
-// src/utils/traitOptions.ts
-var import_nodes4 = require("@codama/nodes");
 var DEFAULT_TRAIT_OPTIONS = {
   baseDefaults: [
     "borsh::BorshSerialize",
@@ -417,14 +616,14 @@ function getTraitsFromNodeFactory(options = {}) {
   return (node) => getTraitsFromNode(node, options);
 }
 function getTraitsFromNode(node, userOptions = {}) {
-  (0, import_nodes4.assertIsNode)(node, ["accountNode", "definedTypeNode", "instructionNode"]);
+  nodes.assertIsNode(node, ["accountNode", "definedTypeNode", "instructionNode"]);
   const options = { ...DEFAULT_TRAIT_OPTIONS, ...userOptions };
   const nodeType = getNodeType(node);
   if (nodeType === "alias") {
     return { imports: new ImportMap(), render: "" };
   }
   const sanitizedOverrides = Object.fromEntries(
-    Object.entries(options.overrides).map(([key, value]) => [(0, import_nodes4.camelCase)(key), value])
+    Object.entries(options.overrides).map(([key, value]) => [nodes.camelCase(key), value])
   );
   const nodeOverrides = sanitizedOverrides[node.name];
   const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
@@ -446,10 +645,10 @@ function getTraitsFromNode(node, userOptions = {}) {
   return { imports, render: traitLines.join("") };
 }
 function getNodeType(node) {
-  if ((0, import_nodes4.isNode)(node, ["accountNode", "instructionNode"])) return "struct";
-  if ((0, import_nodes4.isNode)(node.type, "structTypeNode")) return "struct";
-  if ((0, import_nodes4.isNode)(node.type, "enumTypeNode")) {
-    return (0, import_nodes4.isScalarEnum)(node.type) ? "scalarEnum" : "dataEnum";
+  if (nodes.isNode(node, ["accountNode", "instructionNode"])) return "struct";
+  if (nodes.isNode(node.type, "structTypeNode")) return "struct";
+  if (nodes.isNode(node.type, "enumTypeNode")) {
+    return nodes.isScalarEnum(node.type) ? "scalarEnum" : "dataEnum";
   }
   return "alias";
 }
@@ -495,14 +694,14 @@ function extractFullyQualifiedNames(traits, imports) {
   });
 }
 function getSerdeFieldAttribute(serdeWith, node, userOptions = {}) {
-  (0, import_nodes4.assertIsNode)(node, ["accountNode", "definedTypeNode", "instructionNode"]);
+  nodes.assertIsNode(node, ["accountNode", "definedTypeNode", "instructionNode"]);
   const options = { ...DEFAULT_TRAIT_OPTIONS, ...userOptions };
   const nodeType = getNodeType(node);
   if (nodeType === "alias") {
     return "";
   }
   const sanitizedOverrides = Object.fromEntries(
-    Object.entries(options.overrides).map(([key, value]) => [(0, import_nodes4.camelCase)(key), value])
+    Object.entries(options.overrides).map(([key, value]) => [nodes.camelCase(key), value])
   );
   const nodeOverrides = sanitizedOverrides[node.name];
   const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
@@ -539,20 +738,20 @@ function getTypeManifestVisitor(options) {
   let inlineStruct = false;
   let parentSize = null;
   let parentNode = null;
-  return (0, import_visitors_core3.pipe)(
-    (0, import_visitors_core3.mergeVisitor)(
+  return visitorsCore.pipe(
+    visitorsCore.mergeVisitor(
       () => ({ imports: new ImportMap(), nestedStructs: [], type: "" }),
       (_, values) => ({
         ...mergeManifests(values),
         type: values.map((v) => v.type).join("\n")
       }),
-      { keys: [...import_nodes5.REGISTERED_TYPE_NODE_KINDS, "definedTypeLinkNode", "definedTypeNode", "accountNode"] }
+      { keys: [...nodes.REGISTERED_TYPE_NODE_KINDS, "definedTypeLinkNode", "definedTypeNode", "accountNode"] }
     ),
-    (v) => (0, import_visitors_core3.extendVisitor)(v, {
+    (v) => visitorsCore.extendVisitor(v, {
       visitAccount(account, { self }) {
-        parentName = (0, import_nodes5.pascalCase)(account.name);
+        parentName = nodes.pascalCase(account.name);
         parentNode = account;
-        const manifest = (0, import_visitors_core3.visit)(account.data, self);
+        const manifest = visitorsCore.visit(account.data, self);
         const traits = getTraitsFromNode2(account);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
@@ -563,21 +762,21 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = (0, import_visitors_core3.visit)(arrayType.item, self);
-        if ((0, import_nodes5.isNode)(arrayType.count, "fixedCountNode")) {
+        const childManifest = visitorsCore.visit(arrayType.item, self);
+        if (nodes.isNode(arrayType.count, "fixedCountNode")) {
           return {
             ...childManifest,
             type: `[${childManifest.type}; ${arrayType.count.value}]`
           };
         }
-        if ((0, import_nodes5.isNode)(arrayType.count, "remainderCountNode")) {
+        if (nodes.isNode(arrayType.count, "remainderCountNode")) {
           childManifest.imports.add("kaigan::types::RemainderVec");
           return {
             ...childManifest,
             type: `RemainderVec<${childManifest.type}>`
           };
         }
-        const prefix = (0, import_nodes5.resolveNestedTypeNode)(arrayType.count.prefix);
+        const prefix = nodes.resolveNestedTypeNode(arrayType.count.prefix);
         if (prefix.endian === "le") {
           switch (prefix.format) {
             case "u32":
@@ -609,7 +808,7 @@ function getTypeManifestVisitor(options) {
         throw new Error("Array size not supported by Borsh");
       },
       visitBooleanType(booleanType) {
-        const resolvedSize = (0, import_nodes5.resolveNestedTypeNode)(booleanType.size);
+        const resolvedSize = nodes.resolveNestedTypeNode(booleanType.size);
         if (resolvedSize.format === "u8" && resolvedSize.endian === "le") {
           return {
             imports: new ImportMap(),
@@ -620,28 +819,28 @@ function getTypeManifestVisitor(options) {
         throw new Error("Bool size not supported by Borsh");
       },
       visitBytesType(_bytesType, { self }) {
-        let arraySize = (0, import_nodes5.remainderCountNode)();
+        let arraySize = nodes.remainderCountNode();
         if (typeof parentSize === "number") {
-          arraySize = (0, import_nodes5.fixedCountNode)(parentSize);
+          arraySize = nodes.fixedCountNode(parentSize);
         } else if (parentSize && typeof parentSize === "object") {
-          arraySize = (0, import_nodes5.prefixedCountNode)(parentSize);
+          arraySize = nodes.prefixedCountNode(parentSize);
         }
-        const arrayType = (0, import_nodes5.arrayTypeNode)((0, import_nodes5.numberTypeNode)("u8"), arraySize);
-        return (0, import_visitors_core3.visit)(arrayType, self);
+        const arrayType = nodes.arrayTypeNode(nodes.numberTypeNode("u8"), arraySize);
+        return visitorsCore.visit(arrayType, self);
       },
       visitDefinedType(definedType, { self }) {
-        parentName = (0, import_nodes5.pascalCase)(definedType.name);
+        parentName = nodes.pascalCase(definedType.name);
         parentNode = definedType;
-        const manifest = (0, import_visitors_core3.visit)(definedType.type, self);
+        const manifest = visitorsCore.visit(definedType.type, self);
         const traits = getTraitsFromNode2(definedType);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
         parentNode = null;
-        const renderedType = (0, import_nodes5.isNode)(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${(0, import_nodes5.pascalCase)(definedType.name)} = ${manifest.type};`;
+        const renderedType = nodes.isNode(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${nodes.pascalCase(definedType.name)} = ${manifest.type};`;
         return { ...manifest, type: `${traits.render}${renderedType}` };
       },
       visitDefinedTypeLink(node) {
-        const pascalCaseDefinedType = (0, import_nodes5.pascalCase)(node.name);
+        const pascalCaseDefinedType = nodes.pascalCase(node.name);
         const importFrom = getImportFrom(node);
         return {
           imports: new ImportMap().add(`${importFrom}::${pascalCaseDefinedType}`),
@@ -650,7 +849,7 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const name = (0, import_nodes5.pascalCase)(enumEmptyVariantType.name);
+        const name = nodes.pascalCase(enumEmptyVariantType.name);
         return {
           imports: new ImportMap(),
           nestedStructs: [],
@@ -658,14 +857,14 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumStructVariantType(enumStructVariantType, { self }) {
-        const name = (0, import_nodes5.pascalCase)(enumStructVariantType.name);
+        const name = nodes.pascalCase(enumStructVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
         inlineStruct = true;
-        parentName = (0, import_nodes5.pascalCase)(originalParentName) + name;
-        const typeManifest = (0, import_visitors_core3.visit)(enumStructVariantType.struct, self);
+        parentName = nodes.pascalCase(originalParentName) + name;
+        const typeManifest = visitorsCore.visit(enumStructVariantType.struct, self);
         inlineStruct = false;
         parentName = originalParentName;
         return {
@@ -674,13 +873,13 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
-        const name = (0, import_nodes5.pascalCase)(enumTupleVariantType.name);
+        const name = nodes.pascalCase(enumTupleVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
-        parentName = (0, import_nodes5.pascalCase)(originalParentName) + name;
-        const childManifest = (0, import_visitors_core3.visit)(enumTupleVariantType.tuple, self);
+        parentName = nodes.pascalCase(originalParentName) + name;
+        const childManifest = visitorsCore.visit(enumTupleVariantType.tuple, self);
         parentName = originalParentName;
         let derive = "";
         if (parentNode && childManifest.type === "(Pubkey)") {
@@ -706,25 +905,25 @@ function getTypeManifestVisitor(options) {
         if (!originalParentName) {
           throw new Error("Enum type must have a parent name.");
         }
-        const variants = enumType.variants.map((variant) => (0, import_visitors_core3.visit)(variant, self));
+        const variants = enumType.variants.map((variant) => visitorsCore.visit(variant, self));
         const variantNames = variants.map((variant) => variant.type).join("\n");
         const mergedManifest = mergeManifests(variants);
         return {
           ...mergedManifest,
-          type: `pub enum ${(0, import_nodes5.pascalCase)(originalParentName)} {
+          type: `pub enum ${nodes.pascalCase(originalParentName)} {
 ${variantNames}
 }`
         };
       },
       visitFixedSizeType(fixedSizeType, { self }) {
         parentSize = fixedSizeType.size;
-        const manifest = (0, import_visitors_core3.visit)(fixedSizeType.type, self);
+        const manifest = visitorsCore.visit(fixedSizeType.type, self);
         parentSize = null;
         return manifest;
       },
       visitMapType(mapType, { self }) {
-        const key = (0, import_visitors_core3.visit)(mapType.key, self);
-        const value = (0, import_visitors_core3.visit)(mapType.value, self);
+        const key = visitorsCore.visit(mapType.key, self);
+        const value = visitorsCore.visit(mapType.value, self);
         const mergedManifest = mergeManifests([key, value]);
         mergedManifest.imports.add("std::collections::HashMap");
         return {
@@ -750,8 +949,8 @@ ${variantNames}
         };
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = (0, import_visitors_core3.visit)(optionType.item, self);
-        const optionPrefix = (0, import_nodes5.resolveNestedTypeNode)(optionType.prefix);
+        const childManifest = visitorsCore.visit(optionType.item, self);
+        const optionPrefix = nodes.resolveNestedTypeNode(optionType.prefix);
         if (optionPrefix.format === "u8" && optionPrefix.endian === "le") {
           return {
             ...childManifest,
@@ -768,10 +967,10 @@ ${variantNames}
         };
       },
       visitRemainderOptionType(node) {
-        throw new import_errors2.CodamaError(import_errors2.CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+        throw new errors.CodamaError(errors.CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       },
       visitSetType(setType, { self }) {
-        const childManifest = (0, import_visitors_core3.visit)(setType.item, self);
+        const childManifest = visitorsCore.visit(setType.item, self);
         childManifest.imports.add("std::collections::HashSet");
         return {
           ...childManifest,
@@ -779,8 +978,8 @@ ${variantNames}
         };
       },
       visitSizePrefixType(sizePrefixType, { self }) {
-        parentSize = (0, import_nodes5.resolveNestedTypeNode)(sizePrefixType.prefix);
-        const manifest = (0, import_visitors_core3.visit)(sizePrefixType.type, self);
+        parentSize = nodes.resolveNestedTypeNode(sizePrefixType.prefix);
+        const manifest = visitorsCore.visit(sizePrefixType.type, self);
         parentSize = null;
         return manifest;
       },
@@ -799,7 +998,7 @@ ${variantNames}
             type: `[u8; ${parentSize}]`
           };
         }
-        if ((0, import_nodes5.isNode)(parentSize, "numberTypeNode") && parentSize.endian === "le") {
+        if (nodes.isNode(parentSize, "numberTypeNode") && parentSize.endian === "le") {
           switch (parentSize.format) {
             case "u32":
               return {
@@ -830,16 +1029,16 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct field type must have a parent name.");
         }
-        parentName = (0, import_nodes5.pascalCase)(originalParentName) + (0, import_nodes5.pascalCase)(structFieldType.name);
+        parentName = nodes.pascalCase(originalParentName) + nodes.pascalCase(structFieldType.name);
         nestedStruct = true;
         inlineStruct = false;
-        const fieldManifest = (0, import_visitors_core3.visit)(structFieldType.type, self);
+        const fieldManifest = visitorsCore.visit(structFieldType.type, self);
         parentName = originalParentName;
         inlineStruct = originalInlineStruct;
         nestedStruct = originalNestedStruct;
-        const fieldName = (0, import_nodes5.snakeCase)(structFieldType.name);
-        const docblock = rustDocblock((0, import_nodes5.parseDocs)(structFieldType.docs));
-        const resolvedNestedType = (0, import_nodes5.resolveNestedTypeNode)(structFieldType.type);
+        const fieldName = nodes.snakeCase(structFieldType.name);
+        const docblock = rustDocblock(nodes.parseDocs(structFieldType.docs));
+        const resolvedNestedType = nodes.resolveNestedTypeNode(structFieldType.type);
         let derive = "";
         if (parentNode) {
           if (fieldManifest.type === "Pubkey") {
@@ -854,9 +1053,9 @@ ${variantNames}
               parentNode,
               traitOptions
             );
-          } else if ((0, import_nodes5.isNode)(resolvedNestedType, "arrayTypeNode") && (0, import_nodes5.isNode)(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
+          } else if (nodes.isNode(resolvedNestedType, "arrayTypeNode") && nodes.isNode(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
             derive = getSerdeFieldAttribute("serde_big_array::BigArray", parentNode, traitOptions);
-          } else if ((0, import_nodes5.isNode)(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && (0, import_nodes5.isNode)(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+          } else if (nodes.isNode(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && nodes.isNode(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
             derive = getSerdeFieldAttribute(
               "serde_with::As::<serde_with::Bytes>",
               parentNode,
@@ -874,23 +1073,23 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct type must have a parent name.");
         }
-        const fields = structType.fields.map((field) => (0, import_visitors_core3.visit)(field, self));
+        const fields = structType.fields.map((field) => visitorsCore.visit(field, self));
         const fieldTypes = fields.map((field) => field.type).join("\n");
         const mergedManifest = mergeManifests(fields);
         if (nestedStruct) {
           const nestedTraits = getTraitsFromNode2(
-            (0, import_nodes5.definedTypeNode)({ name: originalParentName, type: structType })
+            nodes.definedTypeNode({ name: originalParentName, type: structType })
           );
           mergedManifest.imports.mergeWith(nestedTraits.imports);
           return {
             ...mergedManifest,
             nestedStructs: [
               ...mergedManifest.nestedStructs,
-              `${nestedTraits.render}pub struct ${(0, import_nodes5.pascalCase)(originalParentName)} {
+              `${nestedTraits.render}pub struct ${nodes.pascalCase(originalParentName)} {
 ${fieldTypes}
 }`
             ],
-            type: (0, import_nodes5.pascalCase)(originalParentName)
+            type: nodes.pascalCase(originalParentName)
           };
         }
         if (inlineStruct) {
@@ -900,13 +1099,13 @@ ${fieldTypes}
         }
         return {
           ...mergedManifest,
-          type: `pub struct ${(0, import_nodes5.pascalCase)(originalParentName)} {
+          type: `pub struct ${nodes.pascalCase(originalParentName)} {
 ${fieldTypes}
 }`
         };
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => (0, import_visitors_core3.visit)(item, self));
+        const items = tupleType.items.map((item) => visitorsCore.visit(item, self));
         const mergedManifest = mergeManifests(items);
         return {
           ...mergedManifest,
@@ -914,7 +1113,7 @@ ${fieldTypes}
         };
       },
       visitZeroableOptionType(node) {
-        throw new import_errors2.CodamaError(import_errors2.CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+        throw new errors.CodamaError(errors.CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       }
     })
   );
@@ -928,8 +1127,8 @@ function mergeManifests(manifests) {
 
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
-  const linkables = new import_visitors_core4.LinkableDictionary();
-  const stack = new import_visitors_core4.NodeStack();
+  const linkables = new visitorsCore.LinkableDictionary();
+  const stack = new visitorsCore.NodeStack();
   let program = null;
   const renderParentInstructions = options.renderParentInstructions ?? false;
   const dependencyMap = options.dependencyMap ?? {};
@@ -941,14 +1140,14 @@ function getRenderMapVisitor(options = {}) {
     traitOptions: options.traitOptions
   });
   const anchorTraits = options.anchorTraits ?? true;
-  return (0, import_visitors_core4.pipe)(
-    (0, import_visitors_core4.staticVisitor)(() => (0, import_renderers_core.createRenderMap)(), {
+  return visitorsCore.pipe(
+    visitorsCore.staticVisitor(() => renderersCore.createRenderMap(), {
       keys: ["rootNode", "programNode", "instructionNode", "accountNode", "definedTypeNode"]
     }),
-    (v) => (0, import_visitors_core4.extendVisitor)(v, {
+    (v) => visitorsCore.extendVisitor(v, {
       visitAccount(node) {
-        const typeManifest = (0, import_visitors_core4.visit)(node, typeManifestVisitor);
-        const fields = (0, import_nodes6.resolveNestedTypeNode)(node.data).fields;
+        const typeManifest = visitorsCore.visit(node, typeManifestVisitor);
+        const fields = nodes.resolveNestedTypeNode(node.data).fields;
         const discriminatorConstants = getDiscriminatorConstants({
           discriminatorNodes: node.discriminators ?? [],
           fields,
@@ -960,58 +1159,57 @@ function getRenderMapVisitor(options = {}) {
         const pda = node.pda ? linkables.get([...stack.getPath(), node.pda]) : void 0;
         const pdaSeeds = pda?.seeds ?? [];
         const seeds = pdaSeeds.map((seed) => {
-          if ((0, import_nodes6.isNode)(seed, "variablePdaSeedNode")) {
-            const seedManifest2 = (0, import_visitors_core4.visit)(seed.type, typeManifestVisitor);
+          if (nodes.isNode(seed, "variablePdaSeedNode")) {
+            const seedManifest2 = visitorsCore.visit(seed.type, typeManifestVisitor);
             seedsImports.mergeWith(seedManifest2.imports);
-            const resolvedType2 = (0, import_nodes6.resolveNestedTypeNode)(seed.type);
+            const resolvedType2 = nodes.resolveNestedTypeNode(seed.type);
             return { ...seed, resolvedType: resolvedType2, typeManifest: seedManifest2 };
           }
-          if ((0, import_nodes6.isNode)(seed.value, "programIdValueNode")) {
+          if (nodes.isNode(seed.value, "programIdValueNode")) {
             return seed;
           }
-          const seedManifest = (0, import_visitors_core4.visit)(seed.type, typeManifestVisitor);
+          const seedManifest = visitorsCore.visit(seed.type, typeManifestVisitor);
           const valueManifest = renderValueNode(seed.value, getImportFrom, true);
           seedsImports.mergeWith(valueManifest.imports);
-          const resolvedType = (0, import_nodes6.resolveNestedTypeNode)(seed.type);
+          const resolvedType = nodes.resolveNestedTypeNode(seed.type);
           return { ...seed, resolvedType, typeManifest: seedManifest, valueManifest };
         });
-        const hasVariableSeeds = pdaSeeds.filter((0, import_nodes6.isNodeFilter)("variablePdaSeedNode")).length > 0;
-        const constantSeeds = seeds.filter((0, import_nodes6.isNodeFilter)("constantPdaSeedNode")).filter((seed) => !(0, import_nodes6.isNode)(seed.value, "programIdValueNode"));
-        const { imports } = typeManifest;
-        if (hasVariableSeeds) {
-          imports.mergeWith(seedsImports);
-        }
-        return (0, import_renderers_core.createRenderMap)(`accounts/${(0, import_nodes6.snakeCase)(node.name)}.rs`, {
+        const hasVariableSeeds = pdaSeeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length > 0;
+        const constantSeeds = seeds.filter(nodes.isNodeFilter("constantPdaSeedNode")).filter((seed) => !nodes.isNode(seed.value, "programIdValueNode"));
+        const imports = typeManifest.imports.mergeWith(...hasVariableSeeds ? [seedsImports] : []).mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${nodes.pascalCase(node.name)}`);
+        return renderersCore.createRenderMap(`accounts/${nodes.snakeCase(node.name)}.rs`, {
           content: render("accountsPage.njk", {
             account: node,
             anchorTraits,
             constantSeeds,
             discriminatorConstants: discriminatorConstants.render,
             hasVariableSeeds,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${(0, import_nodes6.pascalCase)(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             pda,
             program,
             seeds,
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitDefinedType(node) {
-        const typeManifest = (0, import_visitors_core4.visit)(node, typeManifestVisitor);
-        const imports = new ImportMap().mergeWithManifest(typeManifest);
-        return (0, import_renderers_core.createRenderMap)(`types/${(0, import_nodes6.snakeCase)(node.name)}.rs`, {
+        const typeManifest = visitorsCore.visit(node, typeManifestVisitor);
+        const imports = new ImportMap().mergeWithManifest(typeManifest).remove(`generatedTypes::${nodes.pascalCase(node.name)}`);
+        return renderersCore.createRenderMap(`types/${nodes.snakeCase(node.name)}.rs`, {
           content: render("definedTypesPage.njk", {
             definedType: node,
-            imports: imports.remove(`generatedTypes::${(0, import_nodes6.pascalCase)(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitInstruction(node) {
         const imports = new ImportMap();
         const accountsAndArgsConflicts = getConflictsForInstructionAccountsAndArgs(node);
         if (accountsAndArgsConflicts.length > 0) {
-          (0, import_errors3.logWarn)(
+          errors.logWarn(
             `[Rust] Accounts and args of instruction [${node.name}] have the following conflicting attributes [${accountsAndArgsConflicts.join(", ")}]. Thus, the conflicting arguments will be suffixed with "_arg". You may want to rename the conflicting attributes.`
           );
         }
@@ -1030,12 +1228,12 @@ function getRenderMapVisitor(options = {}) {
             getImportFrom,
             getTraitsFromNode: getTraitsFromNode2,
             nestedStruct: true,
-            parentName: `${(0, import_nodes6.pascalCase)(node.name)}InstructionData`
+            parentName: `${nodes.pascalCase(node.name)}InstructionData`
           });
-          const manifest = (0, import_visitors_core4.visit)(argument.type, argumentVisitor);
+          const manifest = visitorsCore.visit(argument.type, argumentVisitor);
           imports.mergeWith(manifest.imports);
-          const innerOptionType = (0, import_nodes6.isNode)(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
-          const hasDefaultValue = !!argument.defaultValue && (0, import_nodes6.isNode)(argument.defaultValue, import_nodes6.VALUE_NODES);
+          const innerOptionType = nodes.isNode(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
+          const hasDefaultValue = !!argument.defaultValue && nodes.isNode(argument.defaultValue, nodes.VALUE_NODES);
           let renderValue = null;
           if (hasDefaultValue) {
             const { imports: argImports, render: value } = renderValueNode(
@@ -1057,57 +1255,59 @@ function getRenderMapVisitor(options = {}) {
             value: renderValue
           });
         });
-        const struct = (0, import_nodes6.structTypeNodeFromInstructionArgumentNodes)(node.arguments);
+        const struct = nodes.structTypeNodeFromInstructionArgumentNodes(node.arguments);
         const structVisitor = getTypeManifestVisitor({
           getImportFrom,
           getTraitsFromNode: getTraitsFromNode2,
-          parentName: `${(0, import_nodes6.pascalCase)(node.name)}InstructionData`
+          parentName: `${nodes.pascalCase(node.name)}InstructionData`
         });
-        const typeManifest = (0, import_visitors_core4.visit)(struct, structVisitor);
+        const typeManifest = visitorsCore.visit(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
-        imports.mergeWith(dataTraits.imports);
-        return (0, import_renderers_core.createRenderMap)(`instructions/${(0, import_nodes6.snakeCase)(node.name)}.rs`, {
+        imports.mergeWith(dataTraits.imports).mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${nodes.pascalCase(node.name)}`);
+        return renderersCore.createRenderMap(`instructions/${nodes.snakeCase(node.name)}.rs`, {
           content: render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
             discriminatorConstants: discriminatorConstants.render,
             hasArgs,
             hasOptional,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${(0, import_nodes6.pascalCase)(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             instruction: node,
             instructionArgs,
             program,
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitProgram(node, { self }) {
         program = node;
-        let renders = (0, import_renderers_core.mergeRenderMaps)([
-          ...node.accounts.map((account) => (0, import_visitors_core4.visit)(account, self)),
-          ...node.definedTypes.map((type) => (0, import_visitors_core4.visit)(type, self)),
-          ...(0, import_nodes6.getAllInstructionsWithSubs)(node, {
+        let renders = renderersCore.mergeRenderMaps([
+          ...node.accounts.map((account) => visitorsCore.visit(account, self)),
+          ...node.definedTypes.map((type) => visitorsCore.visit(type, self)),
+          ...nodes.getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => (0, import_visitors_core4.visit)(ix, self))
+          }).map((ix) => visitorsCore.visit(ix, self))
         ]);
         if (node.errors.length > 0) {
-          renders = (0, import_renderers_core.addToRenderMap)(renders, `errors/${(0, import_nodes6.snakeCase)(node.name)}.rs`, {
+          renders = renderersCore.addToRenderMap(renders, `errors/${nodes.snakeCase(node.name)}.rs`, {
             content: render("errorsPage.njk", {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
               program: node
-            })
+            }),
+            imports: new ImportMap()
           });
         }
         program = null;
         return renders;
       },
       visitRoot(node, { self }) {
-        const programsToExport = (0, import_nodes6.getAllPrograms)(node);
-        const accountsToExport = (0, import_nodes6.getAllAccounts)(node);
-        const instructionsToExport = (0, import_nodes6.getAllInstructionsWithSubs)(node, {
+        const programsToExport = nodes.getAllPrograms(node);
+        const accountsToExport = nodes.getAllAccounts(node);
+        const instructionsToExport = nodes.getAllInstructionsWithSubs(node, {
           leavesOnly: !renderParentInstructions
         });
-        const definedTypesToExport = (0, import_nodes6.getAllDefinedTypes)(node);
+        const definedTypesToExport = nodes.getAllDefinedTypes(node);
         const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const ctx = {
           accountsToExport,
@@ -1117,22 +1317,22 @@ function getRenderMapVisitor(options = {}) {
           programsToExport,
           root: node
         };
-        return (0, import_renderers_core.mergeRenderMaps)([
-          (0, import_renderers_core.createRenderMap)({
-            ["accounts/mod.rs"]: accountsToExport.length > 0 ? { content: render("accountsMod.njk", ctx) } : void 0,
-            ["errors/mod.rs"]: programsToExport.length > 0 ? { content: render("errorsMod.njk", ctx) } : void 0,
-            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? { content: render("instructionsMod.njk", ctx) } : void 0,
-            ["mod.rs"]: { content: render("rootMod.njk", ctx) },
-            ["programs.rs"]: programsToExport.length > 0 ? { content: render("programsMod.njk", ctx) } : void 0,
-            ["shared.rs"]: accountsToExport.length > 0 ? { content: render("sharedPage.njk", ctx) } : void 0,
-            ["types/mod.rs"]: definedTypesToExport.length > 0 ? { content: render("definedTypesMod.njk", ctx) } : void 0
+        return renderersCore.mergeRenderMaps([
+          renderersCore.createRenderMap({
+            ["accounts/mod.rs"]: accountsToExport.length > 0 ? { content: render("accountsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["errors/mod.rs"]: programsToExport.length > 0 ? { content: render("errorsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? { content: render("instructionsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["mod.rs"]: { content: render("rootMod.njk", ctx), imports: new ImportMap() },
+            ["programs.rs"]: programsToExport.length > 0 ? { content: render("programsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["shared.rs"]: accountsToExport.length > 0 ? { content: render("sharedPage.njk", ctx), imports: new ImportMap() } : void 0,
+            ["types/mod.rs"]: definedTypesToExport.length > 0 ? { content: render("definedTypesMod.njk", ctx), imports: new ImportMap() } : void 0
           }),
-          ...(0, import_nodes6.getAllPrograms)(node).map((p) => (0, import_visitors_core4.visit)(p, self))
+          ...nodes.getAllPrograms(node).map((p) => visitorsCore.visit(p, self))
         ]);
       }
     }),
-    (v) => (0, import_visitors_core4.recordNodeStackVisitor)(v, stack),
-    (v) => (0, import_visitors_core4.recordLinkablesOnFirstVisitVisitor)(v, linkables)
+    (v) => visitorsCore.recordNodeStackVisitor(v, stack),
+    (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
 function getConflictsForInstructionAccountsAndArgs(instruction) {
@@ -1143,51 +1343,43 @@ function getConflictsForInstructionAccountsAndArgs(instruction) {
   const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
   return [...new Set(duplicates)];
 }
-
-// src/renderVisitor.ts
-var import_errors4 = require("@codama/errors");
-var import_renderers_core2 = require("@codama/renderers-core");
-var import_visitors_core5 = require("@codama/visitors-core");
-var import_child_process = require("child_process");
-function renderVisitor(path, options = {}) {
-  return (0, import_visitors_core5.rootNodeVisitor)((root) => {
+function renderVisitor(crateFolder, options = {}) {
+  return visitorsCore.rootNodeVisitor((root) => {
+    const generatedFolder = renderersCore.joinPath(crateFolder, options.generatedFolder ?? "src/generated");
     if (options.deleteFolderBeforeRendering ?? true) {
-      (0, import_renderers_core2.deleteDirectory)(path);
+      renderersCore.deleteDirectory(generatedFolder);
     }
-    (0, import_visitors_core5.visit)(root, (0, import_renderers_core2.writeRenderMapVisitor)(getRenderMapVisitor(options), path));
+    const renderMap = visitorsCore.visit(root, getRenderMapVisitor(options));
+    renderersCore.writeRenderMap(renderMap, generatedFolder);
+    syncCargoToml(renderMap, crateFolder, options);
     if (options.formatCode) {
-      if (options.crateFolder) {
-        const removeFalsy = (arg) => Boolean(arg);
-        runFormatter(
-          "cargo",
-          [options.toolchain, "fmt", "--manifest-path", `${options.crateFolder}/Cargo.toml`].filter(
-            removeFalsy
-          )
-        );
-      } else {
-        (0, import_errors4.logWarn)("No crate folder specified, skipping formatting.");
-      }
+      const removeFalsy = (arg) => Boolean(arg);
+      runFormatter(
+        "cargo",
+        [options.toolchain, "fmt", "--manifest-path", `${crateFolder}/Cargo.toml`].filter(removeFalsy)
+      );
     }
   });
 }
 function runFormatter(cmd, args) {
-  const { stdout, stderr, error } = (0, import_child_process.spawnSync)(cmd, args);
+  const { stdout, stderr, error } = child_process.spawnSync(cmd, args);
   if (error?.message?.includes("ENOENT")) {
-    (0, import_errors4.logWarn)(`Could not find ${cmd}, skipping formatting.`);
+    errors.logWarn(`Could not find ${cmd}, skipping formatting.`);
     return;
   }
   if (stdout.length > 0) {
-    (0, import_errors4.logWarn)(`(cargo-fmt) ${stdout ? stdout?.toString() : error}`);
+    errors.logWarn(`(cargo-fmt) ${stdout ? stdout?.toString() : error}`);
   }
   if (stderr.length > 0) {
-    (0, import_errors4.logError)(`(cargo-fmt) ${stderr ? stderr.toString() : error}`);
+    errors.logError(`(cargo-fmt) ${stderr ? stderr.toString() : error}`);
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ImportMap,
-  getRenderMapVisitor,
-  getTypeManifestVisitor,
-  renderVisitor
-});
+
+exports.ImportMap = ImportMap;
+exports.RUST_CORE_IMPORTS = RUST_CORE_IMPORTS;
+exports.default = renderVisitor;
+exports.getRenderMapVisitor = getRenderMapVisitor;
+exports.getTypeManifestVisitor = getTypeManifestVisitor;
+exports.renderVisitor = renderVisitor;
+//# sourceMappingURL=index.node.cjs.map
 //# sourceMappingURL=index.node.cjs.map