@codama/renderers-js 1.4.2 → 1.5.0

package/dist/index.browser.mjs

@@ -266,7 +266,7 @@ function mergeTypeManifests(manifests, options = {}) {
 
 // src/visitors/getRenderMapVisitor.ts
 import {
-  camelCase as camelCase14,
+  camelCase as camelCase15,
   getAllAccounts,
   getAllDefinedTypes,
   getAllInstructionsWithSubs as getAllInstructionsWithSubs2,
@@ -697,11 +697,15 @@ function getAccountTypeFragment(scope) {
   const accountNode = getLastNodeFromPath4(accountPath);
   if (customAccountData.has(accountNode.name)) return;
   return getTypeWithCodecFragment({
+    codecDocs: [`Gets the codec for {@link ${nameApi.dataType(accountNode.name)}} account data.`],
+    decoderDocs: [`Gets the decoder for {@link ${nameApi.dataType(accountNode.name)}} account data.`],
+    encoderDocs: [`Gets the encoder for {@link ${nameApi.dataArgsType(accountNode.name)}} account data.`],
     manifest: typeManifest2,
     name: accountNode.name,
     nameApi,
     node: resolveNestedTypeNode(accountNode.data),
-    size: scope.size
+    size: scope.size,
+    typeDocs: accountNode.docs
   });
 }
 
@@ -918,9 +922,10 @@ function getIsErrorFunctionFragment(scope) {
 }
 
 // src/fragments/indexPage.ts
+import { camelCase as camelCase4 } from "@codama/nodes";
 function getIndexPageFragment(items) {
   if (items.length === 0) return;
-  const names = items.map((item) => item.name).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
+  const names = items.map((item) => camelCase4(item.name)).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
   return mergeFragments(names, (cs) => cs.join("\n"));
 }
 
@@ -975,7 +980,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 }
 
 // src/fragments/instructionByteDelta.ts
-import { assertIsNode, camelCase as camelCase4, isNode as isNode7 } from "@codama/nodes";
+import { assertIsNode, camelCase as camelCase5, isNode as isNode7 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent2 } from "@codama/renderers-core";
 import { getLastNodeFromPath as getLastNodeFromPath7, pipe as pipe4 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
@@ -1019,7 +1024,7 @@ function getNumberValueNodeFragment(byteDelta) {
 }
 function getArgumentValueNodeFragment(byteDelta) {
   assertIsNode(byteDelta.value, "argumentValueNode");
-  const argumentName = camelCase4(byteDelta.value.name);
+  const argumentName = camelCase5(byteDelta.value.name);
   return fragment`Number(args.${argumentName})`;
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
@@ -1075,7 +1080,7 @@ function getInstructionExtraArgsFragment(scope) {
 }
 
 // src/fragments/instructionFunction.ts
-import { camelCase as camelCase9, isNode as isNode12, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
+import { camelCase as camelCase10, isNode as isNode12, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent7 } from "@codama/renderers-core";
 import {
   findProgramNodeFromPath as findProgramNodeFromPath3,
@@ -1084,12 +1089,12 @@ import {
 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputResolved.ts
-import { camelCase as camelCase6, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
+import { camelCase as camelCase7, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent5 } from "@codama/renderers-core";
 import { getLastNodeFromPath as getLastNodeFromPath10 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputDefault.ts
-import { camelCase as camelCase5, isNode as isNode8 } from "@codama/nodes";
+import { camelCase as camelCase6, isNode as isNode8 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent4, setFragmentContent } from "@codama/renderers-core";
 import { pipe as pipe5, visit as visit4 } from "@codama/visitors-core";
 function getInstructionInputDefaultFragment(scope) {
@@ -1102,7 +1107,7 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = camelCase5(input.name);
+    const inputName = camelCase6(input.name);
     if (input.kind === "instructionAccountNode" && isNode8(defaultValue, "resolverValueNode")) {
       return fragment`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`;
     }
@@ -1114,39 +1119,39 @@ function getInstructionInputDefaultFragment(scope) {
     }
     return fragment`args.${inputName} = ${renderedValue};`;
   };
+  const expectTransactionSigner = use("expectTransactionSigner", "shared");
+  const expectSome = use("expectSome", "shared");
+  const expectAddress = use("expectAddress", "shared");
+  const expectProgramDerivedAddress = use("expectProgramDerivedAddress", "shared");
+  const addressType = use("type Address", "solanaAddresses");
   switch (defaultValue.kind) {
     case "accountValueNode":
-      const name = camelCase5(defaultValue.name);
+      const name = camelCase6(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
-        return pipe5(
-          defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`),
-          (f) => addFragmentImports(f, "shared", ["expectTransactionSigner"])
-        );
+        return defaultFragment(fragment`${expectTransactionSigner}(accounts.${name}.value).address`);
       }
       if (input.kind === "instructionAccountNode") {
-        return pipe5(
-          defaultFragment(`expectSome(accounts.${name}.value)`),
-          (f) => addFragmentImports(f, "shared", ["expectSome"])
-        );
+        return defaultFragment(fragment`${expectSome}(accounts.${name}.value)`);
       }
-      return pipe5(
-        defaultFragment(`expectAddress(accounts.${name}.value)`),
-        (f) => addFragmentImports(f, "shared", ["expectAddress"])
-      );
+      return defaultFragment(fragment`${expectAddress}(accounts.${name}.value)`);
     case "pdaValueNode":
+      let pdaProgramValue;
+      if (isNode8(defaultValue.programId, "accountValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(accounts.${camelCase6(defaultValue.programId.name)}.value)`;
+      }
+      if (isNode8(defaultValue.programId, "argumentValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(args.${camelCase6(defaultValue.programId.name)})`;
+      }
       if (isNode8(defaultValue.pda, "pdaNode")) {
-        const pdaProgram = defaultValue.pda.programId ? pipe5(
-          fragment`'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`,
-          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-        ) : fragment`programAddress`;
+        let pdaProgram = fragment`programAddress`;
+        if (pdaProgramValue) {
+          pdaProgram = pdaProgramValue;
+        } else if (defaultValue.pda.programId) {
+          pdaProgram = fragment`'${defaultValue.pda.programId}' as ${addressType}<'${defaultValue.pda.programId}'>`;
+        }
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
           if (isNode8(seed, "constantPdaSeedNode") && isNode8(seed.value, "programIdValueNode")) {
-            return [
-              pipe5(
-                fragment`getAddressEncoder().encode(${pdaProgram})`,
-                (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
-              )
-            ];
+            return [fragment`${use("getAddressEncoder", "solanaAddresses")}().encode(${pdaProgram})`];
           }
           if (isNode8(seed, "constantPdaSeedNode") && !isNode8(seed.value, "programIdValueNode")) {
             const typeManifest2 = visit4(seed.type, typeManifestVisitor);
@@ -1159,18 +1164,12 @@ function getInstructionInputDefaultFragment(scope) {
             if (!valueSeed) return [];
             if (isNode8(valueSeed, "accountValueNode")) {
               return [
-                pipe5(
-                  fragment`${typeManifest2.encoder}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`,
-                  (f) => addFragmentImports(f, "shared", ["expectAddress"])
-                )
+                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${camelCase6(valueSeed.name)}.value))`
               ];
             }
             if (isNode8(valueSeed, "argumentValueNode")) {
               return [
-                pipe5(
-                  fragment`${typeManifest2.encoder}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`,
-                  (f) => addFragmentImports(f, "shared", ["expectSome"])
-                )
+                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${camelCase6(valueSeed.name)}))`
               ];
             }
             const valueManifest2 = visit4(valueSeed, typeManifestVisitor);
@@ -1178,29 +1177,21 @@ function getInstructionInputDefaultFragment(scope) {
           }
           return [];
         });
-        return pipe5(
-          mergeFragments([pdaProgram, ...pdaSeeds2], ([p, ...s]) => {
-            const programAddress2 = p === "programAddress" ? p : `programAddress: ${p}`;
-            return `await getProgramDerivedAddress({ ${programAddress2}, seeds: [${s.join(", ")}] })`;
-          }),
-          (f) => addFragmentImports(f, "solanaAddresses", ["getProgramDerivedAddress"]),
-          (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content)
+        const getProgramDerivedAddress = use("getProgramDerivedAddress", "solanaAddresses");
+        const programAddress2 = pdaProgram.content === "programAddress" ? pdaProgram : fragment`programAddress: ${pdaProgram}`;
+        const seeds = mergeFragments(pdaSeeds2, (s) => s.join(", "));
+        return defaultFragment(
+          fragment`await ${getProgramDerivedAddress}({ ${programAddress2}, seeds: [${seeds}] })`
         );
       }
-      const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
+      const pdaFunction = use(nameApi.pdaFindFunction(defaultValue.pda.name), getImportFrom(defaultValue.pda));
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
         if (isNode8(seed.value, "accountValueNode")) {
-          return pipe5(
-            fragment`${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`,
-            (f) => addFragmentImports(f, "shared", ["expectAddress"])
-          );
+          return fragment`${seed.name}: ${expectAddress}(accounts.${camelCase6(seed.value.name)}.value)`;
         }
         if (isNode8(seed.value, "argumentValueNode")) {
-          return pipe5(
-            fragment`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`,
-            (f) => addFragmentImports(f, "shared", ["expectSome"])
-          );
+          return fragment`${seed.name}: ${expectSome}(args.${camelCase6(seed.value.name)})`;
         }
         return pipe5(
           visit4(seed.value, typeManifestVisitor).value,
@@ -1212,49 +1203,38 @@ function getInstructionInputDefaultFragment(scope) {
         (f) => mapFragmentContent4(f, (c) => `{ ${c} }`)
       );
       if (pdaSeeds.length > 0) {
-        pdaArgs.push(pdaSeedsFragment.content);
+        pdaArgs.push(pdaSeedsFragment);
       }
-      const module = getImportFrom(defaultValue.pda);
-      return pipe5(
-        defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`),
-        (f) => mergeFragmentImports(f, [pdaSeedsFragment.imports]),
-        (f) => addFragmentImports(f, module, [pdaFunction])
-      );
+      if (pdaProgramValue) {
+        pdaArgs.push(fragment`{ programAddress: ${pdaProgramValue} }`);
+      }
+      return defaultFragment(fragment`await ${pdaFunction}(${mergeFragments(pdaArgs, (c) => c.join(", "))})`);
     case "publicKeyValueNode":
-      return pipe5(
-        defaultFragment(`'${defaultValue.publicKey}' as Address<'${defaultValue.publicKey}'>`),
-        (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+      return defaultFragment(
+        fragment`'${defaultValue.publicKey}' as ${addressType}<'${defaultValue.publicKey}'>`
       );
     case "programLinkNode":
-      const programAddress = nameApi.programAddressConstant(defaultValue.name);
-      return pipe5(
-        defaultFragment(programAddress, false),
-        (f) => addFragmentImports(f, getImportFrom(defaultValue), [programAddress])
-      );
+      const programAddress = use(nameApi.programAddressConstant(defaultValue.name), getImportFrom(defaultValue));
+      return defaultFragment(programAddress, false);
     case "programIdValueNode":
       if (optionalAccountStrategy === "programId" && input.kind === "instructionAccountNode" && input.isOptional) {
         return fragment``;
       }
-      return defaultFragment("programAddress", false);
+      return defaultFragment(fragment`programAddress`, false);
     case "identityValueNode":
     case "payerValueNode":
       return fragment``;
     case "accountBumpValueNode":
-      return pipe5(
-        defaultFragment(`expectProgramDerivedAddress(accounts.${camelCase5(defaultValue.name)}.value)[1]`),
-        (f) => addFragmentImports(f, "shared", ["expectProgramDerivedAddress"])
+      return defaultFragment(
+        fragment`${expectProgramDerivedAddress}(accounts.${camelCase6(defaultValue.name)}.value)[1]`
       );
     case "argumentValueNode":
-      return pipe5(
-        defaultFragment(`expectSome(args.${camelCase5(defaultValue.name)})`),
-        (f) => addFragmentImports(f, "shared", ["expectSome"])
-      );
+      return defaultFragment(fragment`${expectSome}(args.${camelCase6(defaultValue.name)})`);
     case "resolverValueNode":
-      const resolverFunction = nameApi.resolverFunction(defaultValue.name);
+      const resolverFunction = use(nameApi.resolverFunction(defaultValue.name), getImportFrom(defaultValue));
       const resolverAwait = useAsync && asyncResolvers.includes(defaultValue.name) ? "await " : "";
       return pipe5(
-        defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
-        (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
+        defaultFragment(fragment`${resolverAwait}${resolverFunction}(resolverScope)`),
         (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
       );
     case "conditionalValueNode":
@@ -1280,17 +1260,17 @@ function getInstructionInputDefaultFragment(scope) {
       let condition = "true";
       if (isNode8(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
-        const module2 = getImportFrom(defaultValue.condition);
+        const module = getImportFrom(defaultValue.condition);
         conditionalFragment = pipe5(
           conditionalFragment,
-          (f) => addFragmentImports(f, module2, [conditionalResolverFunction]),
+          (f) => addFragmentImports(f, module, [conditionalResolverFunction]),
           (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
         );
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
-        const comparedInputName = isNode8(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase5(defaultValue.condition.name)}.value` : `args.${camelCase5(defaultValue.condition.name)}`;
+        const comparedInputName = isNode8(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase6(defaultValue.condition.name)}.value` : `args.${camelCase6(defaultValue.condition.name)}`;
         if (defaultValue.value) {
           const comparedValue = visit4(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
@@ -1318,7 +1298,7 @@ ${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
       );
     default:
       const valueManifest = visit4(defaultValue, typeManifestVisitor).value;
-      return pipe5(valueManifest, (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content));
+      return defaultFragment(valueManifest);
   }
 }
 function renderNestedInstructionDefault(scope) {
@@ -1340,7 +1320,7 @@ function getInstructionInputResolvedFragment(scope) {
       optionalAccountStrategy: parseOptionalAccountStrategy(instructionNode.optionalAccountStrategy)
     });
     if (!inputFragment.content) return [];
-    const camelName = camelCase6(input.name);
+    const camelName = camelCase7(input.name);
     return [
       mapFragmentContent5(
         inputFragment,
@@ -1360,7 +1340,7 @@ ${c}
 
 // src/fragments/instructionInputType.ts
 import {
-  camelCase as camelCase7,
+  camelCase as camelCase8,
   getAllInstructionArguments,
   isNode as isNode10,
   pascalCase as pascalCase4
@@ -1403,7 +1383,7 @@ function getAccountsFragment(scope) {
     const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode10(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const docs = getDocblockFragment(account.docs ?? [], true);
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return fragment`${docs}${camelCase7(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
+    return fragment`${docs}${camelCase8(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
   });
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
@@ -1459,7 +1439,7 @@ function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   if (arg.defaultValue && arg.defaultValueStrategy === "omitted") return null;
   const renamedName = renamedArgs.get(arg.name) ?? arg.name;
   const optionalSign = arg.defaultValue || resolvedArg?.defaultValue ? "?" : "";
-  return fragment`${camelCase7(renamedName)}${optionalSign}: ${argsType}["${camelCase7(arg.name)}"];`;
+  return fragment`${camelCase8(renamedName)}${optionalSign}: ${argsType}["${camelCase8(arg.name)}"];`;
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
@@ -1476,7 +1456,7 @@ function getRemainingAccountsFragment(instructionNode) {
       if (isSigner === "either") return fragment`${signerFragment} | ${addressFragment}`;
       return isSigner ? signerFragment : addressFragment;
     })();
-    return fragment`${camelCase7(name)}${optionalSign}: Array<${typeFragment}>;`;
+    return fragment`${camelCase8(name)}${optionalSign}: Array<${typeFragment}>;`;
   });
   if (fragments.length === 0) return;
   return mergeFragments(fragments, (c) => c.join("\n"));
@@ -1485,7 +1465,7 @@ function getRemainingAccountsFragment(instructionNode) {
 // src/fragments/instructionRemainingAccounts.ts
 import {
   assertIsNode as assertIsNode2,
-  camelCase as camelCase8,
+  camelCase as camelCase9,
   getAllInstructionArguments as getAllInstructionArguments2,
   isNode as isNode11
 } from "@codama/nodes";
@@ -1519,7 +1499,7 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const instructionNode = getLastNodeFromPath12(scope.instructionPath);
   assertIsNode2(remainingAccounts.value, "argumentValueNode");
-  const argumentName = camelCase8(remainingAccounts.value.name);
+  const argumentName = camelCase9(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1626,7 +1606,7 @@ function getAccountsInitializationFragment(instructionNode) {
   if (instructionNode.accounts.length === 0) return;
   const accounts = mergeFragments(
     instructionNode.accounts.map((account) => {
-      const name = camelCase9(account.name);
+      const name = camelCase10(account.name);
       const isWritable = account.isWritable ? "true" : "false";
       return fragment`${name}: { value: input.${name} ?? null, isWritable: ${isWritable} }`;
     }),
@@ -1661,7 +1641,7 @@ function getReturnStatementFragment(scope) {
   const hasLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted" && instructionNode.accounts.some((account) => account.isOptional);
   const getAccountMeta = hasAccounts ? fragment`const getAccountMeta = ${use("getAccountMetaFactory", "shared")}(programAddress, '${optionalAccountStrategy}');` : "";
   const accountItems = [
-    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${camelCase9(account.name)})`),
+    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${camelCase10(account.name)})`),
     ...hasRemainingAccounts ? ["...remainingAccounts"] : []
   ].join(", ");
   let accounts;
@@ -1710,7 +1690,7 @@ function getInstructionTypeFragment(scope) {
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
     const typeParam = fragment`TAccount${pascalCase5(account.name)}`;
-    const camelName = camelCase9(account.name);
+    const camelName = camelCase10(account.name);
     if (account.isSigner === "either") {
       const signerRole = use(
         account.isWritable ? "type WritableSignerAccount" : "type ReadonlySignerAccount",
@@ -1739,7 +1719,7 @@ function getInputTypeCallFragment(scope) {
 
 // src/fragments/instructionPage.ts
 import { logWarn } from "@codama/errors";
-import { camelCase as camelCase11, definedTypeNode as definedTypeNode2, structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3 } from "@codama/nodes";
+import { camelCase as camelCase12, definedTypeNode as definedTypeNode2, structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3 } from "@codama/nodes";
 import {
   findProgramNodeFromPath as findProgramNodeFromPath6,
   getLastNodeFromPath as getLastNodeFromPath16,
@@ -1747,7 +1727,7 @@ import {
 } from "@codama/visitors-core";
 
 // src/fragments/instructionParseFunction.ts
-import { camelCase as camelCase10 } from "@codama/nodes";
+import { camelCase as camelCase11 } from "@codama/nodes";
 import { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath14, pipe as pipe9 } from "@codama/visitors-core";
 function getInstructionParseFunctionFragment(scope) {
   const instructionNode = getLastNodeFromPath14(scope.instructionPath);
@@ -1772,7 +1752,7 @@ function getTypeFragment2(scope) {
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map((account, i) => {
       const docs = getDocblockFragment(account.docs ?? [], true);
-      const name = camelCase10(account.name);
+      const name = camelCase11(account.name);
       return fragment`${docs}${name}${account.isOptional ? "?" : ""}: TAccountMetas[${i}]${account.isOptional ? " | undefined" : ""};`;
     }),
     (cs) => hasAccounts ? `
@@ -1844,7 +1824,7 @@ const getNextOptionalAccount = () => {
   }
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map(
-      (account) => account.isOptional ? fragment`${camelCase10(account.name)}: getNextOptionalAccount()` : fragment`${camelCase10(account.name)}: getNextAccount()`
+      (account) => account.isOptional ? fragment`${camelCase11(account.name)}: getNextOptionalAccount()` : fragment`${camelCase11(account.name)}: getNextAccount()`
     ),
     (cs) => hasAccounts ? `, accounts: { ${cs.join(", ")} }` : ""
   );
@@ -1949,11 +1929,11 @@ 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) => [camelCase11(name), camelCase11(`${name}Arg`)]));
+  return new Map(duplicates.map((name) => [camelCase12(name), camelCase12(`${name}Arg`)]));
 }
 
 // src/fragments/pdaFunction.ts
-import { camelCase as camelCase12, isNode as isNode13, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
+import { camelCase as camelCase13, isNode as isNode13, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
 import { findProgramNodeFromPath as findProgramNodeFromPath7, getLastNodeFromPath as getLastNodeFromPath17, visit as visit6 } from "@codama/visitors-core";
 function getPdaFunctionFragment(scope) {
   const pdaNode = getLastNodeFromPath17(scope.pdaPath);
@@ -1998,7 +1978,7 @@ function getFunctionFragment2(seeds, scope) {
 function parsePdaSeedNodes(seeds, scope) {
   return seeds.map((seed) => {
     if (isNode13(seed, "variablePdaSeedNode")) {
-      const name = camelCase12(seed.name);
+      const name = camelCase13(seed.name);
       const docs = getDocblockFragment(seed.docs ?? [], true);
       const { encoder: encoder2, looseType } = visit6(seed.type, scope.typeManifestVisitor);
       return {
@@ -2388,7 +2368,7 @@ function getTypePageFragment(scope) {
 
 // src/visitors/getTypeManifestVisitor.ts
 import {
-  camelCase as camelCase13,
+  camelCase as camelCase14,
   isNode as isNode15,
   isNodeFilter as isNodeFilter6,
   isScalarEnum,
@@ -2523,7 +2503,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase13(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase14(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return typeManifest({
@@ -2536,7 +2516,7 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase13(currentParentName?.strict ?? "")
+          camelCase14(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -2560,7 +2540,7 @@ function getTypeManifestVisitor(input) {
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase13(currentParentName?.strict ?? "")
+          camelCase14(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -2598,7 +2578,7 @@ function getTypeManifestVisitor(input) {
           decoderOptions.push(fragment`size: ${sizeManifest.decoder}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase13(currentParentName?.strict ?? "")
+          camelCase14(currentParentName?.strict ?? "")
         );
         if (!isScalarEnum(enumType) && discriminator !== "__kind") {
           encoderOptions.push(fragment`discriminator: '${discriminator}'`);
@@ -2967,7 +2947,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = camelCase13(structFieldType.name);
+        const name = camelCase14(structFieldType.name);
         const originalChildManifest = visit8(structFieldType.type, self);
         let docs = getDocblockFragment(structFieldType.docs ?? [], true);
         docs = docs ? fragment`\n${docs}` : docs;
@@ -3022,9 +3002,9 @@ function getTypeManifestVisitor(input) {
         const fieldDiscriminators = discriminators.filter(isNodeFilter6("fieldDiscriminatorNode"));
         const defaultValues = mergeFragments(
           optionalFields.map((f) => {
-            const key = camelCase13(f.name);
+            const key = camelCase14(f.name);
             if (fieldDiscriminators.some((d) => d.name === f.name)) {
-              const constantName = nameApi.constant(camelCase13(`${discriminatorPrefix}_${f.name}`));
+              const constantName = nameApi.constant(camelCase14(`${discriminatorPrefix}_${f.name}`));
               return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${constantName}` : fragment`${key}: value.${key} ?? ${constantName}`;
             }
             const defaultValue = f.defaultValue;
@@ -3125,20 +3105,20 @@ function getRenderMapVisitor(options = {}) {
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const renderScopeWithTypeManifestVisitor = {
-    asyncResolvers: (options.asyncResolvers ?? []).map(camelCase14),
+    asyncResolvers: (options.asyncResolvers ?? []).map(camelCase15),
     customAccountData,
     customInstructionData,
     dependencyMap: options.dependencyMap ?? {},
     getImportFrom: getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData),
     linkables,
     nameApi: getNameApi({ ...DEFAULT_NAME_TRANSFORMERS, ...options.nameTransformers }),
-    nonScalarEnums: (options.nonScalarEnums ?? []).map(camelCase14),
+    nonScalarEnums: (options.nonScalarEnums ?? []).map(camelCase15),
     renderParentInstructions: options.renderParentInstructions ?? false,
     useGranularImports: options.useGranularImports ?? false
   };
   const typeManifestVisitor = getTypeManifestVisitor({ ...renderScopeWithTypeManifestVisitor, stack });
   const renderScope = { ...renderScopeWithTypeManifestVisitor, typeManifestVisitor };
-  const internalNodes = (options.internalNodes ?? []).map(camelCase14);
+  const internalNodes = (options.internalNodes ?? []).map(camelCase15);
   const resolvedInstructionInputVisitor = getResolvedInstructionInputsVisitor();
   const byteSizeVisitor = getByteSizeVisitor(linkables, { stack });
   const asPage = (fragment2, dependencyMap = {}) => {
@@ -3155,7 +3135,7 @@ function getRenderMapVisitor(options = {}) {
     (v) => extendVisitor2(v, {
       visitAccount(node) {
         return createRenderMap(
-          `accounts/${camelCase14(node.name)}.ts`,
+          `accounts/${camelCase15(node.name)}.ts`,
           asPage(
             getAccountPageFragment({
               ...renderScope,
@@ -3167,7 +3147,7 @@ function getRenderMapVisitor(options = {}) {
       },
       visitDefinedType(node) {
         return createRenderMap(
-          `types/${camelCase14(node.name)}.ts`,
+          `types/${camelCase15(node.name)}.ts`,
           asPage(getTypePageFragment({ ...renderScope, node, size: visit9(node, byteSizeVisitor) }), {
             generatedTypes: "."
           })
@@ -3175,7 +3155,7 @@ function getRenderMapVisitor(options = {}) {
       },
       visitInstruction(node) {
         return createRenderMap(
-          `instructions/${camelCase14(node.name)}.ts`,
+          `instructions/${camelCase15(node.name)}.ts`,
           asPage(
             getInstructionPageFragment({
               ...renderScope,
@@ -3188,7 +3168,7 @@ function getRenderMapVisitor(options = {}) {
       },
       visitPda(node) {
         return createRenderMap(
-          `pdas/${camelCase14(node.name)}.ts`,
+          `pdas/${camelCase15(node.name)}.ts`,
           asPage(getPdaPageFragment({ ...renderScope, pdaPath: stack.getPath("pdaNode") }))
         );
       },
@@ -3200,8 +3180,8 @@ function getRenderMapVisitor(options = {}) {
         const scope = { ...renderScope, programNode: node };
         return mergeRenderMaps([
           createRenderMap({
-            [`programs/${camelCase14(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
-            [`errors/${camelCase14(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
+            [`programs/${camelCase15(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
+            [`errors/${camelCase15(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
           }),
           ...node.pdas.map((p) => visit9(p, self)),
           ...node.accounts.map((a) => visit9(a, self)),