@codama/renderers-js 1.3.0 → 1.3.2

package/dist/index.node.cjs

@@ -532,6 +532,7 @@ function getAccountSizeHelpersFragment(scope) {
 }
 
 // src/fragments/accountType.ts
+var import_nodes7 = require("@codama/nodes");
 var import_visitors_core5 = require("@codama/visitors-core");
 
 // src/fragments/type.ts
@@ -550,45 +551,57 @@ function getTypeFragment(scope) {
 }
 
 // src/fragments/typeDecoder.ts
+var import_nodes5 = require("@codama/nodes");
 function getTypeDecoderFragment(scope) {
-  const { name, manifest, nameApi, docs = [] } = scope;
+  const { name, node, manifest, nameApi, docs = [] } = scope;
+  const decoderType = typeof scope.size === "number" ? "FixedSizeDecoder" : "Decoder";
+  const useTypeCast = (0, import_nodes5.isNode)(node, "enumTypeNode") && (0, import_nodes5.isDataEnum)(node) && typeof scope.size === "number";
   return fragmentFromTemplate("typeDecoder.njk", {
     decoderFunction: nameApi.decoderFunction(name),
+    decoderType,
     docs,
     looseName: nameApi.dataArgsType(name),
     manifest,
-    strictName: nameApi.dataType(name)
-  }).mergeImportsWith(manifest.decoder).addImports("solanaCodecsCore", "type Decoder");
+    strictName: nameApi.dataType(name),
+    useTypeCast
+  }).mergeImportsWith(manifest.decoder).addImports("solanaCodecsCore", `type ${decoderType}`);
 }
 
 // src/fragments/typeEncoder.ts
+var import_nodes6 = require("@codama/nodes");
 function getTypeEncoderFragment(scope) {
-  const { name, manifest, nameApi, docs = [] } = scope;
+  const { name, node, manifest, nameApi, docs = [] } = scope;
+  const encoderType = typeof scope.size === "number" ? "FixedSizeEncoder" : "Encoder";
+  const useTypeCast = (0, import_nodes6.isNode)(node, "enumTypeNode") && (0, import_nodes6.isDataEnum)(node) && typeof scope.size === "number";
   return fragmentFromTemplate("typeEncoder.njk", {
     docs,
     encoderFunction: nameApi.encoderFunction(name),
+    encoderType,
     looseName: nameApi.dataArgsType(name),
     manifest,
-    strictName: nameApi.dataType(name)
-  }).mergeImportsWith(manifest.encoder).addImports("solanaCodecsCore", "type Encoder");
+    strictName: nameApi.dataType(name),
+    useTypeCast
+  }).mergeImportsWith(manifest.encoder).addImports("solanaCodecsCore", `type ${encoderType}`);
 }
 
 // src/fragments/typeCodec.ts
 function getTypeCodecFragment(scope) {
   const { name, manifest, nameApi } = scope;
+  const codecType = typeof scope.size === "number" ? "FixedSizeCodec" : "Codec";
   return mergeFragments(
     [
       getTypeEncoderFragment({ ...scope, docs: scope.encoderDocs }),
       getTypeDecoderFragment({ ...scope, docs: scope.decoderDocs }),
       fragmentFromTemplate("typeCodec.njk", {
         codecFunction: nameApi.codecFunction(name),
+        codecType,
         decoderFunction: nameApi.decoderFunction(name),
         docs: scope.codecDocs,
         encoderFunction: nameApi.encoderFunction(name),
         looseName: nameApi.dataArgsType(name),
         manifest,
         strictName: nameApi.dataType(name)
-      }).addImports("solanaCodecsCore", ["type Codec", "combineCodec"])
+      }).addImports("solanaCodecsCore", [`type ${codecType}`, "combineCodec"])
     ],
     (renders) => renders.join("\n\n")
   );
@@ -612,24 +625,26 @@ function getAccountTypeFragment(scope) {
   return getTypeWithCodecFragment({
     manifest: typeManifest2,
     name: accountNode.name,
-    nameApi
+    nameApi,
+    node: (0, import_nodes7.resolveNestedTypeNode)(accountNode.data),
+    size: scope.size
   });
 }
 
 // src/fragments/discriminatorCondition.ts
