@codama/renderers-js 1.2.6 → 1.2.7

package/dist/index.node.mjs

@@ -1,15 +1,3 @@
-import { NodeStack, pipe, staticVisitor, extendVisitor, visit, findLastNodeFromPath, recordNodeStackVisitor, LinkableDictionary, getResolvedInstructionInputsVisitor, findProgramNodeFromPath, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, getLastNodeFromPath, findInstructionNodeFromPath, deduplicateInstructionDependencies } from '@codama/visitors-core';
-import { join, dirname } from 'node:path';
-import { camelCase, pascalCase, snakeCase, REGISTERED_TYPE_NODE_KINDS, REGISTERED_VALUE_NODE_KINDS, isNodeFilter, resolveNestedTypeNode, structTypeNodeFromInstructionArgumentNodes, isNode, isScalarEnum, structTypeNode, structFieldTypeNode, titleCase, kebabCase, capitalize, getAllPrograms, getAllPdas, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, definedTypeNode, definedTypeLinkNode, isDataEnum, accountValueNode, argumentValueNode, VALUE_NODES, getAllInstructionArguments, constantDiscriminatorNode, constantValueNodeFromBytes, constantValueNode, assertIsNode } from '@codama/nodes';
-import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder, getBase64Decoder } from '@solana/codecs-strings';
-import { logWarn, CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
-import { fileURLToPath } from 'node:url';
-import nunjucks from 'nunjucks';
-import { RenderMap, deleteDirectory } from '@codama/renderers-core';
-import * as estreePlugin from 'prettier/plugins/estree';
-import * as typeScriptPlugin from 'prettier/plugins/typescript';
-import { format } from 'prettier/standalone';
-
 // src/ImportMap.ts
 var DEFAULT_EXTERNAL_MODULE_MAP = {
   solanaAccounts: "@solana/kit",
@@ -142,6 +130,20 @@ var ImportMap = class {
     }).join("\n");
   }
 };
+
+// src/fragments/accountFetchHelpers.ts
+import { getLastNodeFromPath } from "@codama/visitors-core";
+
+// src/fragments/common.ts
+import { join as join2 } from "node:path";
+
+// src/utils/async.ts
+import {
+  accountValueNode,
+  argumentValueNode,
+  isNode
+} from "@codama/nodes";
+import { deduplicateInstructionDependencies } from "@codama/visitors-core";
 function hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers) {
   const hasByteDeltasAsync = (instructionNode.byteDeltas ?? []).some(
     ({ value }) => isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
@@ -211,6 +213,9 @@ function getInstructionDependencies(input, asyncResolvers, useAsync) {
   }
   return [];
 }
+
+// src/utils/codecs.ts
+import { getBase16Encoder, getBase58Encoder, getBase64Encoder, getUtf8Encoder } from "@solana/codecs-strings";
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
@@ -224,6 +229,15 @@ function getBytesFromBytesValueNode(node) {
       return getBase64Encoder().encode(node.data);
   }
 }
+
+// src/utils/customData.ts
+import {
+  camelCase,
+  definedTypeLinkNode,
+  definedTypeNode,
+  isNode as isNode2,
+  structTypeNodeFromInstructionArgumentNodes
+} from "@codama/nodes";
 var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
   customDataOptions.map((o) => {
     const options = typeof o === "string" ? { name: o } : o;
@@ -244,7 +258,7 @@ var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
 var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.flatMap((node) => {
   const options = parsedCustomDataOptions.get(node.name);
   if (!options || !options.extract) return [];
-  if (isNode(node, "accountNode")) {
+  if (isNode2(node, "accountNode")) {
     return [definedTypeNode({ name: options.extractAs, type: { ...node.data } })];
   }
   return [
@@ -254,6 +268,9 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
     })
   ];
 });
+
+// src/utils/linkOverrides.ts
+import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
   const customDataOverrides = Object.fromEntries(
     [...customAccountData.values(), ...customInstructionData.values()].map(({ importFrom, importAs }) => [
@@ -300,6 +317,12 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
     }
   };
 }
+
+// src/utils/render.ts
+import { dirname as pathDirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { camelCase as camelCase2, kebabCase, pascalCase, snakeCase, titleCase } from "@codama/nodes";
+import nunjucks from "nunjucks";
 function jsDocblock(docs) {
   if (docs.length <= 0) return "";
   if (docs.length === 1) return `/** ${docs[0]} */
@@ -311,11 +334,11 @@ ${lines.join("\n")}
 `;
 }
 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);
+  env.addFilter("camelCase", camelCase2);
   env.addFilter("snakeCase", snakeCase);
   env.addFilter("kebabCase", kebabCase);
   env.addFilter("titleCase", titleCase);
@@ -328,7 +351,7 @@ function fragment(render2, imports) {
   return new Fragment(render2, imports);
 }
 function fragmentFromTemplate(fragmentFile, context, options) {
-  return fragment(render(join("fragments", fragmentFile), context, options));
+  return fragment(render(join2("fragments", fragmentFile), context, options));
 }
 function mergeFragments(fragments, mergeRenders) {
   return new Fragment(
@@ -425,9 +448,13 @@ function getAccountFetchHelpersFragment(scope) {
     "type MaybeEncodedAccount"
   ]);
 }
+
+// src/fragments/accountPdaHelpers.ts
+import { isNodeFilter } from "@codama/nodes";
+import { findProgramNodeFromPath, getLastNodeFromPath as getLastNodeFromPath2 } from "@codama/visitors-core";
 function getAccountPdaHelpersFragment(scope) {
   const { accountPath, nameApi, linkables, customAccountData, typeManifest: typeManifest2 } = scope;
-  const accountNode = getLastNodeFromPath(accountPath);
+  const accountNode = getLastNodeFromPath2(accountPath);
   const programNode = findProgramNodeFromPath(accountPath);
   const pdaNode = accountNode.pda ? linkables.get([...accountPath, accountNode.pda]) : void 0;
   if (!pdaNode) {
@@ -455,9 +482,12 @@ function getAccountPdaHelpersFragment(scope) {
     "type MaybeAccount"
   ]);
 }
+
+// src/fragments/accountSizeHelpers.ts
+import { getLastNodeFromPath as getLastNodeFromPath3 } from "@codama/visitors-core";
 function getAccountSizeHelpersFragment(scope) {
   const { accountPath, nameApi } = scope;
-  const accountNode = getLastNodeFromPath(accountPath);
+  const accountNode = getLastNodeFromPath3(accountPath);
   if (accountNode.size == null) {
     return fragment("");
   }
@@ -467,6 +497,9 @@ function getAccountSizeHelpersFragment(scope) {
   });
 }
 
+// src/fragments/accountType.ts
+import { getLastNodeFromPath as getLastNodeFromPath4 } from "@codama/visitors-core";
+
 // src/fragments/type.ts
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
@@ -538,7 +571,7 @@ function getTypeWithCodecFragment(scope) {
 // src/fragments/accountType.ts
 function getAccountTypeFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = getLastNodeFromPath(accountPath);
+  const accountNode = getLastNodeFromPath4(accountPath);
   if (customAccountData.has(accountNode.name)) {
     return fragment("");
   }
@@ -548,16 +581,27 @@ function getAccountTypeFragment(scope) {
     nameApi
   });
 }
