@codama/renderers-rust 1.0.15 → 1.0.17

package/dist/index.node.mjs

@@ -1,13 +1,3 @@
-import { CodamaError, CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, logWarn, logError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
-import { REGISTERED_TYPE_NODE_KINDS, definedTypeNode, pascalCase, snakeCase, resolveNestedTypeNode, isNode, remainderCountNode, fixedCountNode, prefixedCountNode, arrayTypeNode, numberTypeNode, getAllPrograms, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, VALUE_NODES, structTypeNodeFromInstructionArgumentNodes, isNodeFilter, camelCase, kebabCase, titleCase, assertIsNode, bytesValueNode, numberValueNode, arrayValueNode, isScalarEnum } from '@codama/nodes';
-import { RenderMap, deleteDirectory, writeRenderMapVisitor } from '@codama/renderers-core';
-import { pipe, mergeVisitor, extendVisitor, visit, LinkableDictionary, NodeStack, staticVisitor, recordNodeStackVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor } from '@codama/visitors-core';
-import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder } from '@solana/codecs-strings';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import nunjucks from 'nunjucks';
-import { spawnSync } from 'child_process';
-
 // src/ImportMap.ts
 var DEFAULT_MODULE_MAP = {
   generated: "crate::generated",
@@ -78,6 +68,53 @@ var ImportMap = class _ImportMap {
     return importStatements.join("\n");
   }
 };
+
+// src/getRenderMapVisitor.ts
+import { logWarn } from "@codama/errors";
+import {
+  getAllAccounts,
+  getAllDefinedTypes,
+  getAllInstructionsWithSubs,
+  getAllPrograms,
+  isNode as isNode4,
+  isNodeFilter,
+  pascalCase as pascalCase4,
+  resolveNestedTypeNode as resolveNestedTypeNode2,
+  snakeCase as snakeCase3,
+  structTypeNodeFromInstructionArgumentNodes,
+  VALUE_NODES
+} from "@codama/nodes";
+import { RenderMap } from "@codama/renderers-core";
+import {
+  extendVisitor as extendVisitor2,
+  LinkableDictionary,
+  NodeStack,
+  pipe as pipe2,
+  recordLinkablesOnFirstVisitVisitor,
+  recordNodeStackVisitor,
+  staticVisitor,
+  visit as visit3
+} from "@codama/visitors-core";
+
+// src/getTypeManifestVisitor.ts
+import { CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, CodamaError as CodamaError2 } from "@codama/errors";
+import {
+  arrayTypeNode,
+  definedTypeNode,
+  fixedCountNode,
+  isNode as isNode2,
+  numberTypeNode,
+  pascalCase as pascalCase2,
+  prefixedCountNode,
+  REGISTERED_TYPE_NODE_KINDS,
+  remainderCountNode,
+  resolveNestedTypeNode,
+  snakeCase as snakeCase2
+} from "@codama/nodes";
+import { extendVisitor, mergeVisitor, pipe, visit } from "@codama/visitors-core";
+
+// src/utils/codecs.ts
+import { getBase16Encoder, getBase58Encoder, getBase64Encoder, getUtf8Encoder } from "@solana/codecs-strings";
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
@@ -91,6 +128,9 @@ function getBytesFromBytesValueNode(node) {
       return getBase64Encoder().encode(node.data);
   }
 }
+
+// src/utils/linkOverrides.ts
+import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
 function getImportFromFactory(overrides) {
   const linkOverrides = {
     accounts: overrides.accounts ?? {},
@@ -131,6 +171,12 @@ function getImportFromFactory(overrides) {
     }
   };
 }