-var import_nodes5 = require("@codama/nodes");
+var import_nodes8 = require("@codama/nodes");
 var import_visitors_core6 = require("@codama/visitors-core");
 var import_codecs_strings2 = require("@solana/codecs-strings");
 function getDiscriminatorConditionFragment(scope) {
   return mergeFragments(
     scope.discriminators.flatMap((discriminator) => {
-      if ((0, import_nodes5.isNode)(discriminator, "sizeDiscriminatorNode")) {
+      if ((0, import_nodes8.isNode)(discriminator, "sizeDiscriminatorNode")) {
         return [getSizeConditionFragment(discriminator, scope)];
       }
-      if ((0, import_nodes5.isNode)(discriminator, "constantDiscriminatorNode")) {
+      if ((0, import_nodes8.isNode)(discriminator, "constantDiscriminatorNode")) {
         return [getByteConditionFragment(discriminator, scope)];
       }
-      if ((0, import_nodes5.isNode)(discriminator, "fieldDiscriminatorNode")) {
+      if ((0, import_nodes8.isNode)(discriminator, "fieldDiscriminatorNode")) {
         return [getFieldConditionFragment(discriminator, scope)];
       }
       return [];
@@ -653,25 +668,25 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if ((0, import_nodes5.isNode)(field.type, "arrayTypeNode") && (0, import_nodes5.isNode)(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && (0, import_nodes5.isNode)(field.type.count, "fixedCountNode") && (0, import_nodes5.isNode)(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every((0, import_nodes5.isNodeFilter)("numberValueNode"))) {
+  if ((0, import_nodes8.isNode)(field.type, "arrayTypeNode") && (0, import_nodes8.isNode)(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && (0, import_nodes8.isNode)(field.type.count, "fixedCountNode") && (0, import_nodes8.isNode)(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every((0, import_nodes8.isNodeFilter)("numberValueNode"))) {
     const base64Bytes = (0, import_codecs_strings2.getBase64Decoder)().decode(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
     return getByteConditionFragment(
-      (0, import_nodes5.constantDiscriminatorNode)((0, import_nodes5.constantValueNodeFromBytes)("base64", base64Bytes), discriminator.offset),
+      (0, import_nodes8.constantDiscriminatorNode)((0, import_nodes8.constantValueNodeFromBytes)("base64", base64Bytes), discriminator.offset),
       scope
     );
   }
   return getByteConditionFragment(
-    (0, import_nodes5.constantDiscriminatorNode)((0, import_nodes5.constantValueNode)(field.type, field.defaultValue), discriminator.offset),
+    (0, import_nodes8.constantDiscriminatorNode)((0, import_nodes8.constantValueNode)(field.type, field.defaultValue), discriminator.offset),
     scope
   );
 }
 
 // src/fragments/instructionAccountMeta.ts
-var import_nodes6 = require("@codama/nodes");
+var import_nodes9 = require("@codama/nodes");
 function getInstructionAccountMetaFragment(instructionAccountNode) {
-  const typeParam = `TAccount${(0, import_nodes6.pascalCase)(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${(0, import_nodes9.pascalCase)(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
     return fragment(`WritableSignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type WritableSignerAccount"]).addImports("solanaSigners", ["type AccountSignerMeta"]);
   }
@@ -685,14 +700,14 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
 }
 
 // src/fragments/instructionAccountTypeParam.ts
-var import_nodes7 = require("@codama/nodes");
+var import_nodes10 = require("@codama/nodes");
 var import_visitors_core7 = require("@codama/visitors-core");
 function getInstructionAccountTypeParamFragment(scope) {
   const { instructionAccountPath, allowAccountMeta, linkables } = scope;
   const instructionAccountNode = (0, import_visitors_core7.getLastNodeFromPath)(instructionAccountPath);
   const instructionNode = (0, import_visitors_core7.findInstructionNodeFromPath)(instructionAccountPath);
   const programNode = (0, import_visitors_core7.findProgramNodeFromPath)(instructionAccountPath);
-  const typeParam = `TAccount${(0, import_nodes7.pascalCase)(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${(0, import_nodes10.pascalCase)(instructionAccountNode.name)}`;
   const accountMeta = allowAccountMeta ? " | AccountMeta<string>" : "";
   const imports = new ImportMap();
   if (allowAccountMeta) {
@@ -719,7 +734,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 }
 
 // src/fragments/instructionByteDelta.ts
-var import_nodes8 = require("@codama/nodes");
+var import_nodes11 = require("@codama/nodes");
 var import_visitors_core8 = require("@codama/visitors-core");
 function getInstructionByteDeltaFragment(scope) {
   const { byteDeltas } = (0, import_visitors_core8.getLastNodeFromPath)(scope.instructionPath);
@@ -733,16 +748,16 @@ const byteDelta: number = [${r.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   const bytesFragment = (() => {
-    if ((0, import_nodes8.isNode)(byteDelta.value, "numberValueNode")) {
+    if ((0, import_nodes11.isNode)(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if ((0, import_nodes8.isNode)(byteDelta.value, "argumentValueNode")) {
+    if ((0, import_nodes11.isNode)(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if ((0, import_nodes8.isNode)(byteDelta.value, "accountLinkNode")) {
+    if ((0, import_nodes11.isNode)(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if ((0, import_nodes8.isNode)(byteDelta.value, "resolverValueNode")) {
+    if ((0, import_nodes11.isNode)(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -757,21 +772,21 @@ function getByteDeltaFragment(byteDelta, scope) {
   return [bytesFragment];
 }
 function getNumberValueNodeFragment(byteDelta) {
-  (0, import_nodes8.assertIsNode)(byteDelta.value, "numberValueNode");
+  (0, import_nodes11.assertIsNode)(byteDelta.value, "numberValueNode");
   return fragment(byteDelta.value.number.toString());
 }
 function getArgumentValueNodeFragment(byteDelta) {
-  (0, import_nodes8.assertIsNode)(byteDelta.value, "argumentValueNode");
-  const argumentName = (0, import_nodes8.camelCase)(byteDelta.value.name);
+  (0, import_nodes11.assertIsNode)(byteDelta.value, "argumentValueNode");
+  const argumentName = (0, import_nodes11.camelCase)(byteDelta.value.name);
   return fragment(`Number(args.${argumentName})`);
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
-  (0, import_nodes8.assertIsNode)(byteDelta.value, "accountLinkNode");
+  (0, import_nodes11.assertIsNode)(byteDelta.value, "accountLinkNode");
   const functionName = scope.nameApi.accountGetSizeFunction(byteDelta.value.name);
   return fragment(`${functionName}()`).addImports(scope.getImportFrom(byteDelta.value), functionName);
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
-  (0, import_nodes8.assertIsNode)(byteDelta.value, "resolverValueNode");
+  (0, import_nodes11.assertIsNode)(byteDelta.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(byteDelta.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -780,6 +795,7 @@ function getResolverValueNodeFragment(byteDelta, scope) {
 }
 
 // src/fragments/instructionData.ts
+var import_nodes12 = require("@codama/nodes");
 var import_visitors_core9 = require("@codama/visitors-core");
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
@@ -791,12 +807,14 @@ function getInstructionDataFragment(scope) {
   return getTypeWithCodecFragment({
     manifest: dataArgsManifest,
     name: instructionDataName,
-    nameApi
+    nameApi,
+    node: (0, import_nodes12.structTypeNodeFromInstructionArgumentNodes)(instructionNode.arguments),
+    size: scope.size
   });
 }
 
 // src/fragments/discriminatorConstants.ts
-var import_nodes9 = require("@codama/nodes");
+var import_nodes13 = require("@codama/nodes");
 var import_visitors_core10 = require("@codama/visitors-core");
 function getDiscriminatorConstantsFragment(scope) {
   const fragments = scope.discriminatorNodes.map((node) => getDiscriminatorConstantFragment(node, scope)).filter(Boolean);
@@ -814,9 +832,9 @@ function getDiscriminatorConstantFragment(discriminatorNode, scope) {
 }
 function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
-  const index = discriminatorNodes.filter((0, import_nodes9.isNodeFilter)("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const index = discriminatorNodes.filter((0, import_nodes13.isNodeFilter)("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = (0, import_nodes9.camelCase)(`${prefix}_discriminator${suffix}`);
+  const name = (0, import_nodes13.camelCase)(`${prefix}_discriminator${suffix}`);
   const encoder = (0, import_visitors_core10.visit)(discriminatorNode.constant.type, typeManifestVisitor).encoder;
   const value = (0, import_visitors_core10.visit)(discriminatorNode.constant.value, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
@@ -824,10 +842,10 @@ function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
 function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { fields, prefix, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !(0, import_nodes9.isNode)(field.defaultValue, import_nodes9.VALUE_NODES)) {
+  if (!field || !field.defaultValue || !(0, import_nodes13.isNode)(field.defaultValue, import_nodes13.VALUE_NODES)) {
     return null;
   }
-  const name = (0, import_nodes9.camelCase)(`${prefix}_${discriminatorNode.name}`);
+  const name = (0, import_nodes13.camelCase)(`${prefix}_${discriminatorNode.name}`);
   const encoder = (0, import_visitors_core10.visit)(field.type, typeManifestVisitor).encoder;
   const value = (0, import_visitors_core10.visit)(field.defaultValue, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
@@ -862,15 +880,15 @@ function getInstructionExtraArgsFragment(scope) {
 }
 
 // src/fragments/instructionFunction.ts
-var import_nodes14 = require("@codama/nodes");
+var import_nodes18 = require("@codama/nodes");
 var import_visitors_core16 = require("@codama/visitors-core");
 
 // src/fragments/instructionInputResolved.ts
-var import_nodes11 = require("@codama/nodes");
+var import_nodes15 = require("@codama/nodes");
 var import_visitors_core13 = require("@codama/visitors-core");
 
 // src/fragments/instructionInputDefault.ts
-var import_nodes10 = require("@codama/nodes");
+var import_nodes14 = require("@codama/nodes");
 var import_visitors_core12 = require("@codama/visitors-core");
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
@@ -882,8 +900,8 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = (0, import_nodes10.camelCase)(input.name);
-    if (input.kind === "instructionAccountNode" && (0, import_nodes10.isNode)(defaultValue, "resolverValueNode")) {
+    const inputName = (0, import_nodes14.camelCase)(input.name);
+    if (input.kind === "instructionAccountNode" && (0, import_nodes14.isNode)(defaultValue, "resolverValueNode")) {
       return fragment(`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`);
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -899,7 +917,7 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
   };
   switch (defaultValue.kind) {
     case "accountValueNode":
-      const name = (0, import_nodes10.camelCase)(defaultValue.name);
+      const name = (0, import_nodes14.camelCase)(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
         return defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`).addImports(
           "shared",
@@ -911,17 +929,17 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
     case "pdaValueNode":
-      if ((0, import_nodes10.isNode)(defaultValue.pda, "pdaNode")) {
+      if ((0, import_nodes14.isNode)(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 ((0, import_nodes10.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes10.isNode)(seed.value, "programIdValueNode")) {
+          if ((0, import_nodes14.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes14.isNode)(seed.value, "programIdValueNode")) {
             return [
               fragment(`getAddressEncoder().encode(${pdaProgram.render})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
             ];
           }
-          if ((0, import_nodes10.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes10.isNode)(seed.value, "programIdValueNode")) {
+          if ((0, import_nodes14.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes14.isNode)(seed.value, "programIdValueNode")) {
             const typeManifest2 = (0, import_visitors_core12.visit)(seed.type, typeManifestVisitor);
             const valueManifest2 = (0, import_visitors_core12.visit)(seed.value, typeManifestVisitor);
             return [
@@ -930,21 +948,21 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
               ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
             ];
           }
-          if ((0, import_nodes10.isNode)(seed, "variablePdaSeedNode")) {
+          if ((0, import_nodes14.isNode)(seed, "variablePdaSeedNode")) {
             const typeManifest2 = (0, import_visitors_core12.visit)(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if ((0, import_nodes10.isNode)(valueSeed, "accountValueNode")) {
+            if ((0, import_nodes14.isNode)(valueSeed, "accountValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${(0, import_nodes10.camelCase)(valueSeed.name)}.value))`
+                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${(0, import_nodes14.camelCase)(valueSeed.name)}.value))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
               ];
             }
-            if ((0, import_nodes10.isNode)(valueSeed, "argumentValueNode")) {
+            if ((0, import_nodes14.isNode)(valueSeed, "argumentValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder.render}.encode(expectSome(args.${(0, import_nodes10.camelCase)(valueSeed.name)}))`
+                  `${typeManifest2.encoder.render}.encode(expectSome(args.${(0, import_nodes14.camelCase)(valueSeed.name)}))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
               ];
             }
@@ -966,13 +984,13 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
-        if ((0, import_nodes10.isNode)(seed.value, "accountValueNode")) {
+        if ((0, import_nodes14.isNode)(seed.value, "accountValueNode")) {
           return fragment(
-            `${seed.name}: expectAddress(accounts.${(0, import_nodes10.camelCase)(seed.value.name)}.value)`
+            `${seed.name}: expectAddress(accounts.${(0, import_nodes14.camelCase)(seed.value.name)}.value)`
           ).addImports("shared", "expectAddress");
         }
-        if ((0, import_nodes10.isNode)(seed.value, "argumentValueNode")) {
-          return fragment(`${seed.name}: expectSome(args.${(0, import_nodes10.camelCase)(seed.value.name)})`).addImports(
+        if ((0, import_nodes14.isNode)(seed.value, "argumentValueNode")) {
+          return fragment(`${seed.name}: expectSome(args.${(0, import_nodes14.camelCase)(seed.value.name)})`).addImports(
             "shared",
             "expectSome"
           );
@@ -1002,10 +1020,10 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       return fragment("");
     case "accountBumpValueNode":
       return defaultFragment(
-        `expectProgramDerivedAddress(accounts.${(0, import_nodes10.camelCase)(defaultValue.name)}.value)[1]`
+        `expectProgramDerivedAddress(accounts.${(0, import_nodes14.camelCase)(defaultValue.name)}.value)[1]`
       ).addImports("shared", "expectProgramDerivedAddress");
     case "argumentValueNode":
-      return defaultFragment(`expectSome(args.${(0, import_nodes10.camelCase)(defaultValue.name)})`).addImports(
+      return defaultFragment(`expectSome(args.${(0, import_nodes14.camelCase)(defaultValue.name)})`).addImports(
         "shared",
         "expectSome"
       );
@@ -1034,14 +1052,14 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if ((0, import_nodes10.isNode)(defaultValue.condition, "resolverValueNode")) {
+      if ((0, import_nodes14.isNode)(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 = (0, import_nodes10.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes10.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes10.camelCase)(defaultValue.condition.name)}`;
+        const comparedInputName = (0, import_nodes14.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes14.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes14.camelCase)(defaultValue.condition.name)}`;
         if (defaultValue.value) {
           const comparedValue = (0, import_visitors_core12.visit)(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment.mergeImportsWith(comparedValue).mergeFeaturesWith(comparedValue);
@@ -1086,13 +1104,13 @@ function getInstructionInputResolvedFragment(scope) {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
       input,
-      optionalAccountStrategy: (0, import_nodes11.parseOptionalAccountStrategy)(instructionNode.optionalAccountStrategy)
+      optionalAccountStrategy: (0, import_nodes15.parseOptionalAccountStrategy)(instructionNode.optionalAccountStrategy)
     });
     if (!inputFragment.render) return [];
-    const camelName = (0, import_nodes11.camelCase)(input.name);
+    const camelName = (0, import_nodes15.camelCase)(input.name);
     return [
       inputFragment.mapRender(
-        (r) => (0, import_nodes11.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (r) => (0, import_nodes15.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${r}
 }` : `if (!accounts.${camelName}.value) {
 ${r}
@@ -1110,7 +1128,7 @@ ${r}
 }
 
 // src/fragments/instructionInputType.ts
-var import_nodes12 = require("@codama/nodes");
+var import_nodes16 = require("@codama/nodes");
 var import_visitors_core14 = require("@codama/visitors-core");
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
@@ -1143,18 +1161,18 @@ function getAccountsFragment(scope) {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !(0, import_nodes12.isNode)(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
-    const accountDocs = (0, import_nodes12.parseDocs)(account.docs);
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !(0, import_nodes16.isNode)(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const accountDocs = (0, import_nodes16.parseDocs)(account.docs);
     const docblock = accountDocs.length > 0 ? jsDocblock(accountDocs) : "";
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
     return getAccountTypeFragment2(resolvedAccount).mapRender(
-      (r) => `${docblock}${(0, import_nodes12.camelCase)(account.name)}${optionalSign}: ${r};`
+      (r) => `${docblock}${(0, import_nodes16.camelCase)(account.name)}${optionalSign}: ${r};`
     );
   });
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
 function getAccountTypeFragment2(account) {
-  const typeParam = `TAccount${(0, import_nodes12.pascalCase)(account.name)}`;
+  const typeParam = `TAccount${(0, import_nodes16.pascalCase)(account.name)}`;
   if (account.isPda && account.isSigner === false) {
     return fragment(`ProgramDerivedAddress<${typeParam}>`).addImports("solanaAddresses", [
       "type ProgramDerivedAddress"
@@ -1202,18 +1220,18 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => (0, import_nodes12.isNode)(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => (0, import_nodes16.isNode)(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) => `${(0, import_nodes12.camelCase)(renamedName)}${optionalSign}: ${r}["${(0, import_nodes12.camelCase)(arg.name)}"];`);
+  return argsType.mapRender((r) => `${(0, import_nodes16.camelCase)(renamedName)}${optionalSign}: ${r}["${(0, import_nodes16.camelCase)(arg.name)}"];`);
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if ((0, import_nodes12.isNode)(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if ((0, import_nodes16.isNode)(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
-    const allArguments = (0, import_nodes12.getAllInstructionArguments)(instructionNode);
+    const allArguments = (0, import_nodes16.getAllInstructionArguments)(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
     if (argumentExists) return [];
     const isSigner = remainingAccountsNode.isSigner ?? false;
@@ -1225,13 +1243,13 @@ function getRemainingAccountsFragment(instructionNode) {
         return mergeFragments([signerFragment, addressFragment], (r) => r.join(" | "));
       }
       return isSigner ? signerFragment : addressFragment;
-    })().mapRender((r) => `${(0, import_nodes12.camelCase)(name)}${optionalSign}: Array<${r}>;`);
+    })().mapRender((r) => `${(0, import_nodes16.camelCase)(name)}${optionalSign}: Array<${r}>;`);
   });
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
 
 // src/fragments/instructionRemainingAccounts.ts
-var import_nodes13 = require("@codama/nodes");
+var import_nodes17 = require("@codama/nodes");
 var import_visitors_core15 = require("@codama/visitors-core");
 function getInstructionRemainingAccountsFragment(scope) {
   const { remainingAccounts } = (0, import_visitors_core15.getLastNodeFromPath)(scope.instructionPath);
@@ -1245,10 +1263,10 @@ const remainingAccounts: AccountMeta[] = ${r.length === 1 ? r[0] : `[...${r.join
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if ((0, import_nodes13.isNode)(remainingAccounts.value, "argumentValueNode")) {
+    if ((0, import_nodes17.isNode)(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if ((0, import_nodes13.isNode)(remainingAccounts.value, "resolverValueNode")) {
+    if ((0, import_nodes17.isNode)(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1258,8 +1276,8 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(scope.instructionPath);
-  (0, import_nodes13.assertIsNode)(remainingAccounts.value, "argumentValueNode");
-  const argumentName = (0, import_nodes13.camelCase)(remainingAccounts.value.name);
+  (0, import_nodes17.assertIsNode)(remainingAccounts.value, "argumentValueNode");
+  const argumentName = (0, import_nodes17.camelCase)(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1267,7 +1285,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 = (0, import_nodes13.getAllInstructionArguments)(instructionNode);
+  const allArguments = (0, import_nodes17.getAllInstructionArguments)(instructionNode);
   const argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
     return fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`).addImports(
@@ -1288,7 +1306,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   ).addImports("solanaInstructions", ["AccountRole"]);
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
-  (0, import_nodes13.assertIsNode)(remainingAccounts.value, "resolverValueNode");
+  (0, import_nodes17.assertIsNode)(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1317,7 +1335,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((0, import_nodes14.isNodeFilter)("argumentValueNode")).map((node) => node.name);
+  const argDependencies = instructionDependencies.filter((0, import_nodes18.isNodeFilter)("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);
@@ -1330,7 +1348,7 @@ function getInstructionFunctionFragment(scope) {
   const hasExtraArgs = (instructionNode.extraArguments ?? []).filter(
     (field) => argIsNotOmitted(field) && (argIsDependent(field) || argHasDefaultValue(field))
   ).length > 0;
-  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => (0, import_nodes14.isNode)(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => (0, import_nodes18.isNode)(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
@@ -1406,7 +1424,7 @@ function getInstructionFunctionFragment(scope) {
   return functionFragment;
 }
 function getTypeParams(instructionNode, programAddressConstant) {
-  const typeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes14.pascalCase)(account.name)} extends string`);
+  const typeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes18.pascalCase)(account.name)} extends string`);
   typeParams.push(`TProgramAddress extends Address = typeof ${programAddressConstant}`);
   return fragment(typeParams.filter((x) => !!x).join(", ")).mapRender((r) => `<${r}>`).addImports("generatedPrograms", [programAddressConstant]);
 }
@@ -1416,8 +1434,8 @@ function getInstructionType(scope) {
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = `TAccount${(0, import_nodes14.pascalCase)(account.name)}`;
-    const camelName = (0, import_nodes14.camelCase)(account.name);
+    const typeParam = `TAccount${(0, import_nodes18.pascalCase)(account.name)}`;
+    const camelName = (0, import_nodes18.camelCase)(account.name);
     if (account.isSigner === "either") {
       const signerRole = account.isWritable ? "WritableSignerAccount" : "ReadonlySignerAccount";
       return fragment(
@@ -1436,7 +1454,7 @@ function getInputTypeCall(scope) {
   const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(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${(0, import_nodes14.pascalCase)(account.name)}`).join(", ");
+  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes18.pascalCase)(account.name)}`).join(", ");
   return fragment(`${inputTypeName}<${accountTypeParams}>`);
 }
 
@@ -1475,7 +1493,7 @@ function getInstructionParseFunctionFragment(scope) {
 }
 
 // src/fragments/instructionType.ts
-var import_nodes15 = require("@codama/nodes");
+var import_nodes19 = require("@codama/nodes");
 var import_visitors_core18 = require("@codama/visitors-core");
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
@@ -1486,7 +1504,7 @@ function getInstructionTypeFragment(scope) {
   const hasData = !!customData || instructionNode.arguments.length > 0;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  const dataType = customData ? (0, import_nodes15.pascalCase)(customData.importAs) : (0, import_nodes15.pascalCase)(instructionDataName);
+  const dataType = customData ? (0, import_nodes19.pascalCase)(customData.importAs) : (0, import_nodes19.pascalCase)(instructionDataName);
   const accountTypeParamsFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountTypeParamFragment({
@@ -1501,7 +1519,7 @@ function getInstructionTypeFragment(scope) {
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountMetaFragment(account).mapRender((r) => {
-        const typeParam = `TAccount${(0, import_nodes15.pascalCase)(account.name)}`;
+        const typeParam = `TAccount${(0, import_nodes19.pascalCase)(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
         const type = `${typeParam} extends string ? ${r} : ${typeParam}`;
         if (!isLegacyOptional) return type;
@@ -1529,7 +1547,7 @@ function getInstructionTypeFragment(scope) {
 }
 
 // src/fragments/pdaFunction.ts
-var import_nodes16 = require("@codama/nodes");
+var import_nodes20 = require("@codama/nodes");
 var import_visitors_core19 = require("@codama/visitors-core");
 function getPdaFunctionFragment(scope) {
   const { pdaPath, typeManifestVisitor, nameApi } = scope;
@@ -1537,12 +1555,12 @@ function getPdaFunctionFragment(scope) {
   const programNode = (0, import_visitors_core19.findProgramNodeFromPath)(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
-    if ((0, import_nodes16.isNode)(seed, "variablePdaSeedNode")) {
+    if ((0, import_nodes20.isNode)(seed, "variablePdaSeedNode")) {
       const seedManifest2 = (0, import_visitors_core19.visit)(seed.type, typeManifestVisitor);
       imports.mergeWith(seedManifest2.looseType, seedManifest2.encoder);
       return { ...seed, typeManifest: seedManifest2 };
     }
-    if ((0, import_nodes16.isNode)(seed.value, "programIdValueNode")) {
+    if ((0, import_nodes20.isNode)(seed.value, "programIdValueNode")) {
       imports.add("solanaAddresses", "getAddressEncoder");
       return seed;
     }
@@ -1552,7 +1570,7 @@ function getPdaFunctionFragment(scope) {
     imports.mergeWith(valueManifest.imports);
     return { ...seed, typeManifest: seedManifest, valueManifest };
   });
-  const hasVariableSeeds = pdaNode.seeds.filter((0, import_nodes16.isNodeFilter)("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = pdaNode.seeds.filter((0, import_nodes20.isNodeFilter)("variablePdaSeedNode")).length > 0;
   return fragmentFromTemplate("pdaFunction.njk", {
     findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
     hasVariableSeeds,
@@ -1572,7 +1590,7 @@ function getProgramFragment(scope) {
 }
 
 // src/fragments/programAccounts.ts
-var import_nodes17 = require("@codama/nodes");
+var import_nodes21 = require("@codama/nodes");
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return fragment("");
   return mergeFragments(
@@ -1606,7 +1624,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: account.discriminators ?? [],
         ifTrue: `return ${programAccountsEnum}.${variant};`,
-        struct: (0, import_nodes17.resolveNestedTypeNode)(account.data)
+        struct: (0, import_nodes21.resolveNestedTypeNode)(account.data)
       });
     }),
     (r) => r.join("\n")
@@ -1637,10 +1655,10 @@ function getProgramErrorsFragment(scope) {
 }
 
 // src/fragments/programInstructions.ts
-var import_nodes18 = require("@codama/nodes");
+var import_nodes22 = require("@codama/nodes");
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return fragment("");
-  const allInstructions = (0, import_nodes18.getAllInstructionsWithSubs)(scope.programNode, {
+  const allInstructions = (0, import_nodes22.getAllInstructionsWithSubs)(scope.programNode, {
     leavesOnly: !scope.renderParentInstructions,
     subInstructionsFirst: true
   });
@@ -1682,7 +1700,7 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: (0, import_nodes18.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
+        struct: (0, import_nodes22.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
       });
     }),
     (r) => r.join("\n")
@@ -1717,10 +1735,10 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
 }
 
 // src/fragments/typeDiscriminatedUnionHelpers.ts
-var import_nodes19 = require("@codama/nodes");
+var import_nodes23 = require("@codama/nodes");
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = (0, import_nodes19.isNode)(typeNode, "enumTypeNode") && (0, import_nodes19.isDataEnum)(typeNode);
+  const isDiscriminatedUnion = (0, import_nodes23.isNode)(typeNode, "enumTypeNode") && (0, import_nodes23.isDataEnum)(typeNode);
   if (!isDiscriminatedUnion) {
     return fragment("");
   }
@@ -1765,12 +1783,12 @@ function mergeManifests(manifests, options = {}) {
 // src/getRenderMapVisitor.ts
 var import_node_path3 = require("path");
 var import_errors2 = require("@codama/errors");
-var import_nodes22 = require("@codama/nodes");
+var import_nodes26 = require("@codama/nodes");
 var import_renderers_core = require("@codama/renderers-core");
 var import_visitors_core21 = require("@codama/visitors-core");
 
 // src/getTypeManifestVisitor.ts
-var import_nodes20 = require("@codama/nodes");
+var import_nodes24 = require("@codama/nodes");
 var import_visitors_core20 = require("@codama/visitors-core");
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
@@ -1788,8 +1806,8 @@ function getTypeManifestVisitor(input) {
       }),
       {
         keys: [
-          ...import_nodes20.REGISTERED_TYPE_NODE_KINDS,
-          ...import_nodes20.REGISTERED_VALUE_NODE_KINDS,
+          ...import_nodes24.REGISTERED_TYPE_NODE_KINDS,
+          ...import_nodes24.REGISTERED_VALUE_NODE_KINDS,
           "definedTypeLinkNode",
           "definedTypeNode",
           "accountNode",
@@ -1833,7 +1851,7 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap().add("solanaCodecsDataStructures", "getBooleanDecoder");
         let sizeEncoder = "";
         let sizeDecoder = "";
-        const resolvedSize = (0, import_nodes20.resolveNestedTypeNode)(booleanType.size);
+        const resolvedSize = (0, import_nodes24.resolveNestedTypeNode)(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
           const size = (0, import_visitors_core20.visit)(booleanType.size, self);
           encoderImports.mergeWith(size.encoder);
@@ -1884,7 +1902,7 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitConstantValue(node, { self }) {
-        if ((0, import_nodes20.isNode)(node.type, "bytesTypeNode") && (0, import_nodes20.isNode)(node.value, "bytesValueNode")) {
+        if ((0, import_nodes24.isNode)(node.type, "bytesTypeNode") && (0, import_nodes24.isNode)(node.value, "bytesValueNode")) {
           return (0, import_visitors_core20.visit)(node.value, self);
         }
         return {
@@ -1923,7 +1941,7 @@ function getTypeManifestVisitor(input) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes20.camelCase)(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes24.camelCase)(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return {
@@ -1944,7 +1962,7 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes20.camelCase)(currentParentName?.strict ?? "")
+          (0, import_nodes24.camelCase)(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -1960,12 +1978,12 @@ function getTypeManifestVisitor(input) {
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes20.camelCase)(currentParentName?.strict ?? "")
+          (0, import_nodes24.camelCase)(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
-        const struct = (0, import_nodes20.structTypeNode)([
-          (0, import_nodes20.structFieldTypeNode)({
+        const struct = (0, import_nodes24.structTypeNode)([
+          (0, import_nodes24.structFieldTypeNode)({
             name: "fields",
             type: enumTupleVariantType.tuple
           })
@@ -1985,7 +2003,7 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap();
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = (0, import_nodes20.resolveNestedTypeNode)(enumType.size);
+        const enumSize = (0, import_nodes24.resolveNestedTypeNode)(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
           const sizeManifest = (0, import_visitors_core20.visit)(enumType.size, self);
           encoderImports.mergeWith(sizeManifest.encoder);
@@ -1994,15 +2012,15 @@ function getTypeManifestVisitor(input) {
           decoderOptions.push(`size: ${sizeManifest.decoder.render}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes20.camelCase)(currentParentName?.strict ?? "")
+          (0, import_nodes24.camelCase)(currentParentName?.strict ?? "")
         );
-        if (!(0, import_nodes20.isScalarEnum)(enumType) && discriminator !== "__kind") {
+        if (!(0, import_nodes24.isScalarEnum)(enumType) && discriminator !== "__kind") {
           encoderOptions.push(`discriminator: '${discriminator}'`);
           decoderOptions.push(`discriminator: '${discriminator}'`);
         }
         const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
         const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
-        if ((0, import_nodes20.isScalarEnum)(enumType)) {
+        if ((0, import_nodes24.isScalarEnum)(enumType)) {
           if (currentParentName === null) {
             throw new Error(
               "Scalar enums cannot be inlined and must be introduced via a defined type. Ensure you are not inlining a defined type that is a scalar enum through a visitor."
@@ -2041,7 +2059,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 && (0, import_nodes20.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes20.isScalarEnum)(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && (0, import_nodes24.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes24.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);
@@ -2086,7 +2104,7 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = (0, import_nodes20.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
+        const struct = (0, import_nodes24.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
         const manifest = link ? (0, import_visitors_core20.visit)(link, self) : (0, import_visitors_core20.visit)(struct, self);
         parentName = null;
         return manifest;
@@ -2153,7 +2171,7 @@ function getTypeManifestVisitor(input) {
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = (0, import_nodes20.resolveNestedTypeNode)(optionType.prefix);
+        const optionPrefix = (0, import_nodes24.resolveNestedTypeNode)(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
           const prefixManifest = (0, import_visitors_core20.visit)(optionType.prefix, self);
           childManifest.encoder.mergeImportsWith(prefixManifest.encoder);
@@ -2319,9 +2337,9 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = (0, import_nodes20.camelCase)(structFieldType.name);
+        const name = (0, import_nodes24.camelCase)(structFieldType.name);
         const childManifest = (0, import_visitors_core20.visit)(structFieldType.type, self);
-        const structFieldDocs = (0, import_nodes20.parseDocs)(structFieldType.docs);
+        const structFieldDocs = (0, import_nodes24.parseDocs)(structFieldType.docs);
         const docblock = structFieldDocs.length > 0 ? `
 ${jsDocblock(structFieldDocs)}` : "";
         const originalLooseType = childManifest.looseType.render;
@@ -2363,11 +2381,11 @@ ${jsDocblock(structFieldDocs)}` : "";
         const accountNode = (0, import_visitors_core20.findLastNodeFromPath)(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
-        const fieldDiscriminators = discriminators.filter((0, import_nodes20.isNodeFilter)("fieldDiscriminatorNode"));
+        const fieldDiscriminators = discriminators.filter((0, import_nodes24.isNodeFilter)("fieldDiscriminatorNode"));
         const defaultValues = optionalFields.map((f) => {
-          const key = (0, import_nodes20.camelCase)(f.name);
+          const key = (0, import_nodes24.camelCase)(f.name);
           if (fieldDiscriminators.some((d) => d.name === f.name)) {
-            const constantName = nameApi.constant((0, import_nodes20.camelCase)(`${discriminatorPrefix}_${f.name}`));
+            const constantName = nameApi.constant((0, import_nodes24.camelCase)(`${discriminatorPrefix}_${f.name}`));
             return f.defaultValueStrategy === "omitted" ? `${key}: ${constantName}` : `${key}: value.${key} ?? ${constantName}`;
           }
           const defaultValue = f.defaultValue;
@@ -2427,19 +2445,19 @@ ${jsDocblock(structFieldDocs)}` : "";
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if ((0, import_nodes20.isNode)(count, "fixedCountNode")) {
+  if ((0, import_nodes24.isNode)(count, "fixedCountNode")) {
     return {
       decoder: fragment(`size: ${count.value}`),
       encoder: fragment(`size: ${count.value}`)
     };
   }
-  if ((0, import_nodes20.isNode)(count, "remainderCountNode")) {
+  if ((0, import_nodes24.isNode)(count, "remainderCountNode")) {
     return {
       decoder: fragment(`size: 'remainder'`),
       encoder: fragment(`size: 'remainder'`)
     };
   }
-  const prefix = (0, import_nodes20.resolveNestedTypeNode)(count.prefix);
+  const prefix = (0, import_nodes24.resolveNestedTypeNode)(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: fragment(""), encoder: fragment("") };
   }
@@ -2450,67 +2468,67 @@ function getArrayLikeSizeOption(count, visitor) {
 }
 
 // src/nameTransformers.ts
-var import_nodes21 = require("@codama/nodes");
+var import_nodes25 = require("@codama/nodes");
 function getNameApi(transformers) {
   const helpers = {
-    camelCase: import_nodes21.camelCase,
-    capitalize: import_nodes21.capitalize,
-    kebabCase: import_nodes21.kebabCase,
-    pascalCase: import_nodes21.pascalCase,
-    snakeCase: import_nodes21.snakeCase,
-    titleCase: import_nodes21.titleCase
+    camelCase: import_nodes25.camelCase,
+    capitalize: import_nodes25.capitalize,
+    kebabCase: import_nodes25.kebabCase,
+    pascalCase: import_nodes25.pascalCase,
+    snakeCase: import_nodes25.snakeCase,
+    titleCase: import_nodes25.titleCase
   };
   return Object.fromEntries(
     Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
   );
 }
 var DEFAULT_NAME_TRANSFORMERS = {
-  accountDecodeFunction: (name) => `decode${(0, import_nodes21.pascalCase)(name)}`,
-  accountFetchAllFunction: (name) => `fetchAll${(0, import_nodes21.pascalCase)(name)}`,
-  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${(0, import_nodes21.pascalCase)(name)}`,
-  accountFetchFromSeedsFunction: (name) => `fetch${(0, import_nodes21.pascalCase)(name)}FromSeeds`,
-  accountFetchFunction: (name) => `fetch${(0, import_nodes21.pascalCase)(name)}`,
-  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${(0, import_nodes21.pascalCase)(name)}FromSeeds`,
-  accountFetchMaybeFunction: (name) => `fetchMaybe${(0, import_nodes21.pascalCase)(name)}`,
-  accountGetSizeFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Size`,
-  codecFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Codec`,
-  constant: (name) => (0, import_nodes21.snakeCase)(name).toUpperCase(),
-  constantFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Bytes`,
-  dataArgsType: (name) => `${(0, import_nodes21.pascalCase)(name)}Args`,
-  dataType: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
-  decoderFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Decoder`,
+  accountDecodeFunction: (name) => `decode${(0, import_nodes25.pascalCase)(name)}`,
+  accountFetchAllFunction: (name) => `fetchAll${(0, import_nodes25.pascalCase)(name)}`,
+  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${(0, import_nodes25.pascalCase)(name)}`,
+  accountFetchFromSeedsFunction: (name) => `fetch${(0, import_nodes25.pascalCase)(name)}FromSeeds`,
+  accountFetchFunction: (name) => `fetch${(0, import_nodes25.pascalCase)(name)}`,
+  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${(0, import_nodes25.pascalCase)(name)}FromSeeds`,
+  accountFetchMaybeFunction: (name) => `fetchMaybe${(0, import_nodes25.pascalCase)(name)}`,
+  accountGetSizeFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}Size`,
+  codecFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}Codec`,
+  constant: (name) => (0, import_nodes25.snakeCase)(name).toUpperCase(),
+  constantFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}Bytes`,
+  dataArgsType: (name) => `${(0, import_nodes25.pascalCase)(name)}Args`,
+  dataType: (name) => `${(0, import_nodes25.pascalCase)(name)}`,
+  decoderFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}Decoder`,
   discriminatedUnionDiscriminator: () => "__kind",
-  discriminatedUnionFunction: (name) => `${(0, import_nodes21.camelCase)(name)}`,
-  discriminatedUnionVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
-  encoderFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Encoder`,
-  enumVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
-  instructionAsyncFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}InstructionAsync`,
-  instructionAsyncInputType: (name) => `${(0, import_nodes21.pascalCase)(name)}AsyncInput`,
-  instructionDataType: (name) => `${(0, import_nodes21.pascalCase)(name)}InstructionData`,
-  instructionExtraType: (name) => `${(0, import_nodes21.pascalCase)(name)}InstructionExtra`,
-  instructionParseFunction: (name) => `parse${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  instructionParsedType: (name) => `Parsed${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  instructionSyncFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  instructionSyncInputType: (name) => `${(0, import_nodes21.pascalCase)(name)}Input`,
-  instructionType: (name) => `${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  isDiscriminatedUnionFunction: (name) => `is${(0, import_nodes21.pascalCase)(name)}`,
-  pdaFindFunction: (name) => `find${(0, import_nodes21.pascalCase)(name)}Pda`,
-  pdaSeedsType: (name) => `${(0, import_nodes21.pascalCase)(name)}Seeds`,
-  programAccountsEnum: (name) => `${(0, import_nodes21.pascalCase)(name)}Account`,
-  programAccountsEnumVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
-  programAccountsIdentifierFunction: (name) => `identify${(0, import_nodes21.pascalCase)(name)}Account`,
-  programAddressConstant: (name) => `${(0, import_nodes21.snakeCase)(name).toUpperCase()}_PROGRAM_ADDRESS`,
-  programErrorConstant: (name) => (0, import_nodes21.snakeCase)(name).toUpperCase(),
-  programErrorConstantPrefix: (name) => `${(0, import_nodes21.snakeCase)(name).toUpperCase()}_ERROR__`,
-  programErrorMessagesMap: (name) => `${(0, import_nodes21.camelCase)(name)}ErrorMessages`,
-  programErrorUnion: (name) => `${(0, import_nodes21.pascalCase)(name)}Error`,
-  programGetErrorMessageFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}ErrorMessage`,
-  programInstructionsEnum: (name) => `${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  programInstructionsEnumVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
-  programInstructionsIdentifierFunction: (name) => `identify${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  programInstructionsParsedUnionType: (name) => `Parsed${(0, import_nodes21.pascalCase)(name)}Instruction`,
-  programIsErrorFunction: (name) => `is${(0, import_nodes21.pascalCase)(name)}Error`,
-  resolverFunction: (name) => `${(0, import_nodes21.camelCase)(name)}`
+  discriminatedUnionFunction: (name) => `${(0, import_nodes25.camelCase)(name)}`,
+  discriminatedUnionVariant: (name) => `${(0, import_nodes25.pascalCase)(name)}`,
+  encoderFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}Encoder`,
+  enumVariant: (name) => `${(0, import_nodes25.pascalCase)(name)}`,
+  instructionAsyncFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}InstructionAsync`,
+  instructionAsyncInputType: (name) => `${(0, import_nodes25.pascalCase)(name)}AsyncInput`,
+  instructionDataType: (name) => `${(0, import_nodes25.pascalCase)(name)}InstructionData`,
+  instructionExtraType: (name) => `${(0, import_nodes25.pascalCase)(name)}InstructionExtra`,
+  instructionParseFunction: (name) => `parse${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  instructionParsedType: (name) => `Parsed${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  instructionSyncFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  instructionSyncInputType: (name) => `${(0, import_nodes25.pascalCase)(name)}Input`,
+  instructionType: (name) => `${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  isDiscriminatedUnionFunction: (name) => `is${(0, import_nodes25.pascalCase)(name)}`,
+  pdaFindFunction: (name) => `find${(0, import_nodes25.pascalCase)(name)}Pda`,
+  pdaSeedsType: (name) => `${(0, import_nodes25.pascalCase)(name)}Seeds`,
+  programAccountsEnum: (name) => `${(0, import_nodes25.pascalCase)(name)}Account`,
+  programAccountsEnumVariant: (name) => `${(0, import_nodes25.pascalCase)(name)}`,
+  programAccountsIdentifierFunction: (name) => `identify${(0, import_nodes25.pascalCase)(name)}Account`,
+  programAddressConstant: (name) => `${(0, import_nodes25.snakeCase)(name).toUpperCase()}_PROGRAM_ADDRESS`,
+  programErrorConstant: (name) => (0, import_nodes25.snakeCase)(name).toUpperCase(),
+  programErrorConstantPrefix: (name) => `${(0, import_nodes25.snakeCase)(name).toUpperCase()}_ERROR__`,
+  programErrorMessagesMap: (name) => `${(0, import_nodes25.camelCase)(name)}ErrorMessages`,
+  programErrorUnion: (name) => `${(0, import_nodes25.pascalCase)(name)}Error`,
+  programGetErrorMessageFunction: (name) => `get${(0, import_nodes25.pascalCase)(name)}ErrorMessage`,
+  programInstructionsEnum: (name) => `${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  programInstructionsEnumVariant: (name) => `${(0, import_nodes25.pascalCase)(name)}`,
+  programInstructionsIdentifierFunction: (name) => `identify${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  programInstructionsParsedUnionType: (name) => `Parsed${(0, import_nodes25.pascalCase)(name)}Instruction`,
+  programIsErrorFunction: (name) => `is${(0, import_nodes25.pascalCase)(name)}Error`,
+  resolverFunction: (name) => `${(0, import_nodes25.camelCase)(name)}`
 };
 
 // src/getRenderMapVisitor.ts
@@ -2525,9 +2543,9 @@ function getRenderMapVisitor(options = {}) {
   const renderParentInstructions = options.renderParentInstructions ?? false;
   const dependencyMap = options.dependencyMap ?? {};
   const useGranularImports = options.useGranularImports ?? false;
-  const asyncResolvers = (options.asyncResolvers ?? []).map(import_nodes22.camelCase);
-  const nonScalarEnums = (options.nonScalarEnums ?? []).map(import_nodes22.camelCase);
-  const internalNodes = (options.internalNodes ?? []).map(import_nodes22.camelCase);
+  const asyncResolvers = (options.asyncResolvers ?? []).map(import_nodes26.camelCase);
+  const nonScalarEnums = (options.nonScalarEnums ?? []).map(import_nodes26.camelCase);
+  const internalNodes = (options.internalNodes ?? []).map(import_nodes26.camelCase);
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const getImportFrom = getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData);
@@ -2541,6 +2559,7 @@ function getRenderMapVisitor(options = {}) {
     stack
   });
   const resolvedInstructionInputVisitor = (0, import_visitors_core21.getResolvedInstructionInputsVisitor)();
+  const byteSizeVisitor = (0, import_visitors_core21.getByteSizeVisitor)(linkables, { stack });
   const globalScope = {
     asyncResolvers,
     customAccountData,
@@ -2568,9 +2587,10 @@ function getRenderMapVisitor(options = {}) {
         const scope = {
           ...globalScope,
           accountPath,
+          size: (0, import_visitors_core21.visit)(node, byteSizeVisitor),
           typeManifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor)
         };
-        const fields = (0, import_nodes22.resolveNestedTypeNode)(node.data).fields;
+        const fields = (0, import_nodes26.resolveNestedTypeNode)(node.data).fields;
         const accountDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
           discriminatorNodes: node.discriminators ?? [],
@@ -2589,7 +2609,7 @@ function getRenderMapVisitor(options = {}) {
           accountPdaHelpersFragment
         );
         return new import_renderers_core.RenderMap().add(
-          `accounts/${(0, import_nodes22.camelCase)(node.name)}.ts`,
+          `accounts/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("accountsPage.njk", {
             accountDiscriminatorConstantsFragment,
             accountFetchHelpersFragment,
@@ -2608,6 +2628,8 @@ function getRenderMapVisitor(options = {}) {
           encoderDocs: [],
           manifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor),
           name: node.name,
+          node: node.type,
+          size: (0, import_visitors_core21.visit)(node, byteSizeVisitor),
           typeDocs: node.docs,
           typeNode: node.type
         };
@@ -2621,7 +2643,7 @@ function getRenderMapVisitor(options = {}) {
           nameApi.codecFunction(node.name)
         ]);
         return new import_renderers_core.RenderMap().add(
-          `types/${(0, import_nodes22.camelCase)(node.name)}.ts`,
+          `types/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("definedTypesPage.njk", {
             imports: imports.toString({
               ...dependencyMap,
@@ -2642,15 +2664,16 @@ function getRenderMapVisitor(options = {}) {
           ...globalScope,
           dataArgsManifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor),
           extraArgsManifest: (0, import_visitors_core21.visit)(
-            (0, import_nodes22.definedTypeNode)({
+            (0, import_nodes26.definedTypeNode)({
               name: instructionExtraName,
-              type: (0, import_nodes22.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
+              type: (0, import_nodes26.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
             }),
             typeManifestVisitor
           ),
           instructionPath,
           renamedArgs: getRenamedArgsMap(node),
-          resolvedInputs: (0, import_visitors_core21.visit)(node, resolvedInstructionInputVisitor)
+          resolvedInputs: (0, import_visitors_core21.visit)(node, resolvedInstructionInputVisitor),
+          size: (0, import_visitors_core21.visit)(node, byteSizeVisitor)
         };
         const instructionDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
@@ -2680,7 +2703,7 @@ function getRenderMapVisitor(options = {}) {
           instructionParseFunctionFragment
         );
         return new import_renderers_core.RenderMap().add(
-          `instructions/${(0, import_nodes22.camelCase)(node.name)}.ts`,
+          `instructions/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("instructionsPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             instruction: node,
@@ -2703,7 +2726,7 @@ function getRenderMapVisitor(options = {}) {
         const pdaFunctionFragment = getPdaFunctionFragment(scope);
         const imports = new ImportMap().mergeWith(pdaFunctionFragment);
         return new import_renderers_core.RenderMap().add(
-          `pdas/${(0, import_nodes22.camelCase)(node.name)}.ts`,
+          `pdas/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("pdasPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             pdaFunctionFragment
@@ -2720,7 +2743,7 @@ function getRenderMapVisitor(options = {}) {
         if (node.errors.length > 0) {
           const programErrorsFragment = getProgramErrorsFragment(scope);
           renderMap.add(
-            `errors/${(0, import_nodes22.camelCase)(node.name)}.ts`,
+            `errors/${(0, import_nodes26.camelCase)(node.name)}.ts`,
             render2("errorsPage.njk", {
               imports: new ImportMap().mergeWith(programErrorsFragment).toString(dependencyMap, useGranularImports),
               programErrorsFragment
@@ -2731,7 +2754,7 @@ function getRenderMapVisitor(options = {}) {
         const programAccountsFragment = getProgramAccountsFragment(scope);
         const programInstructionsFragment = getProgramInstructionsFragment(scope);
         renderMap.add(
-          `programs/${(0, import_nodes22.camelCase)(node.name)}.ts`,
+          `programs/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("programsPage.njk", {
             imports: new ImportMap().mergeWith(programFragment, programAccountsFragment, programInstructionsFragment).toString(dependencyMap, useGranularImports),
             programAccountsFragment,
@@ -2740,7 +2763,7 @@ function getRenderMapVisitor(options = {}) {
           })
         );
         renderMap.mergeWith(
-          ...(0, import_nodes22.getAllInstructionsWithSubs)(node, {
+          ...(0, import_nodes26.getAllInstructionsWithSubs)(node, {
             leavesOnly: !renderParentInstructions
           }).map((ix) => (0, import_visitors_core21.visit)(ix, self))
         );
@@ -2748,14 +2771,14 @@ function getRenderMapVisitor(options = {}) {
       },
       visitRoot(node, { self }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
-        const programsToExport = (0, import_nodes22.getAllPrograms)(node).filter(isNotInternal);
+        const programsToExport = (0, import_nodes26.getAllPrograms)(node).filter(isNotInternal);
         const programsWithErrorsToExport = programsToExport.filter((p) => p.errors.length > 0);
-        const pdasToExport = (0, import_nodes22.getAllPdas)(node);
-        const accountsToExport = (0, import_nodes22.getAllAccounts)(node).filter(isNotInternal);
-        const instructionsToExport = (0, import_nodes22.getAllInstructionsWithSubs)(node, {
+        const pdasToExport = (0, import_nodes26.getAllPdas)(node);
+        const accountsToExport = (0, import_nodes26.getAllAccounts)(node).filter(isNotInternal);
+        const instructionsToExport = (0, import_nodes26.getAllInstructionsWithSubs)(node, {
           leavesOnly: !renderParentInstructions
         }).filter(isNotInternal);
-        const definedTypesToExport = (0, import_nodes22.getAllDefinedTypes)(node).filter(isNotInternal);
+        const definedTypesToExport = (0, import_nodes26.getAllDefinedTypes)(node).filter(isNotInternal);
         const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const ctx = {
           accountsToExport,
@@ -2807,7 +2830,7 @@ 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(...(0, import_nodes22.getAllPrograms)(node).map((p) => (0, import_visitors_core21.visit)(p, self)));
+        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...(0, import_nodes26.getAllPrograms)(node).map((p) => (0, import_visitors_core21.visit)(p, self)));
       }
     }),
     (v) => (0, import_visitors_core21.recordNodeStackVisitor)(v, stack),
@@ -2829,7 +2852,7 @@ function getRenamedArgsMap(instruction) {
   (0, import_errors2.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) => [(0, import_nodes22.camelCase)(name), (0, import_nodes22.camelCase)(`${name}Arg`)]));
+  return new Map(duplicates.map((name) => [(0, import_nodes26.camelCase)(name), (0, import_nodes26.camelCase)(`${name}Arg`)]));
 }
 
 // src/renderVisitor.ts