+
+// src/fragments/discriminatorCondition.ts
+import {
+  constantDiscriminatorNode,
+  constantValueNode,
+  constantValueNodeFromBytes,
+  isNode as isNode3,
+  isNodeFilter as isNodeFilter2
+} from "@codama/nodes";
+import { visit } from "@codama/visitors-core";
+import { getBase64Decoder } from "@solana/codecs-strings";
 function getDiscriminatorConditionFragment(scope) {
   return mergeFragments(
     scope.discriminators.flatMap((discriminator) => {
-      if (isNode(discriminator, "sizeDiscriminatorNode")) {
+      if (isNode3(discriminator, "sizeDiscriminatorNode")) {
         return [getSizeConditionFragment(discriminator, scope)];
       }
-      if (isNode(discriminator, "constantDiscriminatorNode")) {
+      if (isNode3(discriminator, "constantDiscriminatorNode")) {
         return [getByteConditionFragment(discriminator, scope)];
       }
-      if (isNode(discriminator, "fieldDiscriminatorNode")) {
+      if (isNode3(discriminator, "fieldDiscriminatorNode")) {
         return [getFieldConditionFragment(discriminator, scope)];
       }
       return [];
@@ -581,7 +625,7 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if (isNode(field.type, "arrayTypeNode") && isNode(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode(field.type.count, "fixedCountNode") && isNode(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter("numberValueNode"))) {
+  if (isNode3(field.type, "arrayTypeNode") && isNode3(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode3(field.type.count, "fixedCountNode") && isNode3(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter2("numberValueNode"))) {
     const base64Bytes = getBase64Decoder().decode(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
@@ -595,8 +639,11 @@ function getFieldConditionFragment(discriminator, scope) {
     scope
   );
 }
+
+// src/fragments/instructionAccountMeta.ts
+import { pascalCase as pascalCase2 } from "@codama/nodes";
 function getInstructionAccountMetaFragment(instructionAccountNode) {
-  const typeParam = `TAccount${pascalCase(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${pascalCase2(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
     return fragment(`WritableSignerAccount<${typeParam}> & IAccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type WritableSignerAccount"]).addImports("solanaSigners", ["type IAccountSignerMeta"]);
   }
@@ -608,15 +655,23 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
   }
   return fragment(`ReadonlyAccount<${typeParam}>`).addImports("solanaInstructions", "type ReadonlyAccount");
 }
+
+// src/fragments/instructionAccountTypeParam.ts
+import { pascalCase as pascalCase3 } from "@codama/nodes";
+import {
+  findInstructionNodeFromPath,
+  findProgramNodeFromPath as findProgramNodeFromPath2,
+  getLastNodeFromPath as getLastNodeFromPath5
+} from "@codama/visitors-core";
 function getInstructionAccountTypeParamFragment(scope) {
-  const { instructionAccountPath, linkables } = scope;
-  const instructionAccountNode = getLastNodeFromPath(instructionAccountPath);
+  const { instructionAccountPath, allowAccountMeta, linkables } = scope;
+  const instructionAccountNode = getLastNodeFromPath5(instructionAccountPath);
   const instructionNode = findInstructionNodeFromPath(instructionAccountPath);
-  const programNode = findProgramNodeFromPath(instructionAccountPath);
-  const typeParam = `TAccount${pascalCase(instructionAccountNode.name)}`;
-  const accountMeta = " | IAccountMeta<string>" ;
+  const programNode = findProgramNodeFromPath2(instructionAccountPath);
+  const typeParam = `TAccount${pascalCase3(instructionAccountNode.name)}`;
+  const accountMeta = allowAccountMeta ? " | IAccountMeta<string>" : "";
   const imports = new ImportMap();
-  {
+  if (allowAccountMeta) {
     imports.add("solanaInstructions", "type IAccountMeta");
   }
   if (instructionNode.optionalAccountStrategy === "omitted" && instructionAccountNode.isOptional) {
@@ -638,8 +693,12 @@ function getDefaultAddress(defaultValue, programId, linkables) {
       return "string";
   }
 }
+
+// src/fragments/instructionByteDelta.ts
+import { assertIsNode, camelCase as camelCase3, isNode as isNode4 } from "@codama/nodes";
+import { getLastNodeFromPath as getLastNodeFromPath6 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = getLastNodeFromPath(scope.instructionPath);
+  const { byteDeltas } = getLastNodeFromPath6(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -650,16 +709,16 @@ const byteDelta: number = [${r.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   const bytesFragment = (() => {
-    if (isNode(byteDelta.value, "numberValueNode")) {
+    if (isNode4(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if (isNode(byteDelta.value, "argumentValueNode")) {
+    if (isNode4(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if (isNode(byteDelta.value, "accountLinkNode")) {
+    if (isNode4(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if (isNode(byteDelta.value, "resolverValueNode")) {
+    if (isNode4(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -679,7 +738,7 @@ function getNumberValueNodeFragment(byteDelta) {
 }
 function getArgumentValueNodeFragment(byteDelta) {
   assertIsNode(byteDelta.value, "argumentValueNode");
-  const argumentName = camelCase(byteDelta.value.name);
+  const argumentName = camelCase3(byteDelta.value.name);
   return fragment(`Number(args.${argumentName})`);
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
@@ -695,9 +754,12 @@ function getResolverValueNodeFragment(byteDelta, scope) {
   const functionName = scope.nameApi.resolverFunction(byteDelta.value.name);
   return fragment(`${awaitKeyword}${functionName}(resolverScope)`).addImports(scope.getImportFrom(byteDelta.value), functionName).addFeatures(["instruction:resolverScopeVariable"]);
 }
+
+// src/fragments/instructionData.ts
+import { getLastNodeFromPath as getLastNodeFromPath7 } from "@codama/visitors-core";
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath7(instructionPath);
   if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) {
     return fragment("");
   }
@@ -708,6 +770,15 @@ function getInstructionDataFragment(scope) {
     nameApi
   });
 }
+
+// src/fragments/discriminatorConstants.ts
+import {
+  camelCase as camelCase4,
+  isNode as isNode5,
+  isNodeFilter as isNodeFilter3,
+  VALUE_NODES
+} from "@codama/nodes";
+import { visit as visit2 } from "@codama/visitors-core";
 function getDiscriminatorConstantsFragment(scope) {
   const fragments = scope.discriminatorNodes.map((node) => getDiscriminatorConstantFragment(node, scope)).filter(Boolean);
   return mergeFragments(fragments, (r) => r.join("\n\n"));
@@ -724,22 +795,22 @@ function getDiscriminatorConstantFragment(discriminatorNode, scope) {
 }
 function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
-  const index = discriminatorNodes.filter(isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const index = discriminatorNodes.filter(isNodeFilter3("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = camelCase(`${prefix}_discriminator${suffix}`);
-  const encoder = visit(discriminatorNode.constant.type, typeManifestVisitor).encoder;
-  const value = visit(discriminatorNode.constant.value, typeManifestVisitor).value;
+  const name = camelCase4(`${prefix}_discriminator${suffix}`);
+  const encoder = visit2(discriminatorNode.constant.type, typeManifestVisitor).encoder;
+  const value = visit2(discriminatorNode.constant.value, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { fields, prefix, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !isNode(field.defaultValue, VALUE_NODES)) {
+  if (!field || !field.defaultValue || !isNode5(field.defaultValue, VALUE_NODES)) {
     return null;
   }
-  const name = camelCase(`${prefix}_${discriminatorNode.name}`);
-  const encoder = visit(field.type, typeManifestVisitor).encoder;
-  const value = visit(field.defaultValue, typeManifestVisitor).value;
+  const name = camelCase4(`${prefix}_${discriminatorNode.name}`);
+  const encoder = visit2(field.type, typeManifestVisitor).encoder;
+  const value = visit2(field.defaultValue, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getConstantFragment(scope) {
@@ -754,9 +825,12 @@ function getConstantFragment(scope) {
     (r) => r.join("\n\n")
   );
 }
+
+// src/fragments/instructionExtraArgs.ts
+import { getLastNodeFromPath as getLastNodeFromPath8 } from "@codama/visitors-core";
 function getInstructionExtraArgsFragment(scope) {
   const { instructionPath, extraArgsManifest, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath8(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) {
     return fragment("");
   }
@@ -767,6 +841,21 @@ function getInstructionExtraArgsFragment(scope) {
     strictName: nameApi.dataType(instructionExtraName)
   }).mergeImportsWith(extraArgsManifest.looseType);
 }
+
+// src/fragments/instructionFunction.ts
+import { camelCase as camelCase9, isNode as isNode10, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
+import {
+  findProgramNodeFromPath as findProgramNodeFromPath3,
+  getLastNodeFromPath as getLastNodeFromPath12
+} from "@codama/visitors-core";
+
+// src/fragments/instructionInputResolved.ts
+import { camelCase as camelCase6, isNode as isNode7 } from "@codama/nodes";
+import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
+
+// src/fragments/instructionInputDefault.ts
+import { camelCase as camelCase5, isNode as isNode6 } from "@codama/nodes";
+import { visit as visit3 } from "@codama/visitors-core";
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
   if (!input.defaultValue) {
@@ -777,8 +866,8 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = camelCase(input.name);
-    if (input.kind === "instructionAccountNode" && isNode(defaultValue, "resolverValueNode")) {
+    const inputName = camelCase5(input.name);
+    if (input.kind === "instructionAccountNode" && isNode6(defaultValue, "resolverValueNode")) {
       return fragment(`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`);
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -794,7 +883,7 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
   };
   switch (defaultValue.kind) {
     case "accountValueNode":
-      const name = camelCase(defaultValue.name);
+      const name = camelCase5(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
         return defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`).addImports(
           "shared",
@@ -806,44 +895,44 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
     case "pdaValueNode":
-      if (isNode(defaultValue.pda, "pdaNode")) {
+      if (isNode6(defaultValue.pda, "pdaNode")) {
         const pdaProgram = defaultValue.pda.programId ? fragment(
           `'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`
         ).addImports("solanaAddresses", "type Address") : fragment("programAddress");
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
-          if (isNode(seed, "constantPdaSeedNode") && isNode(seed.value, "programIdValueNode")) {
+          if (isNode6(seed, "constantPdaSeedNode") && isNode6(seed.value, "programIdValueNode")) {
             return [
               fragment(`getAddressEncoder().encode(${pdaProgram.render})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
             ];
           }
-          if (isNode(seed, "constantPdaSeedNode") && !isNode(seed.value, "programIdValueNode")) {
-            const typeManifest2 = visit(seed.type, typeManifestVisitor);
-            const valueManifest2 = visit(seed.value, typeManifestVisitor);
+          if (isNode6(seed, "constantPdaSeedNode") && !isNode6(seed.value, "programIdValueNode")) {
+            const typeManifest2 = visit3(seed.type, typeManifestVisitor);
+            const valueManifest2 = visit3(seed.value, typeManifestVisitor);
             return [
               fragment(
                 `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
               ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
             ];
           }
-          if (isNode(seed, "variablePdaSeedNode")) {
-            const typeManifest2 = visit(seed.type, typeManifestVisitor);
+          if (isNode6(seed, "variablePdaSeedNode")) {
+            const typeManifest2 = visit3(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if (isNode(valueSeed, "accountValueNode")) {
+            if (isNode6(valueSeed, "accountValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${camelCase(valueSeed.name)}.value))`
+                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
               ];
             }
-            if (isNode(valueSeed, "argumentValueNode")) {
+            if (isNode6(valueSeed, "argumentValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder.render}.encode(expectSome(args.${camelCase(valueSeed.name)}))`
+                  `${typeManifest2.encoder.render}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
               ];
             }
-            const valueManifest2 = visit(valueSeed, typeManifestVisitor);
+            const valueManifest2 = visit3(valueSeed, typeManifestVisitor);
             return [
               fragment(
                 `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
@@ -861,18 +950,18 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
-        if (isNode(seed.value, "accountValueNode")) {
+        if (isNode6(seed.value, "accountValueNode")) {
           return fragment(
-            `${seed.name}: expectAddress(accounts.${camelCase(seed.value.name)}.value)`
+            `${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`
           ).addImports("shared", "expectAddress");
         }
-        if (isNode(seed.value, "argumentValueNode")) {
-          return fragment(`${seed.name}: expectSome(args.${camelCase(seed.value.name)})`).addImports(
+        if (isNode6(seed.value, "argumentValueNode")) {
+          return fragment(`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`).addImports(
             "shared",
             "expectSome"
           );
         }
-        return visit(seed.value, typeManifestVisitor).value.mapRender((r) => `${seed.name}: ${r}`);
+        return visit3(seed.value, typeManifestVisitor).value.mapRender((r) => `${seed.name}: ${r}`);
       });
       const pdaSeedsFragment = mergeFragments(pdaSeeds, (renders) => renders.join(", ")).mapRender((r) => `{ ${r} }`);
       if (pdaSeeds.length > 0) {
@@ -897,10 +986,10 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       return fragment("");
     case "accountBumpValueNode":
       return defaultFragment(
-        `expectProgramDerivedAddress(accounts.${camelCase(defaultValue.name)}.value)[1]`
+        `expectProgramDerivedAddress(accounts.${camelCase5(defaultValue.name)}.value)[1]`
       ).addImports("shared", "expectProgramDerivedAddress");
     case "argumentValueNode":
-      return defaultFragment(`expectSome(args.${camelCase(defaultValue.name)})`).addImports(
+      return defaultFragment(`expectSome(args.${camelCase5(defaultValue.name)})`).addImports(
         "shared",
         "expectSome"
       );
@@ -929,16 +1018,16 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if (isNode(defaultValue.condition, "resolverValueNode")) {
+      if (isNode6(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
         conditionalFragment.addImports(getImportFrom(defaultValue.condition), conditionalResolverFunction).addFeatures(["instruction:resolverScopeVariable"]);
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
-        const comparedInputName = isNode(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase(defaultValue.condition.name)}.value` : `args.${camelCase(defaultValue.condition.name)}`;
+        const comparedInputName = isNode6(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase5(defaultValue.condition.name)}.value` : `args.${camelCase5(defaultValue.condition.name)}`;
         if (defaultValue.value) {
-          const comparedValue = visit(defaultValue.value, typeManifestVisitor).value;
+          const comparedValue = visit3(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment.mergeImportsWith(comparedValue).mergeFeaturesWith(comparedValue);
           const operator = negatedCondition ? "!==" : "===";
           condition = `${comparedInputName} ${operator} ${comparedValue.render}`;
@@ -961,7 +1050,7 @@ ${ifTrueRenderer ? ifTrueRenderer.render : ifFalseRenderer?.render}
 }`
       );
     default:
-      const valueManifest = visit(defaultValue, typeManifestVisitor).value;
+      const valueManifest = visit3(defaultValue, typeManifestVisitor).value;
       return defaultFragment(valueManifest.render).mergeImportsWith(valueManifest);
   }
 }
@@ -976,7 +1065,7 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
-  const instructionNode = getLastNodeFromPath(scope.instructionPath);
+  const instructionNode = getLastNodeFromPath9(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
@@ -984,10 +1073,10 @@ function getInstructionInputResolvedFragment(scope) {
       optionalAccountStrategy: instructionNode.optionalAccountStrategy
     });
     if (!inputFragment.render) return [];
-    const camelName = camelCase(input.name);
+    const camelName = camelCase6(input.name);
     return [
       inputFragment.mapRender(
-        (r) => isNode(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (r) => isNode7(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${r}
 }` : `if (!accounts.${camelName}.value) {
 ${r}
@@ -1003,9 +1092,20 @@ ${r}
     (renders) => renders.join("\n")
   );
 }
+
+// src/fragments/instructionInputType.ts
+import {
+  camelCase as camelCase7,
+  getAllInstructionArguments,
+  isNode as isNode8,
+  pascalCase as pascalCase4
+} from "@codama/nodes";
+import {
+  getLastNodeFromPath as getLastNodeFromPath10
+} from "@codama/visitors-core";
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath10(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   const accountsFragment = getAccountsFragment(scope);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
@@ -1029,22 +1129,22 @@ function getInstructionInputTypeFragment(scope) {
 }
 function getAccountsFragment(scope) {
   const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath10(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode8(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const docblock = account.docs.length > 0 ? jsDocblock(account.docs) : "";
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
     return getAccountTypeFragment2(resolvedAccount).mapRender(
-      (r) => `${docblock}${camelCase(account.name)}${optionalSign}: ${r};`
+      (r) => `${docblock}${camelCase7(account.name)}${optionalSign}: ${r};`
     );
   });
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
 function getAccountTypeFragment2(account) {
-  const typeParam = `TAccount${pascalCase(account.name)}`;
+  const typeParam = `TAccount${pascalCase4(account.name)}`;
   if (account.isPda && account.isSigner === false) {
     return fragment(`ProgramDerivedAddress<${typeParam}>`).addImports("solanaAddresses", [
       "type ProgramDerivedAddress"
@@ -1063,7 +1163,7 @@ function getAccountTypeFragment2(account) {
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath10(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
@@ -1081,7 +1181,7 @@ function getDataArgumentsFragments(scope) {
 }
 function getExtraArgumentsFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath10(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
@@ -1092,16 +1192,16 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => isNode(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => isNode8(input, "instructionArgumentNode") && input.name === arg.name
   );
   if (arg.defaultValue && arg.defaultValueStrategy === "omitted") return null;
   const renamedName = renamedArgs.get(arg.name) ?? arg.name;
   const optionalSign = arg.defaultValue || resolvedArg?.defaultValue ? "?" : "";
-  return argsType.mapRender((r) => `${camelCase(renamedName)}${optionalSign}: ${r}["${camelCase(arg.name)}"];`);
+  return argsType.mapRender((r) => `${camelCase7(renamedName)}${optionalSign}: ${r}["${camelCase7(arg.name)}"];`);
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if (isNode(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if (isNode8(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
     const allArguments = getAllInstructionArguments(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
@@ -1115,12 +1215,21 @@ function getRemainingAccountsFragment(instructionNode) {
         return mergeFragments([signerFragment, addressFragment], (r) => r.join(" | "));
       }
       return isSigner ? signerFragment : addressFragment;
-    })().mapRender((r) => `${camelCase(name)}${optionalSign}: Array<${r}>;`);
+    })().mapRender((r) => `${camelCase7(name)}${optionalSign}: Array<${r}>;`);
   });
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
+
+// src/fragments/instructionRemainingAccounts.ts
+import {
+  assertIsNode as assertIsNode2,
+  camelCase as camelCase8,
+  getAllInstructionArguments as getAllInstructionArguments2,
+  isNode as isNode9
+} from "@codama/nodes";
+import { getLastNodeFromPath as getLastNodeFromPath11 } from "@codama/visitors-core";
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = getLastNodeFromPath(scope.instructionPath);
+  const { remainingAccounts } = getLastNodeFromPath11(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -1131,10 +1240,10 @@ const remainingAccounts: IAccountMeta[] = ${r.length === 1 ? r[0] : `[...${r.joi
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if (isNode(remainingAccounts.value, "argumentValueNode")) {
+    if (isNode9(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if (isNode(remainingAccounts.value, "resolverValueNode")) {
+    if (isNode9(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1143,9 +1252,9 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const instructionNode = getLastNodeFromPath(scope.instructionPath);
-  assertIsNode(remainingAccounts.value, "argumentValueNode");
-  const argumentName = camelCase(remainingAccounts.value.name);
+  const instructionNode = getLastNodeFromPath11(scope.instructionPath);
+  assertIsNode2(remainingAccounts.value, "argumentValueNode");
+  const argumentName = camelCase8(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1153,7 +1262,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const signerRole = isWritable ? "AccountRole.WRITABLE_SIGNER" : "AccountRole.READONLY_SIGNER";
   const role = isSigner === true ? signerRole : nonSignerRole;
   const argumentArray = isOptional ? `(args.${argumentName} ?? [])` : `args.${argumentName}`;
-  const allArguments = getAllInstructionArguments(instructionNode);
+  const allArguments = getAllInstructionArguments2(instructionNode);
   const argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
     return fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`).addImports(
@@ -1174,7 +1283,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   ).addImports("solanaInstructions", ["AccountRole"]);
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
-  assertIsNode(remainingAccounts.value, "resolverValueNode");
+  assertIsNode2(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1194,8 +1303,8 @@ function getInstructionFunctionFragment(scope) {
     nameApi,
     customInstructionData
   } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
-  const programNode = findProgramNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath12(instructionPath);
+  const programNode = findProgramNodeFromPath3(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
     return fragment("");
   }
@@ -1203,7 +1312,7 @@ function getInstructionFunctionFragment(scope) {
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted" && instructionNode.accounts.some((account) => account.isOptional);
   const instructionDependencies = getInstructionDependencies(instructionNode, asyncResolvers, useAsync);
-  const argDependencies = instructionDependencies.filter(isNodeFilter("argumentValueNode")).map((node) => node.name);
+  const argDependencies = instructionDependencies.filter(isNodeFilter4("argumentValueNode")).map((node) => node.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
   const argIsNotOmitted = (arg) => !(arg.defaultValue && arg.defaultValueStrategy === "omitted");
   const argIsDependent = (arg) => argDependencies.includes(arg.name);
@@ -1216,7 +1325,7 @@ function getInstructionFunctionFragment(scope) {
   const hasExtraArgs = (instructionNode.extraArguments ?? []).filter(
     (field) => argIsNotOmitted(field) && (argIsDependent(field) || argHasDefaultValue(field))
   ).length > 0;
-  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode10(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
@@ -1292,18 +1401,18 @@ function getInstructionFunctionFragment(scope) {
   return functionFragment;
 }
 function getTypeParams(instructionNode, programAddressConstant) {
-  const typeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase(account.name)} extends string`);
+  const typeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase5(account.name)} extends string`);
   typeParams.push(`TProgramAddress extends Address = typeof ${programAddressConstant}`);
   return fragment(typeParams.filter((x) => !!x).join(", ")).mapRender((r) => `<${r}>`).addImports("generatedPrograms", [programAddressConstant]);
 }
 function getInstructionType(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath12(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = `TAccount${pascalCase(account.name)}`;
-    const camelName = camelCase(account.name);
+    const typeParam = `TAccount${pascalCase5(account.name)}`;
+    const camelName = camelCase9(account.name);
     if (account.isSigner === "either") {
       const signerRole = account.isWritable ? "WritableSignerAccount" : "ReadonlySignerAccount";
       return fragment(
@@ -1319,16 +1428,19 @@ function getInstructionType(scope) {
 }
 function getInputTypeCall(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath12(instructionPath);
   const inputTypeName = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   if (instructionNode.accounts.length === 0) return fragment(inputTypeName);
-  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase(account.name)}`).join(", ");
+  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase5(account.name)}`).join(", ");
   return fragment(`${inputTypeName}<${accountTypeParams}>`);
 }
+
+// src/fragments/instructionParseFunction.ts
+import { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath13 } from "@codama/visitors-core";
 function getInstructionParseFunctionFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
-  const programNode = findProgramNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath13(instructionPath);
+  const programNode = findProgramNodeFromPath4(instructionPath);
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasOptionalAccounts = instructionNode.accounts.some((account) => account.isOptional);
@@ -1356,20 +1468,25 @@ function getInstructionParseFunctionFragment(scope) {
     programAddressConstant
   }).mergeImportsWith(dataTypeFragment).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaInstructions", ["type IInstruction"]).addImports("solanaInstructions", hasAccounts ? ["type IInstructionWithAccounts", "type IAccountMeta"] : []).addImports("solanaInstructions", hasData ? ["type IInstructionWithData"] : []);
 }
+
+// src/fragments/instructionType.ts
+import { pascalCase as pascalCase6 } from "@codama/nodes";
+import { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath14 } from "@codama/visitors-core";
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath(instructionPath);
-  const programNode = findProgramNodeFromPath(instructionPath);
+  const instructionNode = getLastNodeFromPath14(instructionPath);
+  const programNode = findProgramNodeFromPath5(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  const dataType = customData ? pascalCase(customData.importAs) : pascalCase(instructionDataName);
+  const dataType = customData ? pascalCase6(customData.importAs) : pascalCase6(instructionDataName);
   const accountTypeParamsFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
+        allowAccountMeta: true,
         instructionAccountPath: [...instructionPath, account]
       })
     ),
@@ -1379,7 +1496,7 @@ function getInstructionTypeFragment(scope) {
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountMetaFragment(account).mapRender((r) => {
-        const typeParam = `TAccount${pascalCase(account.name)}`;
+        const typeParam = `TAccount${pascalCase6(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
         const type = `${typeParam} extends string ? ${r} : ${typeParam}`;
         if (!isLegacyOptional) return type;
@@ -1405,28 +1522,32 @@ function getInstructionTypeFragment(scope) {
   ]);
   return fragment2;
 }
+
+// src/fragments/pdaFunction.ts
+import { isNode as isNode11, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
+import { findProgramNodeFromPath as findProgramNodeFromPath6, getLastNodeFromPath as getLastNodeFromPath15, visit as visit4 } from "@codama/visitors-core";
 function getPdaFunctionFragment(scope) {
   const { pdaPath, typeManifestVisitor, nameApi } = scope;
-  const pdaNode = getLastNodeFromPath(pdaPath);
-  const programNode = findProgramNodeFromPath(pdaPath);
+  const pdaNode = getLastNodeFromPath15(pdaPath);
+  const programNode = findProgramNodeFromPath6(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
-    if (isNode(seed, "variablePdaSeedNode")) {
-      const seedManifest2 = visit(seed.type, typeManifestVisitor);
+    if (isNode11(seed, "variablePdaSeedNode")) {
+      const seedManifest2 = visit4(seed.type, typeManifestVisitor);
       imports.mergeWith(seedManifest2.looseType, seedManifest2.encoder);
       return { ...seed, typeManifest: seedManifest2 };
     }
-    if (isNode(seed.value, "programIdValueNode")) {
+    if (isNode11(seed.value, "programIdValueNode")) {
       imports.add("solanaAddresses", "getAddressEncoder");
       return seed;
     }
-    const seedManifest = visit(seed.type, typeManifestVisitor);
+    const seedManifest = visit4(seed.type, typeManifestVisitor);
     imports.mergeWith(seedManifest.encoder);
-    const valueManifest = visit(seed.value, typeManifestVisitor).value;
+    const valueManifest = visit4(seed.value, typeManifestVisitor).value;
     imports.mergeWith(valueManifest.imports);
     return { ...seed, typeManifest: seedManifest, valueManifest };
   });
-  const hasVariableSeeds = pdaNode.seeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = pdaNode.seeds.filter(isNodeFilter5("variablePdaSeedNode")).length > 0;
   return fragmentFromTemplate("pdaFunction.njk", {
     findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
     hasVariableSeeds,
@@ -1444,6 +1565,9 @@ function getProgramFragment(scope) {
     programAddressConstant: nameApi.programAddressConstant(programNode.name)
   }).addImports("solanaAddresses", ["type Address"]);
 }
+
+// src/fragments/programAccounts.ts
+import { resolveNestedTypeNode } from "@codama/nodes";
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return fragment("");
   return mergeFragments(
@@ -1505,6 +1629,12 @@ function getProgramErrorsFragment(scope) {
     programIsErrorFunction: nameApi.programIsErrorFunction(programNode.name)
   }).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaPrograms", ["isProgramError"]).addImports("solanaErrors", ["type SolanaError", "type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM"]).addImports("solanaAddresses", ["type Address"]);
 }
+
+// src/fragments/programInstructions.ts
+import {
+  getAllInstructionsWithSubs,
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes2
+} from "@codama/nodes";
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return fragment("");
   const allInstructions = getAllInstructionsWithSubs(scope.programNode, {
@@ -1549,7 +1679,7 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: structTypeNodeFromInstructionArgumentNodes(instruction.arguments)
+        struct: structTypeNodeFromInstructionArgumentNodes2(instruction.arguments)
       });
     }),
     (r) => r.join("\n")
@@ -1582,9 +1712,12 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
     (r) => r.join("\n")
   );
 }
+
+// src/fragments/typeDiscriminatedUnionHelpers.ts
+import { isDataEnum, isNode as isNode12 } from "@codama/nodes";
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = isNode(typeNode, "enumTypeNode") && isDataEnum(typeNode);
+  const isDiscriminatedUnion = isNode12(typeNode, "enumTypeNode") && isDataEnum(typeNode);
   if (!isDiscriminatedUnion) {
     return fragment("");
   }
@@ -1625,6 +1758,57 @@ function mergeManifests(manifests, options = {}) {
     value: merge((m) => m.value, mergeValues)
   };
 }
+
+// src/getRenderMapVisitor.ts
+import { join as join3 } from "node:path";
+import { logWarn } from "@codama/errors";
+import {
+  camelCase as camelCase12,
+  definedTypeNode as definedTypeNode2,
+  getAllAccounts,
+  getAllDefinedTypes,
+  getAllInstructionsWithSubs as getAllInstructionsWithSubs2,
+  getAllPdas,
+  getAllPrograms,
+  resolveNestedTypeNode as resolveNestedTypeNode3,
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
+} from "@codama/nodes";
+import { RenderMap } from "@codama/renderers-core";
+import {
+  extendVisitor as extendVisitor2,
+  findProgramNodeFromPath as findProgramNodeFromPath7,
+  getResolvedInstructionInputsVisitor,
+  LinkableDictionary as LinkableDictionary3,
+  NodeStack as NodeStack2,
+  pipe as pipe2,
+  recordLinkablesOnFirstVisitVisitor,
+  recordNodeStackVisitor as recordNodeStackVisitor2,
+  staticVisitor as staticVisitor2,
+  visit as visit6
+} from "@codama/visitors-core";
+
+// src/getTypeManifestVisitor.ts
+import {
+  camelCase as camelCase10,
+  isNode as isNode13,
+  isNodeFilter as isNodeFilter6,
+  isScalarEnum,
+  REGISTERED_TYPE_NODE_KINDS,
+  REGISTERED_VALUE_NODE_KINDS,
+  resolveNestedTypeNode as resolveNestedTypeNode2,
+  structFieldTypeNode,
+  structTypeNode,
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3
+} from "@codama/nodes";
+import {
+  extendVisitor,
+  findLastNodeFromPath,
+  NodeStack,
+  pipe,
+  recordNodeStackVisitor,
+  staticVisitor,
+  visit as visit5
+} from "@codama/visitors-core";
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
   const stack = input.stack ?? new NodeStack();
@@ -1657,15 +1841,15 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(account.name)
         };
         const link = customAccountData.get(account.name)?.linkNode;
-        const manifest = link ? visit(link, self) : visit(account.data, self);
+        const manifest = link ? visit5(link, self) : visit5(account.data, self);
         parentName = null;
         return manifest;
       },
       visitAmountType(amountType, { self }) {
-        return visit(amountType.number, self);
+        return visit5(amountType.number, self);
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = visit(arrayType.item, self);
+        const childManifest = visit5(arrayType.item, self);
         childManifest.looseType.mapRender((r) => `Array<${r}>`);
         childManifest.strictType.mapRender((r) => `Array<${r}>`);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
@@ -1677,7 +1861,7 @@ function getTypeManifestVisitor(input) {
       },
       visitArrayValue(node, { self }) {
         return mergeManifests(
-          node.items.map((v) => visit(v, self)),
+          node.items.map((v) => visit5(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
@@ -1686,9 +1870,9 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap().add("solanaCodecsDataStructures", "getBooleanDecoder");
         let sizeEncoder = "";
         let sizeDecoder = "";
-        const resolvedSize = resolveNestedTypeNode(booleanType.size);
+        const resolvedSize = resolveNestedTypeNode2(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
-          const size = visit(booleanType.size, self);
+          const size = visit5(booleanType.size, self);
           encoderImports.mergeWith(size.encoder);
           decoderImports.mergeWith(size.decoder);
           sizeEncoder = `{ size: ${size.encoder.render} }`;
@@ -1737,26 +1921,26 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitConstantValue(node, { self }) {
-        if (isNode(node.type, "bytesTypeNode") && isNode(node.value, "bytesValueNode")) {
-          return visit(node.value, self);
+        if (isNode13(node.type, "bytesTypeNode") && isNode13(node.value, "bytesValueNode")) {
+          return visit5(node.value, self);
         }
         return {
           ...typeManifest(),
           value: mergeFragments(
-            [visit(node.type, self).encoder, visit(node.value, self).value],
+            [visit5(node.type, self).encoder, visit5(node.value, self).value],
             ([encoderFunction, value]) => `${encoderFunction}.encode(${value})`
           )
         };
       },
       visitDateTimeType(dateTimeType, { self }) {
-        return visit(dateTimeType.number, self);
+        return visit5(dateTimeType.number, self);
       },
       visitDefinedType(definedType, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(definedType.name),
           strict: nameApi.dataType(definedType.name)
         };
-        const manifest = visit(definedType.type, self);
+        const manifest = visit5(definedType.type, self);
         parentName = null;
         return manifest;
       },
@@ -1776,7 +1960,7 @@ function getTypeManifestVisitor(input) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase10(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return {
@@ -1797,12 +1981,12 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase(currentParentName?.strict ?? "")
+          camelCase10(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         parentName = null;
-        const structManifest = visit(enumStructVariantType.struct, self);
+        const structManifest = visit5(enumStructVariantType.struct, self);
         parentName = currentParentName;
         structManifest.strictType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
         structManifest.looseType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
@@ -1813,7 +1997,7 @@ function getTypeManifestVisitor(input) {
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase(currentParentName?.strict ?? "")
+          camelCase10(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -1824,7 +2008,7 @@ function getTypeManifestVisitor(input) {
           })
         ]);
         parentName = null;
-        const structManifest = visit(struct, self);
+        const structManifest = visit5(struct, self);
         parentName = currentParentName;
         structManifest.strictType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
         structManifest.looseType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
@@ -1838,16 +2022,16 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap();
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = resolveNestedTypeNode(enumType.size);
+        const enumSize = resolveNestedTypeNode2(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
-          const sizeManifest = visit(enumType.size, self);
+          const sizeManifest = visit5(enumType.size, self);
           encoderImports.mergeWith(sizeManifest.encoder);
           decoderImports.mergeWith(sizeManifest.decoder);
           encoderOptions.push(`size: ${sizeManifest.encoder.render}`);
           decoderOptions.push(`size: ${sizeManifest.decoder.render}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase(currentParentName?.strict ?? "")
+          camelCase10(currentParentName?.strict ?? "")
         );
         if (!isScalarEnum(enumType) && discriminator !== "__kind") {
           encoderOptions.push(`discriminator: '${discriminator}'`);
@@ -1878,7 +2062,7 @@ function getTypeManifestVisitor(input) {
           };
         }
         const mergedManifest = mergeManifests(
-          enumType.variants.map((variant) => visit(variant, self)),
+          enumType.variants.map((variant) => visit5(variant, self)),
           {
             mergeCodecs: (renders) => renders.join(", "),
             mergeTypes: (renders) => renders.join(" | ")
@@ -1894,7 +2078,7 @@ function getTypeManifestVisitor(input) {
         const enumFunction = nameApi.discriminatedUnionFunction(node.enum.name);
         const importFrom = getImportFrom(node.enum);
         const enumNode = linkables.get([...stack.getPath(), node.enum])?.type;
-        const isScalar = enumNode && isNode(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && isNode13(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
           manifest.value.setRender(`${enumName}.${variantName2}`).addImports(importFrom, enumName);
@@ -1905,18 +2089,18 @@ function getTypeManifestVisitor(input) {
           manifest.value.setRender(`${enumFunction}('${variantName}')`).addImports(importFrom, enumFunction);
           return manifest;
         }
-        manifest.value = visit(node.value, self).value.mapRender((r) => `${enumFunction}('${variantName}', ${r})`).addImports(importFrom, enumFunction);
+        manifest.value = visit5(node.value, self).value.mapRender((r) => `${enumFunction}('${variantName}', ${r})`).addImports(importFrom, enumFunction);
         return manifest;
       },
       visitFixedSizeType(node, { self }) {
-        const manifest = visit(node.type, self);
+        const manifest = visit5(node.type, self);
         manifest.encoder.mapRender((r) => `fixEncoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixEncoderSize");
         manifest.decoder.mapRender((r) => `fixDecoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixDecoderSize");
         return manifest;
       },
       visitHiddenPrefixType(node, { self }) {
-        const manifest = visit(node.type, self);
-        const prefixes = node.prefix.map((c) => visit(c, self).value);
+        const manifest = visit5(node.type, self);
+        const prefixes = node.prefix.map((c) => visit5(c, self).value);
         const prefixEncoders = fragment(prefixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...prefixes);
         const prefixDecoders = fragment(prefixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...prefixes);
         manifest.encoder.mapRender((r) => `getHiddenPrefixEncoder(${r}, [${prefixEncoders.render}])`).mergeImportsWith(prefixEncoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixEncoder");
@@ -1924,8 +2108,8 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitHiddenSuffixType(node, { self }) {
-        const manifest = visit(node.type, self);
-        const suffixes = node.suffix.map((c) => visit(c, self).value);
+        const manifest = visit5(node.type, self);
+        const suffixes = node.suffix.map((c) => visit5(c, self).value);
         const suffixEncoders = fragment(suffixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...suffixes);
         const suffixDecoders = fragment(suffixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...suffixes);
         manifest.encoder.mapRender((r) => `getHiddenSuffixEncoder(${r}, [${suffixEncoders.render}])`).mergeImportsWith(suffixEncoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixEncoder");
@@ -1939,19 +2123,19 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = structTypeNodeFromInstructionArgumentNodes(instruction.arguments);
-        const manifest = link ? visit(link, self) : visit(struct, self);
+        const struct = structTypeNodeFromInstructionArgumentNodes3(instruction.arguments);
+        const manifest = link ? visit5(link, self) : visit5(struct, self);
         parentName = null;
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeManifests([visit(node.key, self), visit(node.value, self)], {
+        return mergeManifests([visit5(node.key, self), visit5(node.value, self)], {
           mergeValues: (renders) => `[${renders.join(", ")}]`
         });
       },
       visitMapType(mapType, { self }) {
-        const key = visit(mapType.key, self);
-        const value = visit(mapType.value, self);
+        const key = visit5(mapType.key, self);
+        const value = visit5(mapType.value, self);
         const mergedManifest = mergeManifests([key, value], {
           mergeCodecs: ([k, v]) => `${k}, ${v}`,
           mergeTypes: ([k, v]) => `Map<${k}, ${v}>`
@@ -1964,7 +2148,7 @@ function getTypeManifestVisitor(input) {
         return mergedManifest;
       },
       visitMapValue(node, { self }) {
-        const entryFragments = node.entries.map((entry) => visit(entry, self));
+        const entryFragments = node.entries.map((entry) => visit5(entry, self));
         return mergeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
@@ -2001,14 +2185,14 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visit(optionType.item, self);
+        const childManifest = visit5(optionType.item, self);
         childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = resolveNestedTypeNode(optionType.prefix);
+        const optionPrefix = resolveNestedTypeNode2(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = visit(optionType.prefix, self);
+          const prefixManifest = visit5(optionType.prefix, self);
           childManifest.encoder.mergeImportsWith(prefixManifest.encoder);
           childManifest.decoder.mergeImportsWith(prefixManifest.decoder);
           encoderOptions.push(`prefix: ${prefixManifest.encoder.render}`);
@@ -2025,7 +2209,7 @@ function getTypeManifestVisitor(input) {
         return childManifest;
       },
       visitPostOffsetType(node, { self }) {
-        const manifest = visit(node.type, self);
+        const manifest = visit5(node.type, self);
         if (node.strategy === "padded") {
           manifest.encoder.mapRender((r) => `padRightEncoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padRightEncoder");
           manifest.decoder.mapRender((r) => `padRightDecoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padRightDecoder");
@@ -2047,7 +2231,7 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitPreOffsetType(node, { self }) {
-        const manifest = visit(node.type, self);
+        const manifest = visit5(node.type, self);
         if (node.strategy === "padded") {
           manifest.encoder.mapRender((r) => `padLeftEncoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padLeftEncoder");
           manifest.decoder.mapRender((r) => `padLeftDecoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padLeftDecoder");
@@ -2083,7 +2267,7 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = visit(node.item, self);
+        const childManifest = visit5(node.item, self);
         childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = ["prefix: null"];
@@ -2095,14 +2279,14 @@ function getTypeManifestVisitor(input) {
         return childManifest;
       },
       visitSentinelType(node, { self }) {
-        const manifest = visit(node.type, self);
-        const sentinel = visit(node.sentinel, self).value;
+        const manifest = visit5(node.type, self);
+        const sentinel = visit5(node.sentinel, self).value;
         manifest.encoder.mapRender((r) => `addEncoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addEncoderSentinel");
         manifest.decoder.mapRender((r) => `addDecoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addDecoderSentinel");
         return manifest;
       },
       visitSetType(setType, { self }) {
-        const childManifest = visit(setType.item, self);
+        const childManifest = visit5(setType.item, self);
         childManifest.strictType.mapRender((r) => `Set<${r}>`);
         childManifest.looseType.mapRender((r) => `Set<${r}>`);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
@@ -2114,19 +2298,19 @@ function getTypeManifestVisitor(input) {
       },
       visitSetValue(node, { self }) {
         return mergeManifests(
-          node.items.map((v) => visit(v, self)),
+          node.items.map((v) => visit5(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
       },
       visitSizePrefixType(node, { self }) {
-        const manifest = visit(node.type, self);
-        const prefix = visit(node.prefix, self);
+        const manifest = visit5(node.type, self);
+        const prefix = visit5(node.prefix, self);
         manifest.encoder.mapRender((r) => `addEncoderSizePrefix(${r}, ${prefix.encoder.render})`).mergeImportsWith(prefix.encoder).addImports("solanaCodecsCore", "addEncoderSizePrefix");
         manifest.decoder.mapRender((r) => `addDecoderSizePrefix(${r}, ${prefix.decoder.render})`).mergeImportsWith(prefix.decoder).addImports("solanaCodecsCore", "addDecoderSizePrefix");
         return manifest;
       },
       visitSolAmountType({ number }, { self }) {
-        const numberManifest = visit(number, self);
+        const numberManifest = visit5(number, self);
         const lamportsType = "Lamports";
         const lamportsImport = new ImportMap().add("solanaRpcTypes", "type Lamports");
         return {
@@ -2139,7 +2323,7 @@ function getTypeManifestVisitor(input) {
       },
       visitSomeValue(node, { self }) {
         const manifest = typeManifest();
-        manifest.value = visit(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
+        manifest.value = visit5(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
         return manifest;
       },
       visitStringType(stringType) {
@@ -2172,8 +2356,8 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = camelCase(structFieldType.name);
-        const childManifest = visit(structFieldType.type, self);
+        const name = camelCase10(structFieldType.name);
+        const childManifest = visit5(structFieldType.type, self);
         const docblock = structFieldType.docs.length > 0 ? `
 ${jsDocblock(structFieldType.docs)}` : "";
         const originalLooseType = childManifest.looseType.render;
@@ -2193,13 +2377,13 @@ ${jsDocblock(structFieldType.docs)}` : "";
       },
       visitStructFieldValue(node, { self }) {
         const manifest = typeManifest();
-        manifest.value = visit(node.value, self).value.mapRender((r) => `${node.name}: ${r}`);
+        manifest.value = visit5(node.value, self).value.mapRender((r) => `${node.name}: ${r}`);
         return manifest;
       },
       visitStructType(structType, { self }) {
         const optionalFields = structType.fields.filter((f) => !!f.defaultValue);
         const mergedManifest = mergeManifests(
-          structType.fields.map((field) => visit(field, self)),
+          structType.fields.map((field) => visit5(field, self)),
           {
             mergeCodecs: (renders) => `([${renders.join(", ")}])`,
             mergeTypes: (renders) => `{ ${renders.join("")} }`
@@ -2215,15 +2399,15 @@ ${jsDocblock(structFieldType.docs)}` : "";
         const accountNode = findLastNodeFromPath(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
-        const fieldDiscriminators = discriminators.filter(isNodeFilter("fieldDiscriminatorNode"));
+        const fieldDiscriminators = discriminators.filter(isNodeFilter6("fieldDiscriminatorNode"));
         const defaultValues = optionalFields.map((f) => {
-          const key = camelCase(f.name);
+          const key = camelCase10(f.name);
           if (fieldDiscriminators.some((d) => d.name === f.name)) {
-            const constantName = nameApi.constant(camelCase(`${discriminatorPrefix}_${f.name}`));
+            const constantName = nameApi.constant(camelCase10(`${discriminatorPrefix}_${f.name}`));
             return f.defaultValueStrategy === "omitted" ? `${key}: ${constantName}` : `${key}: value.${key} ?? ${constantName}`;
           }
           const defaultValue = f.defaultValue;
-          const { render: renderedValue, imports } = visit(defaultValue, self).value;
+          const { render: renderedValue, imports } = visit5(defaultValue, self).value;
           mergedManifest.encoder.mergeImportsWith(imports);
           return f.defaultValueStrategy === "omitted" ? `${key}: ${renderedValue}` : `${key}: value.${key} ?? ${renderedValue}`;
         }).join(", ");
@@ -2232,12 +2416,12 @@ ${jsDocblock(structFieldType.docs)}` : "";
       },
       visitStructValue(node, { self }) {
         return mergeManifests(
-          node.fields.map((field) => visit(field, self)),
+          node.fields.map((field) => visit5(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visit(item, self));
+        const items = tupleType.items.map((item) => visit5(item, self));
         const mergedManifest = mergeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
@@ -2248,18 +2432,18 @@ ${jsDocblock(structFieldType.docs)}` : "";
       },
       visitTupleValue(node, { self }) {
         return mergeManifests(
-          node.items.map((v) => visit(v, self)),
+          node.items.map((v) => visit5(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = visit(node.item, self);
+        const childManifest = visit5(node.item, self);
         childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
         if (node.zeroValue) {
-          const zeroValueManifest = visit(node.zeroValue, self);
+          const zeroValueManifest = visit5(node.zeroValue, self);
           childManifest.encoder.mergeImportsWith(zeroValueManifest.value);
           childManifest.decoder.mergeImportsWith(zeroValueManifest.value);
           encoderOptions.push(`noneValue: ${zeroValueManifest.value.render}`);
@@ -2279,93 +2463,96 @@ ${jsDocblock(structFieldType.docs)}` : "";
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if (isNode(count, "fixedCountNode")) {
+  if (isNode13(count, "fixedCountNode")) {
     return {
       decoder: fragment(`size: ${count.value}`),
       encoder: fragment(`size: ${count.value}`)
     };
   }
-  if (isNode(count, "remainderCountNode")) {
+  if (isNode13(count, "remainderCountNode")) {
     return {
       decoder: fragment(`size: 'remainder'`),
       encoder: fragment(`size: 'remainder'`)
     };
   }
-  const prefix = resolveNestedTypeNode(count.prefix);
+  const prefix = resolveNestedTypeNode2(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: fragment(""), encoder: fragment("") };
   }
-  const prefixManifest = visit(count.prefix, visitor);
+  const prefixManifest = visit5(count.prefix, visitor);
   prefixManifest.encoder.mapRender((r) => `size: ${r}`);
   prefixManifest.decoder.mapRender((r) => `size: ${r}`);
   return prefixManifest;
 }
+
+// src/nameTransformers.ts
+import { camelCase as camelCase11, capitalize, kebabCase as kebabCase2, pascalCase as pascalCase7, snakeCase as snakeCase2, titleCase as titleCase2 } from "@codama/nodes";
 function getNameApi(transformers) {
   const helpers = {
-    camelCase: camelCase,
+    camelCase: camelCase11,
     capitalize,
-    kebabCase: kebabCase,
-    pascalCase: pascalCase,
-    snakeCase: snakeCase,
-    titleCase: titleCase
+    kebabCase: kebabCase2,
+    pascalCase: pascalCase7,
+    snakeCase: snakeCase2,
+    titleCase: titleCase2
   };
   return Object.fromEntries(
     Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
   );
 }
 var DEFAULT_NAME_TRANSFORMERS = {
-  accountDecodeFunction: (name) => `decode${pascalCase(name)}`,
-  accountFetchAllFunction: (name) => `fetchAll${pascalCase(name)}`,
-  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${pascalCase(name)}`,
-  accountFetchFromSeedsFunction: (name) => `fetch${pascalCase(name)}FromSeeds`,
-  accountFetchFunction: (name) => `fetch${pascalCase(name)}`,
-  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${pascalCase(name)}FromSeeds`,
-  accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase(name)}`,
-  accountGetSizeFunction: (name) => `get${pascalCase(name)}Size`,
-  codecFunction: (name) => `get${pascalCase(name)}Codec`,
-  constant: (name) => snakeCase(name).toUpperCase(),
-  constantFunction: (name) => `get${pascalCase(name)}Bytes`,
-  dataArgsType: (name) => `${pascalCase(name)}Args`,
-  dataType: (name) => `${pascalCase(name)}`,
-  decoderFunction: (name) => `get${pascalCase(name)}Decoder`,
+  accountDecodeFunction: (name) => `decode${pascalCase7(name)}`,
+  accountFetchAllFunction: (name) => `fetchAll${pascalCase7(name)}`,
+  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${pascalCase7(name)}`,
+  accountFetchFromSeedsFunction: (name) => `fetch${pascalCase7(name)}FromSeeds`,
+  accountFetchFunction: (name) => `fetch${pascalCase7(name)}`,
+  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${pascalCase7(name)}FromSeeds`,
+  accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase7(name)}`,
+  accountGetSizeFunction: (name) => `get${pascalCase7(name)}Size`,
+  codecFunction: (name) => `get${pascalCase7(name)}Codec`,
+  constant: (name) => snakeCase2(name).toUpperCase(),
+  constantFunction: (name) => `get${pascalCase7(name)}Bytes`,
+  dataArgsType: (name) => `${pascalCase7(name)}Args`,
+  dataType: (name) => `${pascalCase7(name)}`,
+  decoderFunction: (name) => `get${pascalCase7(name)}Decoder`,
   discriminatedUnionDiscriminator: () => "__kind",
-  discriminatedUnionFunction: (name) => `${camelCase(name)}`,
-  discriminatedUnionVariant: (name) => `${pascalCase(name)}`,
-  encoderFunction: (name) => `get${pascalCase(name)}Encoder`,
-  enumVariant: (name) => `${pascalCase(name)}`,
-  instructionAsyncFunction: (name) => `get${pascalCase(name)}InstructionAsync`,
-  instructionAsyncInputType: (name) => `${pascalCase(name)}AsyncInput`,
-  instructionDataType: (name) => `${pascalCase(name)}InstructionData`,
-  instructionExtraType: (name) => `${pascalCase(name)}InstructionExtra`,
-  instructionParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
-  instructionParsedType: (name) => `Parsed${pascalCase(name)}Instruction`,
-  instructionSyncFunction: (name) => `get${pascalCase(name)}Instruction`,
-  instructionSyncInputType: (name) => `${pascalCase(name)}Input`,
-  instructionType: (name) => `${pascalCase(name)}Instruction`,
-  isDiscriminatedUnionFunction: (name) => `is${pascalCase(name)}`,
-  pdaFindFunction: (name) => `find${pascalCase(name)}Pda`,
-  pdaSeedsType: (name) => `${pascalCase(name)}Seeds`,
-  programAccountsEnum: (name) => `${pascalCase(name)}Account`,
-  programAccountsEnumVariant: (name) => `${pascalCase(name)}`,
-  programAccountsIdentifierFunction: (name) => `identify${pascalCase(name)}Account`,
-  programAddressConstant: (name) => `${snakeCase(name).toUpperCase()}_PROGRAM_ADDRESS`,
-  programErrorConstant: (name) => snakeCase(name).toUpperCase(),
-  programErrorConstantPrefix: (name) => `${snakeCase(name).toUpperCase()}_ERROR__`,
-  programErrorMessagesMap: (name) => `${camelCase(name)}ErrorMessages`,
-  programErrorUnion: (name) => `${pascalCase(name)}Error`,
-  programGetErrorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
-  programInstructionsEnum: (name) => `${pascalCase(name)}Instruction`,
-  programInstructionsEnumVariant: (name) => `${pascalCase(name)}`,
-  programInstructionsIdentifierFunction: (name) => `identify${pascalCase(name)}Instruction`,
-  programInstructionsParsedUnionType: (name) => `Parsed${pascalCase(name)}Instruction`,
-  programIsErrorFunction: (name) => `is${pascalCase(name)}Error`,
-  resolverFunction: (name) => `${camelCase(name)}`
+  discriminatedUnionFunction: (name) => `${camelCase11(name)}`,
+  discriminatedUnionVariant: (name) => `${pascalCase7(name)}`,
+  encoderFunction: (name) => `get${pascalCase7(name)}Encoder`,
+  enumVariant: (name) => `${pascalCase7(name)}`,
+  instructionAsyncFunction: (name) => `get${pascalCase7(name)}InstructionAsync`,
+  instructionAsyncInputType: (name) => `${pascalCase7(name)}AsyncInput`,
+  instructionDataType: (name) => `${pascalCase7(name)}InstructionData`,
+  instructionExtraType: (name) => `${pascalCase7(name)}InstructionExtra`,
+  instructionParseFunction: (name) => `parse${pascalCase7(name)}Instruction`,
+  instructionParsedType: (name) => `Parsed${pascalCase7(name)}Instruction`,
+  instructionSyncFunction: (name) => `get${pascalCase7(name)}Instruction`,
+  instructionSyncInputType: (name) => `${pascalCase7(name)}Input`,
+  instructionType: (name) => `${pascalCase7(name)}Instruction`,
+  isDiscriminatedUnionFunction: (name) => `is${pascalCase7(name)}`,
+  pdaFindFunction: (name) => `find${pascalCase7(name)}Pda`,
+  pdaSeedsType: (name) => `${pascalCase7(name)}Seeds`,
+  programAccountsEnum: (name) => `${pascalCase7(name)}Account`,
+  programAccountsEnumVariant: (name) => `${pascalCase7(name)}`,
+  programAccountsIdentifierFunction: (name) => `identify${pascalCase7(name)}Account`,
+  programAddressConstant: (name) => `${snakeCase2(name).toUpperCase()}_PROGRAM_ADDRESS`,
+  programErrorConstant: (name) => snakeCase2(name).toUpperCase(),
+  programErrorConstantPrefix: (name) => `${snakeCase2(name).toUpperCase()}_ERROR__`,
+  programErrorMessagesMap: (name) => `${camelCase11(name)}ErrorMessages`,
+  programErrorUnion: (name) => `${pascalCase7(name)}Error`,
+  programGetErrorMessageFunction: (name) => `get${pascalCase7(name)}ErrorMessage`,
+  programInstructionsEnum: (name) => `${pascalCase7(name)}Instruction`,
+  programInstructionsEnumVariant: (name) => `${pascalCase7(name)}`,
+  programInstructionsIdentifierFunction: (name) => `identify${pascalCase7(name)}Instruction`,
+  programInstructionsParsedUnionType: (name) => `Parsed${pascalCase7(name)}Instruction`,
+  programIsErrorFunction: (name) => `is${pascalCase7(name)}Error`,
+  resolverFunction: (name) => `${camelCase11(name)}`
 };
 
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
-  const linkables = new LinkableDictionary();
-  const stack = new NodeStack();
+  const linkables = new LinkableDictionary3();
+  const stack = new NodeStack2();
   const nameTransformers = {
     ...DEFAULT_NAME_TRANSFORMERS,
     ...options.nameTransformers
@@ -2374,9 +2561,9 @@ function getRenderMapVisitor(options = {}) {
   const renderParentInstructions = options.renderParentInstructions ?? false;
   const dependencyMap = options.dependencyMap ?? {};
   const useGranularImports = options.useGranularImports ?? false;
-  const asyncResolvers = (options.asyncResolvers ?? []).map(camelCase);
-  const nonScalarEnums = (options.nonScalarEnums ?? []).map(camelCase);
-  const internalNodes = (options.internalNodes ?? []).map(camelCase);
+  const asyncResolvers = (options.asyncResolvers ?? []).map(camelCase12);
+  const nonScalarEnums = (options.nonScalarEnums ?? []).map(camelCase12);
+  const internalNodes = (options.internalNodes ?? []).map(camelCase12);
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const getImportFrom = getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData);
@@ -2402,24 +2589,24 @@ function getRenderMapVisitor(options = {}) {
     typeManifestVisitor
   };
   const render2 = (template, context, renderOptions) => {
-    return render(join("pages", template), context, renderOptions);
+    return render(join3("pages", template), context, renderOptions);
   };
-  return pipe(
-    staticVisitor(() => new RenderMap(), {
+  return pipe2(
+    staticVisitor2(() => new RenderMap(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
-    (v) => extendVisitor(v, {
+    (v) => extendVisitor2(v, {
       visitAccount(node) {
         const accountPath = stack.getPath("accountNode");
-        if (!findProgramNodeFromPath(accountPath)) {
+        if (!findProgramNodeFromPath7(accountPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = {
           ...globalScope,
           accountPath,
-          typeManifest: visit(node, typeManifestVisitor)
+          typeManifest: visit6(node, typeManifestVisitor)
         };
-        const fields = resolveNestedTypeNode(node.data).fields;
+        const fields = resolveNestedTypeNode3(node.data).fields;
         const accountDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
           discriminatorNodes: node.discriminators ?? [],
@@ -2438,7 +2625,7 @@ function getRenderMapVisitor(options = {}) {
           accountPdaHelpersFragment
         );
         return new RenderMap().add(
-          `accounts/${camelCase(node.name)}.ts`,
+          `accounts/${camelCase12(node.name)}.ts`,
           render2("accountsPage.njk", {
             accountDiscriminatorConstantsFragment,
             accountFetchHelpersFragment,
@@ -2455,7 +2642,7 @@ function getRenderMapVisitor(options = {}) {
           codecDocs: [],
           decoderDocs: [],
           encoderDocs: [],
-          manifest: visit(node, typeManifestVisitor),
+          manifest: visit6(node, typeManifestVisitor),
           name: node.name,
           typeDocs: node.docs,
           typeNode: node.type
@@ -2470,7 +2657,7 @@ function getRenderMapVisitor(options = {}) {
           nameApi.codecFunction(node.name)
         ]);
         return new RenderMap().add(
-          `types/${camelCase(node.name)}.ts`,
+          `types/${camelCase12(node.name)}.ts`,
           render2("definedTypesPage.njk", {
             imports: imports.toString({
               ...dependencyMap,
@@ -2483,23 +2670,23 @@ function getRenderMapVisitor(options = {}) {
       },
       visitInstruction(node) {
         const instructionPath = stack.getPath("instructionNode");
-        if (!findProgramNodeFromPath(instructionPath)) {
+        if (!findProgramNodeFromPath7(instructionPath)) {
           throw new Error("Instruction must be visited inside a program.");
         }
         const instructionExtraName = nameApi.instructionExtraType(node.name);
         const scope = {
           ...globalScope,
-          dataArgsManifest: visit(node, typeManifestVisitor),
-          extraArgsManifest: visit(
-            definedTypeNode({
+          dataArgsManifest: visit6(node, typeManifestVisitor),
+          extraArgsManifest: visit6(
+            definedTypeNode2({
               name: instructionExtraName,
-              type: structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? [])
+              type: structTypeNodeFromInstructionArgumentNodes4(node.extraArguments ?? [])
             }),
             typeManifestVisitor
           ),
           instructionPath,
           renamedArgs: getRenamedArgsMap(node),
-          resolvedInputs: visit(node, resolvedInstructionInputVisitor)
+          resolvedInputs: visit6(node, resolvedInstructionInputVisitor)
         };
         const instructionDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
@@ -2529,7 +2716,7 @@ function getRenderMapVisitor(options = {}) {
           instructionParseFunctionFragment
         );
         return new RenderMap().add(
-          `instructions/${camelCase(node.name)}.ts`,
+          `instructions/${camelCase12(node.name)}.ts`,
           render2("instructionsPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             instruction: node,
@@ -2545,14 +2732,14 @@ function getRenderMapVisitor(options = {}) {
       },
       visitPda(node) {
         const pdaPath = stack.getPath("pdaNode");
-        if (!findProgramNodeFromPath(pdaPath)) {
+        if (!findProgramNodeFromPath7(pdaPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = { ...globalScope, pdaPath };
         const pdaFunctionFragment = getPdaFunctionFragment(scope);
         const imports = new ImportMap().mergeWith(pdaFunctionFragment);
         return new RenderMap().add(
-          `pdas/${camelCase(node.name)}.ts`,
+          `pdas/${camelCase12(node.name)}.ts`,
           render2("pdasPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             pdaFunctionFragment
@@ -2565,11 +2752,11 @@ function getRenderMapVisitor(options = {}) {
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
         ];
         const scope = { ...globalScope, programNode: node };
-        const renderMap = new RenderMap().mergeWith(...node.pdas.map((p) => visit(p, self))).mergeWith(...node.accounts.map((a) => visit(a, self))).mergeWith(...node.definedTypes.map((t) => visit(t, self))).mergeWith(...customDataDefinedType.map((t) => visit(t, self)));
+        const renderMap = new RenderMap().mergeWith(...node.pdas.map((p) => visit6(p, self))).mergeWith(...node.accounts.map((a) => visit6(a, self))).mergeWith(...node.definedTypes.map((t) => visit6(t, self))).mergeWith(...customDataDefinedType.map((t) => visit6(t, self)));
         if (node.errors.length > 0) {
           const programErrorsFragment = getProgramErrorsFragment(scope);
           renderMap.add(
-            `errors/${camelCase(node.name)}.ts`,
+            `errors/${camelCase12(node.name)}.ts`,
             render2("errorsPage.njk", {
               imports: new ImportMap().mergeWith(programErrorsFragment).toString(dependencyMap, useGranularImports),
               programErrorsFragment
@@ -2580,7 +2767,7 @@ function getRenderMapVisitor(options = {}) {
         const programAccountsFragment = getProgramAccountsFragment(scope);
         const programInstructionsFragment = getProgramInstructionsFragment(scope);
         renderMap.add(
-          `programs/${camelCase(node.name)}.ts`,
+          `programs/${camelCase12(node.name)}.ts`,
           render2("programsPage.njk", {
             imports: new ImportMap().mergeWith(programFragment, programAccountsFragment, programInstructionsFragment).toString(dependencyMap, useGranularImports),
             programAccountsFragment,
@@ -2589,9 +2776,9 @@ function getRenderMapVisitor(options = {}) {
           })
         );
         renderMap.mergeWith(
-          ...getAllInstructionsWithSubs(node, {
+          ...getAllInstructionsWithSubs2(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => visit(ix, self))
+          }).map((ix) => visit6(ix, self))
         );
         return renderMap;
       },
@@ -2601,7 +2788,7 @@ function getRenderMapVisitor(options = {}) {
         const programsWithErrorsToExport = programsToExport.filter((p) => p.errors.length > 0);
         const pdasToExport = getAllPdas(node);
         const accountsToExport = getAllAccounts(node).filter(isNotInternal);
-        const instructionsToExport = getAllInstructionsWithSubs(node, {
+        const instructionsToExport = getAllInstructionsWithSubs2(node, {
           leavesOnly: !renderParentInstructions
         }).filter(isNotInternal);
         const definedTypesToExport = getAllDefinedTypes(node).filter(isNotInternal);
@@ -2656,10 +2843,10 @@ function getRenderMapVisitor(options = {}) {
         if (definedTypesToExport.length > 0) {
           map.add("types/index.ts", render2("definedTypesIndex.njk", ctx));
         }
-        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit(p, self)));
+        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit6(p, self)));
       }
     }),
-    (v) => recordNodeStackVisitor(v, stack),
+    (v) => recordNodeStackVisitor2(v, stack),
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
@@ -2678,8 +2865,15 @@ function getRenamedArgsMap(instruction) {
   logWarn(
     `[JavaScript] Accounts and args of instruction [${instruction.name}] have the following conflicting attributes [${duplicates.join(", ")}]. Thus, the arguments have been renamed to avoid conflicts in the input type.`
   );
-  return new Map(duplicates.map((name) => [camelCase(name), camelCase(`${name}Arg`)]));
+  return new Map(duplicates.map((name) => [camelCase12(name), camelCase12(`${name}Arg`)]));
 }
+
+// src/renderVisitor.ts
+import { deleteDirectory } from "@codama/renderers-core";
+import { rootNodeVisitor, visit as visit7 } from "@codama/visitors-core";
+import * as estreePlugin from "prettier/plugins/estree";
+import * as typeScriptPlugin from "prettier/plugins/typescript";
+import { format } from "prettier/standalone";
 var DEFAULT_PRETTIER_OPTIONS = {
   arrowParens: "always",
   parser: "typescript",
@@ -2696,7 +2890,7 @@ function renderVisitor(path, options = {}) {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    const renderMap = visit(root, getRenderMapVisitor(options));
+    const renderMap = visit7(root, getRenderMapVisitor(options));
     if (options.formatCode ?? true) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
       await renderMap.mapContentAsync((code) => format(code, prettierOptions));
@@ -2704,7 +2898,15 @@ function renderVisitor(path, options = {}) {
     renderMap.write(path);
   });
 }
-
-export { DEFAULT_NAME_TRANSFORMERS, ImportMap, renderVisitor as default, getNameApi, getRenderMapVisitor, getTypeManifestVisitor, mergeManifests, renderVisitor, typeManifest };
-//# sourceMappingURL=index.node.mjs.map
+export {
+  DEFAULT_NAME_TRANSFORMERS,
+  ImportMap,
+  renderVisitor as default,
+  getNameApi,
+  getRenderMapVisitor,
+  getTypeManifestVisitor,
+  mergeManifests,
+  renderVisitor,
+  typeManifest
+};
 //# sourceMappingURL=index.node.mjs.map