+
+// src/utils/render.ts
+import { dirname as pathDirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { camelCase, kebabCase, pascalCase, snakeCase, titleCase } from "@codama/nodes";
+import nunjucks from "nunjucks";
 function rustDocblock(docs) {
   if (docs.length <= 0) return "";
   const lines = docs.map((doc) => `/// ${doc}`);
@@ -138,8 +184,8 @@ function rustDocblock(docs) {
 `;
 }
 var render = (template, context, options) => {
-  const dirname$1 = dirname(fileURLToPath(import.meta.url)) ;
-  const templates = join(dirname$1, "templates");
+  const dirname = true ? pathDirname(fileURLToPath(import.meta.url)) : __dirname;
+  const templates = false ? join(dirname, "..", "..", "public", "templates") : join(dirname, "templates");
   const env = nunjucks.configure(templates, { autoescape: false, trimBlocks: true, ...options });
   env.addFilter("pascalCase", pascalCase);
   env.addFilter("camelCase", camelCase);
@@ -149,6 +195,14 @@ var render = (template, context, options) => {
   env.addFilter("rustDocblock", rustDocblock);
   return env.render(template, context);
 };
+
+// src/utils/traitOptions.ts
+import {
+  assertIsNode,
+  camelCase as camelCase2,
+  isNode,
+  isScalarEnum
+} from "@codama/nodes";
 var DEFAULT_TRAIT_OPTIONS = {
   baseDefaults: [
     "borsh::BorshSerialize",
@@ -178,7 +232,7 @@ function getTraitsFromNode(node, userOptions = {}) {
     return { imports: new ImportMap(), render: "" };
   }
   const sanitizedOverrides = Object.fromEntries(
-    Object.entries(options.overrides).map(([key, value]) => [camelCase(key), value])
+    Object.entries(options.overrides).map(([key, value]) => [camelCase2(key), value])
   );
   const nodeOverrides = sanitizedOverrides[node.name];
   const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
@@ -267,7 +321,7 @@ function getTypeManifestVisitor(options) {
     ),
     (v) => extendVisitor(v, {
       visitAccount(account, { self }) {
-        parentName = pascalCase(account.name);
+        parentName = pascalCase2(account.name);
         const manifest = visit(account.data, self);
         const traits = getTraitsFromNode2(account);
         manifest.imports.mergeWith(traits.imports);
@@ -279,13 +333,13 @@ function getTypeManifestVisitor(options) {
       },
       visitArrayType(arrayType, { self }) {
         const childManifest = visit(arrayType.item, self);
-        if (isNode(arrayType.count, "fixedCountNode")) {
+        if (isNode2(arrayType.count, "fixedCountNode")) {
           return {
             ...childManifest,
             type: `[${childManifest.type}; ${arrayType.count.value}]`
           };
         }
-        if (isNode(arrayType.count, "remainderCountNode")) {
+        if (isNode2(arrayType.count, "remainderCountNode")) {
           childManifest.imports.add("kaigan::types::RemainderVec");
           return {
             ...childManifest,
@@ -345,16 +399,16 @@ function getTypeManifestVisitor(options) {
         return visit(arrayType, self);
       },
       visitDefinedType(definedType, { self }) {
-        parentName = pascalCase(definedType.name);
+        parentName = pascalCase2(definedType.name);
         const manifest = visit(definedType.type, self);
         const traits = getTraitsFromNode2(definedType);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
-        const renderedType = isNode(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase(definedType.name)} = ${manifest.type};`;
+        const renderedType = isNode2(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase2(definedType.name)} = ${manifest.type};`;
         return { ...manifest, type: `${traits.render}${renderedType}` };
       },
       visitDefinedTypeLink(node) {
-        const pascalCaseDefinedType = pascalCase(node.name);
+        const pascalCaseDefinedType = pascalCase2(node.name);
         const importFrom = getImportFrom(node);
         return {
           imports: new ImportMap().add(`${importFrom}::${pascalCaseDefinedType}`),
@@ -363,7 +417,7 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const name = pascalCase(enumEmptyVariantType.name);
+        const name = pascalCase2(enumEmptyVariantType.name);
         return {
           imports: new ImportMap(),
           nestedStructs: [],
@@ -371,13 +425,13 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumStructVariantType(enumStructVariantType, { self }) {
-        const name = pascalCase(enumStructVariantType.name);
+        const name = pascalCase2(enumStructVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
         inlineStruct = true;
-        parentName = pascalCase(originalParentName) + name;
+        parentName = pascalCase2(originalParentName) + name;
         const typeManifest = visit(enumStructVariantType.struct, self);
         inlineStruct = false;
         parentName = originalParentName;
@@ -387,12 +441,12 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
-        const name = pascalCase(enumTupleVariantType.name);
+        const name = pascalCase2(enumTupleVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
-        parentName = pascalCase(originalParentName) + name;
+        parentName = pascalCase2(originalParentName) + name;
         const childManifest = visit(enumTupleVariantType.tuple, self);
         parentName = originalParentName;
         let derive = "";
@@ -416,7 +470,7 @@ function getTypeManifestVisitor(options) {
         const mergedManifest = mergeManifests(variants);
         return {
           ...mergedManifest,
-          type: `pub enum ${pascalCase(originalParentName)} {
+          type: `pub enum ${pascalCase2(originalParentName)} {
 ${variantNames}
 }`
         };
@@ -473,7 +527,7 @@ ${variantNames}
         };
       },
       visitRemainderOptionType(node) {
-        throw new CodamaError(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+        throw new CodamaError2(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       },
       visitSetType(setType, { self }) {
         const childManifest = visit(setType.item, self);
@@ -504,7 +558,7 @@ ${variantNames}
             type: `[u8; ${parentSize}]`
           };
         }
-        if (isNode(parentSize, "numberTypeNode") && parentSize.endian === "le") {
+        if (isNode2(parentSize, "numberTypeNode") && parentSize.endian === "le") {
           switch (parentSize.format) {
             case "u32":
               return {
@@ -535,14 +589,14 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct field type must have a parent name.");
         }
-        parentName = pascalCase(originalParentName) + pascalCase(structFieldType.name);
+        parentName = pascalCase2(originalParentName) + pascalCase2(structFieldType.name);
         nestedStruct = true;
         inlineStruct = false;
         const fieldManifest = visit(structFieldType.type, self);
         parentName = originalParentName;
         inlineStruct = originalInlineStruct;
         nestedStruct = originalNestedStruct;
-        const fieldName = snakeCase(structFieldType.name);
+        const fieldName = snakeCase2(structFieldType.name);
         const docblock = rustDocblock(structFieldType.docs);
         const resolvedNestedType = resolveNestedTypeNode(structFieldType.type);
         let derive = "";
@@ -550,9 +604,9 @@ ${variantNames}
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]\n';
         } else if (fieldManifest.type === "Vec<Pubkey>") {
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<Vec<serde_with::DisplayFromStr>>"))]\n';
-        } else if (isNode(resolvedNestedType, "arrayTypeNode") && isNode(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
+        } else if (isNode2(resolvedNestedType, "arrayTypeNode") && isNode2(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]\n';
-        } else if (isNode(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+        } else if (isNode2(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode2(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::Bytes>"))]\n';
         }
         return {
@@ -577,11 +631,11 @@ ${variantNames}
             ...mergedManifest,
             nestedStructs: [
               ...mergedManifest.nestedStructs,
-              `${nestedTraits.render}pub struct ${pascalCase(originalParentName)} {
+              `${nestedTraits.render}pub struct ${pascalCase2(originalParentName)} {
 ${fieldTypes}
 }`
             ],
-            type: pascalCase(originalParentName)
+            type: pascalCase2(originalParentName)
           };
         }
         if (inlineStruct) {
@@ -591,7 +645,7 @@ ${fieldTypes}
         }
         return {
           ...mergedManifest,
-          type: `pub struct ${pascalCase(originalParentName)} {
+          type: `pub struct ${pascalCase2(originalParentName)} {
 ${fieldTypes}
 }`
         };
@@ -605,7 +659,7 @@ ${fieldTypes}
         };
       },
       visitZeroableOptionType(node) {
-        throw new CodamaError(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+        throw new CodamaError2(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       }
     })
   );
@@ -616,13 +670,23 @@ function mergeManifests(manifests) {
     nestedStructs: manifests.flatMap((m) => m.nestedStructs)
   };
 }
+
+// src/renderValueNodeVisitor.ts
+import {
+  arrayValueNode,
+  bytesValueNode,
+  isNode as isNode3,
+  numberValueNode,
+  pascalCase as pascalCase3
+} from "@codama/nodes";
+import { visit as visit2 } from "@codama/visitors-core";
 function renderValueNode(value, getImportFrom, useStr = false) {
-  return visit(value, renderValueNodeVisitor(getImportFrom, useStr));
+  return visit2(value, renderValueNodeVisitor(getImportFrom, useStr));
 }
 function renderValueNodeVisitor(getImportFrom, useStr = false) {
   return {
     visitArrayValue(node) {
-      const list = node.items.map((v) => visit(v, this));
+      const list = node.items.map((v) => visit2(v, this));
       return {
         imports: new ImportMap().mergeWith(...list.map((c) => c.imports)),
         render: `[${list.map((c) => c.render).join(", ")}]`
@@ -637,17 +701,17 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
     visitBytesValue(node) {
       const bytes = getBytesFromBytesValueNode(node);
       const numbers = Array.from(bytes).map(numberValueNode);
-      return visit(arrayValueNode(numbers), this);
+      return visit2(arrayValueNode(numbers), this);
     },
     visitConstantValue(node) {
-      if (isNode(node.value, "bytesValueNode")) {
-        return visit(node.value, this);
+      if (isNode3(node.value, "bytesValueNode")) {
+        return visit2(node.value, this);
       }
-      if (isNode(node.type, "stringTypeNode") && isNode(node.value, "stringValueNode")) {
-        return visit(bytesValueNode(node.type.encoding, node.value.string), this);
+      if (isNode3(node.type, "stringTypeNode") && isNode3(node.value, "stringValueNode")) {
+        return visit2(bytesValueNode(node.type.encoding, node.value.string), this);
       }
-      if (isNode(node.type, "numberTypeNode") && isNode(node.value, "numberValueNode")) {
-        const numberManifest = visit(node.value, this);
+      if (isNode3(node.type, "numberTypeNode") && isNode3(node.value, "numberValueNode")) {
+        const numberManifest = visit2(node.value, this);
         const { format, endian } = node.type;
         const byteFunction = endian === "le" ? "to_le_bytes" : "to_be_bytes";
         numberManifest.render = `${numberManifest.render}${format}.${byteFunction}()`;
@@ -657,14 +721,14 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
     },
     visitEnumValue(node) {
       const imports = new ImportMap();
-      const enumName = pascalCase(node.enum.name);
-      const variantName = pascalCase(node.variant);
+      const enumName = pascalCase3(node.enum.name);
+      const variantName = pascalCase3(node.variant);
       const importFrom = getImportFrom(node.enum);
       imports.add(`${importFrom}::${enumName}`);
       if (!node.value) {
         return { imports, render: `${enumName}::${variantName}` };
       }
-      const enumValue = visit(node.value, this);
+      const enumValue = visit2(node.value, this);
       const fields = enumValue.render;
       return {
         imports: imports.mergeWith(enumValue.imports),
@@ -672,15 +736,15 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitMapEntryValue(node) {
-      const mapKey = visit(node.key, this);
-      const mapValue = visit(node.value, this);
+      const mapKey = visit2(node.key, this);
+      const mapValue = visit2(node.value, this);
       return {
         imports: mapKey.imports.mergeWith(mapValue.imports),
         render: `[${mapKey.render}, ${mapValue.render}]`
       };
     },
     visitMapValue(node) {
-      const map = node.entries.map((entry) => visit(entry, this));
+      const map = node.entries.map((entry) => visit2(entry, this));
       const imports = new ImportMap().add("std::collection::HashMap");
       return {
         imports: imports.mergeWith(...map.map((c) => c.imports)),
@@ -706,7 +770,7 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitSetValue(node) {
-      const set = node.items.map((v) => visit(v, this));
+      const set = node.items.map((v) => visit2(v, this));
       const imports = new ImportMap().add("std::collection::HashSet");
       return {
         imports: imports.mergeWith(...set.map((c) => c.imports)),
@@ -714,7 +778,7 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitSomeValue(node) {
-      const child = visit(node.value, this);
+      const child = visit2(node.value, this);
       return {
         ...child,
         render: `Some(${child.render})`
@@ -727,21 +791,21 @@ function renderValueNodeVisitor(getImportFrom, useStr = false) {
       };
     },
     visitStructFieldValue(node) {
-      const structValue = visit(node.value, this);
+      const structValue = visit2(node.value, this);
       return {
         imports: structValue.imports,
         render: `${node.name}: ${structValue.render}`
       };
     },
     visitStructValue(node) {
-      const struct = node.fields.map((field) => visit(field, this));
+      const struct = node.fields.map((field) => visit2(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) => visit(v, this));
+      const tuple = node.items.map((v) => visit2(v, this));
       return {
         imports: new ImportMap().mergeWith(...tuple.map((c) => c.imports)),
         render: `(${tuple.map((c) => c.render).join(", ")})`
@@ -761,46 +825,46 @@ function getRenderMapVisitor(options = {}) {
   const getTraitsFromNode2 = getTraitsFromNodeFactory(options.traitOptions);
   const typeManifestVisitor = getTypeManifestVisitor({ getImportFrom, getTraitsFromNode: getTraitsFromNode2 });
   const anchorTraits = options.anchorTraits ?? true;
-  return pipe(
+  return pipe2(
     staticVisitor(() => new RenderMap(), {
       keys: ["rootNode", "programNode", "instructionNode", "accountNode", "definedTypeNode"]
     }),
-    (v) => extendVisitor(v, {
+    (v) => extendVisitor2(v, {
       visitAccount(node) {
-        const typeManifest = visit(node, typeManifestVisitor);
+        const typeManifest = visit3(node, typeManifestVisitor);
         const seedsImports = new ImportMap();
         const pda = node.pda ? linkables.get([...stack.getPath(), node.pda]) : void 0;
         const pdaSeeds = pda?.seeds ?? [];
         const seeds = pdaSeeds.map((seed) => {
-          if (isNode(seed, "variablePdaSeedNode")) {
-            const seedManifest2 = visit(seed.type, typeManifestVisitor);
+          if (isNode4(seed, "variablePdaSeedNode")) {
+            const seedManifest2 = visit3(seed.type, typeManifestVisitor);
             seedsImports.mergeWith(seedManifest2.imports);
-            const resolvedType2 = resolveNestedTypeNode(seed.type);
+            const resolvedType2 = resolveNestedTypeNode2(seed.type);
             return { ...seed, resolvedType: resolvedType2, typeManifest: seedManifest2 };
           }
-          if (isNode(seed.value, "programIdValueNode")) {
+          if (isNode4(seed.value, "programIdValueNode")) {
             return seed;
           }
-          const seedManifest = visit(seed.type, typeManifestVisitor);
+          const seedManifest = visit3(seed.type, typeManifestVisitor);
           const valueManifest = renderValueNode(seed.value, getImportFrom, true);
           seedsImports.mergeWith(valueManifest.imports);
-          const resolvedType = resolveNestedTypeNode(seed.type);
+          const resolvedType = resolveNestedTypeNode2(seed.type);
           return { ...seed, resolvedType, typeManifest: seedManifest, valueManifest };
         });
         const hasVariableSeeds = pdaSeeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
-        const constantSeeds = seeds.filter(isNodeFilter("constantPdaSeedNode")).filter((seed) => !isNode(seed.value, "programIdValueNode"));
+        const constantSeeds = seeds.filter(isNodeFilter("constantPdaSeedNode")).filter((seed) => !isNode4(seed.value, "programIdValueNode"));
         const { imports } = typeManifest;
         if (hasVariableSeeds) {
           imports.mergeWith(seedsImports);
         }
         return new RenderMap().add(
-          `accounts/${snakeCase(node.name)}.rs`,
+          `accounts/${snakeCase3(node.name)}.rs`,
           render("accountsPage.njk", {
             account: node,
             anchorTraits,
             constantSeeds,
             hasVariableSeeds,
-            imports: imports.remove(`generatedAccounts::${pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.remove(`generatedAccounts::${pascalCase4(node.name)}`).toString(dependencyMap),
             pda,
             program,
             seeds,
@@ -809,13 +873,13 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitDefinedType(node) {
-        const typeManifest = visit(node, typeManifestVisitor);
+        const typeManifest = visit3(node, typeManifestVisitor);
         const imports = new ImportMap().mergeWithManifest(typeManifest);
         return new RenderMap().add(
-          `types/${snakeCase(node.name)}.rs`,
+          `types/${snakeCase3(node.name)}.rs`,
           render("definedTypesPage.njk", {
             definedType: node,
-            imports: imports.remove(`generatedTypes::${pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.remove(`generatedTypes::${pascalCase4(node.name)}`).toString(dependencyMap),
             typeManifest
           })
         );
@@ -836,12 +900,12 @@ function getRenderMapVisitor(options = {}) {
             getImportFrom,
             getTraitsFromNode: getTraitsFromNode2,
             nestedStruct: true,
-            parentName: `${pascalCase(node.name)}InstructionData`
+            parentName: `${pascalCase4(node.name)}InstructionData`
           });
-          const manifest = visit(argument.type, argumentVisitor);
+          const manifest = visit3(argument.type, argumentVisitor);
           imports.mergeWith(manifest.imports);
-          const innerOptionType = isNode(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
-          const hasDefaultValue = !!argument.defaultValue && isNode(argument.defaultValue, VALUE_NODES);
+          const innerOptionType = isNode4(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
+          const hasDefaultValue = !!argument.defaultValue && isNode4(argument.defaultValue, VALUE_NODES);
           let renderValue = null;
           if (hasDefaultValue) {
             const { imports: argImports, render: value } = renderValueNode(
@@ -867,18 +931,18 @@ function getRenderMapVisitor(options = {}) {
         const structVisitor = getTypeManifestVisitor({
           getImportFrom,
           getTraitsFromNode: getTraitsFromNode2,
-          parentName: `${pascalCase(node.name)}InstructionData`
+          parentName: `${pascalCase4(node.name)}InstructionData`
         });
-        const typeManifest = visit(struct, structVisitor);
+        const typeManifest = visit3(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
         imports.mergeWith(dataTraits.imports);
         return new RenderMap().add(
-          `instructions/${snakeCase(node.name)}.rs`,
+          `instructions/${snakeCase3(node.name)}.rs`,
           render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
             hasArgs,
             hasOptional,
-            imports: imports.remove(`generatedInstructions::${pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.remove(`generatedInstructions::${pascalCase4(node.name)}`).toString(dependencyMap),
             instruction: node,
             instructionArgs,
             program,
@@ -888,14 +952,14 @@ function getRenderMapVisitor(options = {}) {
       },
       visitProgram(node, { self }) {
         program = node;
-        const renderMap = new RenderMap().mergeWith(...node.accounts.map((account) => visit(account, self))).mergeWith(...node.definedTypes.map((type) => visit(type, self))).mergeWith(
+        const renderMap = new RenderMap().mergeWith(...node.accounts.map((account) => visit3(account, self))).mergeWith(...node.definedTypes.map((type) => visit3(type, self))).mergeWith(
           ...getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => visit(ix, self))
+          }).map((ix) => visit3(ix, self))
         );
         if (node.errors.length > 0) {
           renderMap.add(
-            `errors/${snakeCase(node.name)}.rs`,
+            `errors/${snakeCase3(node.name)}.rs`,
             render("errorsPage.njk", {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
@@ -941,7 +1005,7 @@ function getRenderMapVisitor(options = {}) {
         if (definedTypesToExport.length > 0) {
           map.add("types/mod.rs", render("definedTypesMod.njk", ctx));
         }
-        return map.add("mod.rs", render("rootMod.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit(p, self)));
+        return map.add("mod.rs", render("rootMod.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit3(p, self)));
       }
     }),
     (v) => recordNodeStackVisitor(v, stack),
@@ -956,18 +1020,24 @@ function getConflictsForInstructionAccountsAndArgs(instruction) {
   const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
   return [...new Set(duplicates)];
 }
+
+// src/renderVisitor.ts
+import { logError, logWarn as logWarn2 } from "@codama/errors";
+import { deleteDirectory, writeRenderMapVisitor } from "@codama/renderers-core";
+import { rootNodeVisitor, visit as visit4 } from "@codama/visitors-core";
+import { spawnSync } from "child_process";
 function renderVisitor(path, options = {}) {
   return rootNodeVisitor((root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    visit(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
+    visit4(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
     if (options.formatCode) {
       if (options.crateFolder) {
         const toolchain = options.toolchain ?? "+stable";
         runFormatter("cargo", [toolchain, "fmt", "--manifest-path", `${options.crateFolder}/Cargo.toml`]);
       } else {
-        logWarn("No crate folder specified, skipping formatting.");
+        logWarn2("No crate folder specified, skipping formatting.");
       }
     }
   });
@@ -975,17 +1045,21 @@ function renderVisitor(path, options = {}) {
 function runFormatter(cmd, args) {
   const { stdout, stderr, error } = spawnSync(cmd, args);
   if (error?.message?.includes("ENOENT")) {
-    logWarn(`Could not find ${cmd}, skipping formatting.`);
+    logWarn2(`Could not find ${cmd}, skipping formatting.`);
     return;
   }
   if (stdout.length > 0) {
-    logWarn(`(cargo-fmt) ${stdout ? stdout?.toString() : error}`);
+    logWarn2(`(cargo-fmt) ${stdout ? stdout?.toString() : error}`);
   }
   if (stderr.length > 0) {
     logError(`(cargo-fmt) ${stderr ? stderr.toString() : error}`);
   }
 }
-
-export { ImportMap, renderVisitor as default, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
-//# sourceMappingURL=index.node.mjs.map
+export {
+  ImportMap,
+  renderVisitor as default,
+  getRenderMapVisitor,
+  getTypeManifestVisitor,
+  renderVisitor
+};
 //# sourceMappingURL=index.node.mjs.map