@codama/renderers-js 1.4.2 → 1.5.0

package/dist/index.browser.cjs

@@ -314,7 +314,7 @@ function mergeTypeManifests(manifests, options = {}) {
 }
 
 // src/visitors/getRenderMapVisitor.ts
-var import_nodes28 = require("@codama/nodes");
+var import_nodes29 = require("@codama/nodes");
 var import_renderers_core13 = require("@codama/renderers-core");
 var import_visitors_core29 = require("@codama/visitors-core");
 
@@ -718,11 +718,15 @@ function getAccountTypeFragment(scope) {
   const accountNode = (0, import_visitors_core5.getLastNodeFromPath)(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: (0, import_nodes7.resolveNestedTypeNode)(accountNode.data),
-    size: scope.size
+    size: scope.size,
+    typeDocs: accountNode.docs
   });
 }
 
@@ -928,16 +932,17 @@ function getIsErrorFunctionFragment(scope) {
 }
 
 // src/fragments/indexPage.ts
+var import_nodes11 = require("@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) => (0, import_nodes11.camelCase)(item.name)).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
   return mergeFragments(names, (cs) => cs.join("\n"));
 }
 
 // src/fragments/instructionAccountMeta.ts
-var import_nodes11 = require("@codama/nodes");
+var import_nodes12 = require("@codama/nodes");
 function getInstructionAccountMetaFragment(instructionAccountNode) {
-  const typeParam = `TAccount${(0, import_nodes11.pascalCase)(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${(0, import_nodes12.pascalCase)(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
     return fragment`${use("type WritableSignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
@@ -951,14 +956,14 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
 }
 
 // src/fragments/instructionAccountTypeParam.ts
-var import_nodes12 = require("@codama/nodes");
+var import_nodes13 = require("@codama/nodes");
 var import_visitors_core9 = require("@codama/visitors-core");
 function getInstructionAccountTypeParamFragment(scope) {
   const { instructionAccountPath, allowAccountMeta, linkables } = scope;
   const instructionAccountNode = (0, import_visitors_core9.getLastNodeFromPath)(instructionAccountPath);
   const instructionNode = (0, import_visitors_core9.findInstructionNodeFromPath)(instructionAccountPath);
   const programNode = (0, import_visitors_core9.findProgramNodeFromPath)(instructionAccountPath);
-  const typeParam = `TAccount${(0, import_nodes12.pascalCase)(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${(0, import_nodes13.pascalCase)(instructionAccountNode.name)}`;
   const accountMeta = allowAccountMeta ? fragment` | ${use("type AccountMeta", "solanaInstructions")}<string>` : void 0;
   if (instructionNode.optionalAccountStrategy === "omitted" && instructionAccountNode.isOptional) {
     return fragment`${typeParam} extends string${accountMeta} | undefined = undefined`;
@@ -981,7 +986,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 }
 
 // src/fragments/instructionByteDelta.ts
-var import_nodes13 = require("@codama/nodes");
+var import_nodes14 = require("@codama/nodes");
 var import_renderers_core3 = require("@codama/renderers-core");
 var import_visitors_core10 = require("@codama/visitors-core");
 function getInstructionByteDeltaFragment(scope) {
@@ -996,16 +1001,16 @@ const byteDelta: number = [${c.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   let bytesFragment = (() => {
-    if ((0, import_nodes13.isNode)(byteDelta.value, "numberValueNode")) {
+    if ((0, import_nodes14.isNode)(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if ((0, import_nodes13.isNode)(byteDelta.value, "argumentValueNode")) {
+    if ((0, import_nodes14.isNode)(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if ((0, import_nodes13.isNode)(byteDelta.value, "accountLinkNode")) {
+    if ((0, import_nodes14.isNode)(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if ((0, import_nodes13.isNode)(byteDelta.value, "resolverValueNode")) {
+    if ((0, import_nodes14.isNode)(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -1020,16 +1025,16 @@ function getByteDeltaFragment(byteDelta, scope) {
   return [bytesFragment];
 }
 function getNumberValueNodeFragment(byteDelta) {
-  (0, import_nodes13.assertIsNode)(byteDelta.value, "numberValueNode");
+  (0, import_nodes14.assertIsNode)(byteDelta.value, "numberValueNode");
   return fragment`${byteDelta.value.number}`;
 }
 function getArgumentValueNodeFragment(byteDelta) {
-  (0, import_nodes13.assertIsNode)(byteDelta.value, "argumentValueNode");
-  const argumentName = (0, import_nodes13.camelCase)(byteDelta.value.name);
+  (0, import_nodes14.assertIsNode)(byteDelta.value, "argumentValueNode");
+  const argumentName = (0, import_nodes14.camelCase)(byteDelta.value.name);
   return fragment`Number(args.${argumentName})`;
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
-  (0, import_nodes13.assertIsNode)(byteDelta.value, "accountLinkNode");
+  (0, import_nodes14.assertIsNode)(byteDelta.value, "accountLinkNode");
   const functionName = use(
     scope.nameApi.accountGetSizeFunction(byteDelta.value.name),
     scope.getImportFrom(byteDelta.value)
@@ -1037,7 +1042,7 @@ function getAccountLinkNodeFragment(byteDelta, scope) {
   return fragment`${functionName}()`;
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
-  (0, import_nodes13.assertIsNode)(byteDelta.value, "resolverValueNode");
+  (0, import_nodes14.assertIsNode)(byteDelta.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(byteDelta.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1052,7 +1057,7 @@ function getResolverValueNodeFragment(byteDelta, scope) {
 }
 
 // src/fragments/instructionData.ts
-var import_nodes14 = require("@codama/nodes");
+var import_nodes15 = require("@codama/nodes");
 var import_visitors_core11 = require("@codama/visitors-core");
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
@@ -1063,7 +1068,7 @@ function getInstructionDataFragment(scope) {
     manifest: dataArgsManifest,
     name: instructionDataName,
     nameApi,
-    node: (0, import_nodes14.structTypeNodeFromInstructionArgumentNodes)(instructionNode.arguments),
+    node: (0, import_nodes15.structTypeNodeFromInstructionArgumentNodes)(instructionNode.arguments),
     size: scope.size
   });
 }
@@ -1081,17 +1086,17 @@ function getInstructionExtraArgsFragment(scope) {
 }
 
 // src/fragments/instructionFunction.ts
-var import_nodes19 = require("@codama/nodes");
+var import_nodes20 = require("@codama/nodes");
 var import_renderers_core8 = require("@codama/renderers-core");
 var import_visitors_core17 = require("@codama/visitors-core");
 
 // src/fragments/instructionInputResolved.ts
-var import_nodes16 = require("@codama/nodes");
+var import_nodes17 = require("@codama/nodes");
 var import_renderers_core6 = require("@codama/renderers-core");
 var import_visitors_core14 = require("@codama/visitors-core");
 
 // src/fragments/instructionInputDefault.ts
-var import_nodes15 = require("@codama/nodes");
+var import_nodes16 = require("@codama/nodes");
 var import_renderers_core5 = require("@codama/renderers-core");
 var import_visitors_core13 = require("@codama/visitors-core");
 function getInstructionInputDefaultFragment(scope) {
@@ -1104,8 +1109,8 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = (0, import_nodes15.camelCase)(input.name);
-    if (input.kind === "instructionAccountNode" && (0, import_nodes15.isNode)(defaultValue, "resolverValueNode")) {
+    const inputName = (0, import_nodes16.camelCase)(input.name);
+    if (input.kind === "instructionAccountNode" && (0, import_nodes16.isNode)(defaultValue, "resolverValueNode")) {
       return fragment`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`;
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -1116,63 +1121,57 @@ 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 = (0, import_nodes15.camelCase)(defaultValue.name);
+      const name = (0, import_nodes16.camelCase)(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
-        return (0, import_visitors_core13.pipe)(
-          defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`),
-          (f) => addFragmentImports(f, "shared", ["expectTransactionSigner"])
-        );
+        return defaultFragment(fragment`${expectTransactionSigner}(accounts.${name}.value).address`);
       }
       if (input.kind === "instructionAccountNode") {
-        return (0, import_visitors_core13.pipe)(
-          defaultFragment(`expectSome(accounts.${name}.value)`),
-          (f) => addFragmentImports(f, "shared", ["expectSome"])
-        );
+        return defaultFragment(fragment`${expectSome}(accounts.${name}.value)`);
       }
-      return (0, import_visitors_core13.pipe)(
-        defaultFragment(`expectAddress(accounts.${name}.value)`),
-        (f) => addFragmentImports(f, "shared", ["expectAddress"])
-      );
+      return defaultFragment(fragment`${expectAddress}(accounts.${name}.value)`);
     case "pdaValueNode":
-      if ((0, import_nodes15.isNode)(defaultValue.pda, "pdaNode")) {
-        const pdaProgram = defaultValue.pda.programId ? (0, import_visitors_core13.pipe)(
-          fragment`'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`,
-          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-        ) : fragment`programAddress`;
+      let pdaProgramValue;
+      if ((0, import_nodes16.isNode)(defaultValue.programId, "accountValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(accounts.${(0, import_nodes16.camelCase)(defaultValue.programId.name)}.value)`;
+      }
+      if ((0, import_nodes16.isNode)(defaultValue.programId, "argumentValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(args.${(0, import_nodes16.camelCase)(defaultValue.programId.name)})`;
+      }
+      if ((0, import_nodes16.isNode)(defaultValue.pda, "pdaNode")) {
+        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 ((0, import_nodes15.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes15.isNode)(seed.value, "programIdValueNode")) {
-            return [
-              (0, import_visitors_core13.pipe)(
-                fragment`getAddressEncoder().encode(${pdaProgram})`,
-                (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
-              )
-            ];
+          if ((0, import_nodes16.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes16.isNode)(seed.value, "programIdValueNode")) {
+            return [fragment`${use("getAddressEncoder", "solanaAddresses")}().encode(${pdaProgram})`];
           }
-          if ((0, import_nodes15.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes15.isNode)(seed.value, "programIdValueNode")) {
+          if ((0, import_nodes16.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes16.isNode)(seed.value, "programIdValueNode")) {
             const typeManifest2 = (0, import_visitors_core13.visit)(seed.type, typeManifestVisitor);
             const valueManifest2 = (0, import_visitors_core13.visit)(seed.value, typeManifestVisitor);
             return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
-          if ((0, import_nodes15.isNode)(seed, "variablePdaSeedNode")) {
+          if ((0, import_nodes16.isNode)(seed, "variablePdaSeedNode")) {
             const typeManifest2 = (0, import_visitors_core13.visit)(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if ((0, import_nodes15.isNode)(valueSeed, "accountValueNode")) {
+            if ((0, import_nodes16.isNode)(valueSeed, "accountValueNode")) {
               return [
-                (0, import_visitors_core13.pipe)(
-                  fragment`${typeManifest2.encoder}.encode(expectAddress(accounts.${(0, import_nodes15.camelCase)(valueSeed.name)}.value))`,
-                  (f) => addFragmentImports(f, "shared", ["expectAddress"])
-                )
+                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${(0, import_nodes16.camelCase)(valueSeed.name)}.value))`
               ];
             }
-            if ((0, import_nodes15.isNode)(valueSeed, "argumentValueNode")) {
+            if ((0, import_nodes16.isNode)(valueSeed, "argumentValueNode")) {
               return [
-                (0, import_visitors_core13.pipe)(
-                  fragment`${typeManifest2.encoder}.encode(expectSome(args.${(0, import_nodes15.camelCase)(valueSeed.name)}))`,
-                  (f) => addFragmentImports(f, "shared", ["expectSome"])
-                )
+                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${(0, import_nodes16.camelCase)(valueSeed.name)}))`
               ];
             }
             const valueManifest2 = (0, import_visitors_core13.visit)(valueSeed, typeManifestVisitor);
@@ -1180,29 +1179,21 @@ function getInstructionInputDefaultFragment(scope) {
           }
           return [];
         });
-        return (0, import_visitors_core13.pipe)(
-          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) => (0, import_renderers_core5.mapFragmentContent)(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 ((0, import_nodes15.isNode)(seed.value, "accountValueNode")) {
-          return (0, import_visitors_core13.pipe)(
-            fragment`${seed.name}: expectAddress(accounts.${(0, import_nodes15.camelCase)(seed.value.name)}.value)`,
-            (f) => addFragmentImports(f, "shared", ["expectAddress"])
-          );
+        if ((0, import_nodes16.isNode)(seed.value, "accountValueNode")) {
+          return fragment`${seed.name}: ${expectAddress}(accounts.${(0, import_nodes16.camelCase)(seed.value.name)}.value)`;
         }
-        if ((0, import_nodes15.isNode)(seed.value, "argumentValueNode")) {
-          return (0, import_visitors_core13.pipe)(
-            fragment`${seed.name}: expectSome(args.${(0, import_nodes15.camelCase)(seed.value.name)})`,
-            (f) => addFragmentImports(f, "shared", ["expectSome"])
-          );
+        if ((0, import_nodes16.isNode)(seed.value, "argumentValueNode")) {
+          return fragment`${seed.name}: ${expectSome}(args.${(0, import_nodes16.camelCase)(seed.value.name)})`;
         }
         return (0, import_visitors_core13.pipe)(
           (0, import_visitors_core13.visit)(seed.value, typeManifestVisitor).value,
@@ -1214,49 +1205,38 @@ function getInstructionInputDefaultFragment(scope) {
         (f) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => `{ ${c} }`)
       );
       if (pdaSeeds.length > 0) {
-        pdaArgs.push(pdaSeedsFragment.content);
+        pdaArgs.push(pdaSeedsFragment);
       }
-      const module2 = getImportFrom(defaultValue.pda);
-      return (0, import_visitors_core13.pipe)(
-        defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`),
-        (f) => mergeFragmentImports(f, [pdaSeedsFragment.imports]),
-        (f) => addFragmentImports(f, module2, [pdaFunction])
-      );
+      if (pdaProgramValue) {
+        pdaArgs.push(fragment`{ programAddress: ${pdaProgramValue} }`);
+      }
+      return defaultFragment(fragment`await ${pdaFunction}(${mergeFragments(pdaArgs, (c) => c.join(", "))})`);
     case "publicKeyValueNode":
-      return (0, import_visitors_core13.pipe)(
-        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 (0, import_visitors_core13.pipe)(
-        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 (0, import_visitors_core13.pipe)(
-        defaultFragment(`expectProgramDerivedAddress(accounts.${(0, import_nodes15.camelCase)(defaultValue.name)}.value)[1]`),
-        (f) => addFragmentImports(f, "shared", ["expectProgramDerivedAddress"])
+      return defaultFragment(
+        fragment`${expectProgramDerivedAddress}(accounts.${(0, import_nodes16.camelCase)(defaultValue.name)}.value)[1]`
       );
     case "argumentValueNode":
-      return (0, import_visitors_core13.pipe)(
-        defaultFragment(`expectSome(args.${(0, import_nodes15.camelCase)(defaultValue.name)})`),
-        (f) => addFragmentImports(f, "shared", ["expectSome"])
-      );
+      return defaultFragment(fragment`${expectSome}(args.${(0, import_nodes16.camelCase)(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 (0, import_visitors_core13.pipe)(
-        defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
-        (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
+        defaultFragment(fragment`${resolverAwait}${resolverFunction}(resolverScope)`),
         (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
       );
     case "conditionalValueNode":
@@ -1280,19 +1260,19 @@ function getInstructionInputDefaultFragment(scope) {
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if ((0, import_nodes15.isNode)(defaultValue.condition, "resolverValueNode")) {
+      if ((0, import_nodes16.isNode)(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
-        const module3 = getImportFrom(defaultValue.condition);
+        const module2 = getImportFrom(defaultValue.condition);
         conditionalFragment = (0, import_visitors_core13.pipe)(
           conditionalFragment,
-          (f) => addFragmentImports(f, module3, [conditionalResolverFunction]),
+          (f) => addFragmentImports(f, module2, [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 = (0, import_nodes15.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes15.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes15.camelCase)(defaultValue.condition.name)}`;
+        const comparedInputName = (0, import_nodes16.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes16.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes16.camelCase)(defaultValue.condition.name)}`;
         if (defaultValue.value) {
           const comparedValue = (0, import_visitors_core13.visit)(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
@@ -1320,7 +1300,7 @@ ${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
       );
     default:
       const valueManifest = (0, import_visitors_core13.visit)(defaultValue, typeManifestVisitor).value;
-      return (0, import_visitors_core13.pipe)(valueManifest, (f) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => defaultFragment(c).content));
+      return defaultFragment(valueManifest);
   }
 }
 function renderNestedInstructionDefault(scope) {
@@ -1339,14 +1319,14 @@ function getInstructionInputResolvedFragment(scope) {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
       input,
-      optionalAccountStrategy: (0, import_nodes16.parseOptionalAccountStrategy)(instructionNode.optionalAccountStrategy)
+      optionalAccountStrategy: (0, import_nodes17.parseOptionalAccountStrategy)(instructionNode.optionalAccountStrategy)
     });
     if (!inputFragment.content) return [];
-    const camelName = (0, import_nodes16.camelCase)(input.name);
+    const camelName = (0, import_nodes17.camelCase)(input.name);
     return [
       (0, import_renderers_core6.mapFragmentContent)(
         inputFragment,
-        (c) => (0, import_nodes16.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (c) => (0, import_nodes17.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${c}
 }` : `if (!accounts.${camelName}.value) {
 ${c}
@@ -1361,7 +1341,7 @@ ${c}
 }
 
 // src/fragments/instructionInputType.ts
-var import_nodes17 = require("@codama/nodes");
+var import_nodes18 = require("@codama/nodes");
 var import_renderers_core7 = require("@codama/renderers-core");
 var import_visitors_core15 = require("@codama/visitors-core");
 function getInstructionInputTypeFragment(scope) {
@@ -1371,7 +1351,7 @@ function getInstructionInputTypeFragment(scope) {
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
   let accountTypeParams = "";
   if (instructionNode.accounts.length > 0) {
-    accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes17.pascalCase)(account.name)} extends string = string`).join(", ");
+    accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes18.pascalCase)(account.name)} extends string = string`).join(", ");
     accountTypeParams = `<${accountTypeParams}>`;
   }
   const typeBodyFragment = mergeFragments(
@@ -1394,15 +1374,15 @@ function getAccountsFragment(scope) {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !(0, import_nodes17.isNode)(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !(0, import_nodes18.isNode)(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const docs = getDocblockFragment(account.docs ?? [], true);
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return fragment`${docs}${(0, import_nodes17.camelCase)(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
+    return fragment`${docs}${(0, import_nodes18.camelCase)(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
   });
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getAccountTypeFragment2(account) {
-  const typeParam = `TAccount${(0, import_nodes17.pascalCase)(account.name)}`;
+  const typeParam = `TAccount${(0, import_nodes18.pascalCase)(account.name)}`;
   const address = use("type Address", "solanaAddresses");
   const signer = use("type TransactionSigner", "solanaSigners");
   const pda = use("type ProgramDerivedAddress", "solanaAddresses");
@@ -1448,18 +1428,18 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => (0, import_nodes17.isNode)(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => (0, import_nodes18.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 fragment`${(0, import_nodes17.camelCase)(renamedName)}${optionalSign}: ${argsType}["${(0, import_nodes17.camelCase)(arg.name)}"];`;
+  return fragment`${(0, import_nodes18.camelCase)(renamedName)}${optionalSign}: ${argsType}["${(0, import_nodes18.camelCase)(arg.name)}"];`;
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if ((0, import_nodes17.isNode)(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if ((0, import_nodes18.isNode)(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
-    const allArguments = (0, import_nodes17.getAllInstructionArguments)(instructionNode);
+    const allArguments = (0, import_nodes18.getAllInstructionArguments)(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
     if (argumentExists) return [];
     const isSigner = remainingAccountsNode.isSigner ?? false;
@@ -1470,14 +1450,14 @@ function getRemainingAccountsFragment(instructionNode) {
       if (isSigner === "either") return fragment`${signerFragment} | ${addressFragment}`;
       return isSigner ? signerFragment : addressFragment;
     })();
-    return fragment`${(0, import_nodes17.camelCase)(name)}${optionalSign}: Array<${typeFragment}>;`;
+    return fragment`${(0, import_nodes18.camelCase)(name)}${optionalSign}: Array<${typeFragment}>;`;
   });
   if (fragments.length === 0) return;
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 
 // src/fragments/instructionRemainingAccounts.ts
-var import_nodes18 = require("@codama/nodes");
+var import_nodes19 = require("@codama/nodes");
 var import_visitors_core16 = require("@codama/visitors-core");
 function getInstructionRemainingAccountsFragment(scope) {
   const { remainingAccounts } = (0, import_visitors_core16.getLastNodeFromPath)(scope.instructionPath);
@@ -1494,10 +1474,10 @@ const remainingAccounts: AccountMeta[] = ${c.length === 1 ? c[0] : `[...${c.join
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if ((0, import_nodes18.isNode)(remainingAccounts.value, "argumentValueNode")) {
+    if ((0, import_nodes19.isNode)(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if ((0, import_nodes18.isNode)(remainingAccounts.value, "resolverValueNode")) {
+    if ((0, import_nodes19.isNode)(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1507,8 +1487,8 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(scope.instructionPath);
-  (0, import_nodes18.assertIsNode)(remainingAccounts.value, "argumentValueNode");
-  const argumentName = (0, import_nodes18.camelCase)(remainingAccounts.value.name);
+  (0, import_nodes19.assertIsNode)(remainingAccounts.value, "argumentValueNode");
+  const argumentName = (0, import_nodes19.camelCase)(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1517,7 +1497,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const signerRole = isWritable ? fragment`${accountRole}.WRITABLE_SIGNER` : fragment`${accountRole}.READONLY_SIGNER`;
   const role = isSigner === true ? signerRole : nonSignerRole;
   const argumentArray = isOptional ? `(args.${argumentName} ?? [])` : `args.${argumentName}`;
-  const allArguments = (0, import_nodes18.getAllInstructionArguments)(instructionNode);
+  const allArguments = (0, import_nodes19.getAllInstructionArguments)(instructionNode);
   const argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
     return fragment`${argumentArray}.map((address) => ({ address, role: ${role} }))`;
@@ -1528,7 +1508,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   return fragment`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`;
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
-  (0, import_nodes18.assertIsNode)(remainingAccounts.value, "resolverValueNode");
+  (0, import_nodes19.assertIsNode)(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1551,7 +1531,7 @@ function getInstructionFunctionFragment(scope) {
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const instructionDependencies = getInstructionDependencies(instructionNode, asyncResolvers, useAsync);
-  const argDependencies = instructionDependencies.filter((0, import_nodes19.isNodeFilter)("argumentValueNode")).map((node) => node.name);
+  const argDependencies = instructionDependencies.filter((0, import_nodes20.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);
@@ -1564,7 +1544,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_nodes19.isNode)(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => (0, import_nodes20.isNode)(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const programAddressConstant = use(nameApi.programAddressConstant(programNode.name), "generatedPrograms");
@@ -1615,7 +1595,7 @@ function getAccountsInitializationFragment(instructionNode) {
   if (instructionNode.accounts.length === 0) return;
   const accounts = mergeFragments(
     instructionNode.accounts.map((account) => {
-      const name = (0, import_nodes19.camelCase)(account.name);
+      const name = (0, import_nodes20.camelCase)(account.name);
       const isWritable = account.isWritable ? "true" : "false";
       return fragment`${name}: { value: input.${name} ?? null, isWritable: ${isWritable} }`;
     }),
@@ -1650,7 +1630,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.${(0, import_nodes19.camelCase)(account.name)})`),
+    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${(0, import_nodes20.camelCase)(account.name)})`),
     ...hasRemainingAccounts ? ["...remainingAccounts"] : []
   ].join(", ");
   let accounts;
@@ -1687,7 +1667,7 @@ function getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync)
 function getTypeParamsFragment(instructionNode, programAddressConstant) {
   return mergeFragments(
     [
-      ...instructionNode.accounts.map((account) => fragment`TAccount${(0, import_nodes19.pascalCase)(account.name)} extends string`),
+      ...instructionNode.accounts.map((account) => fragment`TAccount${(0, import_nodes20.pascalCase)(account.name)} extends string`),
       fragment`TProgramAddress extends ${use("type Address", "solanaAddresses")} = typeof ${programAddressConstant}`
     ],
     (cs) => `<${cs.join(", ")}>`
@@ -1698,8 +1678,8 @@ function getInstructionTypeFragment(scope) {
   const instructionNode = (0, import_visitors_core17.getLastNodeFromPath)(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = fragment`TAccount${(0, import_nodes19.pascalCase)(account.name)}`;
-    const camelName = (0, import_nodes19.camelCase)(account.name);
+    const typeParam = fragment`TAccount${(0, import_nodes20.pascalCase)(account.name)}`;
+    const camelName = (0, import_nodes20.camelCase)(account.name);
     if (account.isSigner === "either") {
       const signerRole = use(
         account.isWritable ? "type WritableSignerAccount" : "type ReadonlySignerAccount",
@@ -1722,17 +1702,17 @@ function getInputTypeCallFragment(scope) {
   const instructionNode = (0, import_visitors_core17.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_nodes19.pascalCase)(account.name)}`).join(", ");
+  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes20.pascalCase)(account.name)}`).join(", ");
   return fragment`${inputTypeName}<${accountTypeParams}>`;
 }
 
 // src/fragments/instructionPage.ts
 var import_errors2 = require("@codama/errors");
-var import_nodes22 = require("@codama/nodes");
+var import_nodes23 = require("@codama/nodes");
 var import_visitors_core20 = require("@codama/visitors-core");
 
 // src/fragments/instructionParseFunction.ts
-var import_nodes20 = require("@codama/nodes");
+var import_nodes21 = require("@codama/nodes");
 var import_visitors_core18 = require("@codama/visitors-core");
 function getInstructionParseFunctionFragment(scope) {
   const instructionNode = (0, import_visitors_core18.getLastNodeFromPath)(scope.instructionPath);
@@ -1757,7 +1737,7 @@ function getTypeFragment2(scope) {
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map((account, i) => {
       const docs = getDocblockFragment(account.docs ?? [], true);
-      const name = (0, import_nodes20.camelCase)(account.name);
+      const name = (0, import_nodes21.camelCase)(account.name);
       return fragment`${docs}${name}${account.isOptional ? "?" : ""}: TAccountMetas[${i}]${account.isOptional ? " | undefined" : ""};`;
     }),
     (cs) => hasAccounts ? `
@@ -1829,7 +1809,7 @@ const getNextOptionalAccount = () => {
   }
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map(
-      (account) => account.isOptional ? fragment`${(0, import_nodes20.camelCase)(account.name)}: getNextOptionalAccount()` : fragment`${(0, import_nodes20.camelCase)(account.name)}: getNextAccount()`
+      (account) => account.isOptional ? fragment`${(0, import_nodes21.camelCase)(account.name)}: getNextOptionalAccount()` : fragment`${(0, import_nodes21.camelCase)(account.name)}: getNextAccount()`
     ),
     (cs) => hasAccounts ? `, accounts: { ${cs.join(", ")} }` : ""
   );
@@ -1841,7 +1821,7 @@ const getNextOptionalAccount = () => {
 }
 
 // src/fragments/instructionType.ts
-var import_nodes21 = require("@codama/nodes");
+var import_nodes22 = require("@codama/nodes");
 var import_renderers_core9 = require("@codama/renderers-core");
 var import_visitors_core19 = require("@codama/visitors-core");
 function getInstructionTypeFragment2(scope) {
@@ -1868,7 +1848,7 @@ function getInstructionTypeFragment2(scope) {
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => (0, import_renderers_core9.mapFragmentContent)(getInstructionAccountMetaFragment(account), (c) => {
-        const typeParam = `TAccount${(0, import_nodes21.pascalCase)(account.name)}`;
+        const typeParam = `TAccount${(0, import_nodes22.pascalCase)(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
         const type = `${typeParam} extends string ? ${c} : ${typeParam}`;
         if (!isLegacyOptional) return type;
@@ -1893,9 +1873,9 @@ function getInstructionPageFragment(scope) {
     ...scope,
     dataArgsManifest: (0, import_visitors_core20.visit)(node, scope.typeManifestVisitor),
     extraArgsManifest: (0, import_visitors_core20.visit)(
-      (0, import_nodes22.definedTypeNode)({
+      (0, import_nodes23.definedTypeNode)({
         name: scope.nameApi.instructionExtraType(node.name),
-        type: (0, import_nodes22.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
+        type: (0, import_nodes23.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
       }),
       scope.typeManifestVisitor
     ),
@@ -1934,11 +1914,11 @@ 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_nodes23.camelCase)(name), (0, import_nodes23.camelCase)(`${name}Arg`)]));
 }
 
 // src/fragments/pdaFunction.ts
-var import_nodes23 = require("@codama/nodes");
+var import_nodes24 = require("@codama/nodes");
 var import_visitors_core21 = require("@codama/visitors-core");
 function getPdaFunctionFragment(scope) {
   const pdaNode = (0, import_visitors_core21.getLastNodeFromPath)(scope.pdaPath);
@@ -1949,7 +1929,7 @@ function getPdaFunctionFragment(scope) {
   );
 }
 function getSeedInputTypeFragment(seeds, scope) {
-  const variableSeeds = seeds.filter((0, import_nodes23.isNodeFilter)("variablePdaSeedNode"));
+  const variableSeeds = seeds.filter((0, import_nodes24.isNodeFilter)("variablePdaSeedNode"));
   if (variableSeeds.length === 0) return;
   const pdaNode = (0, import_visitors_core21.getLastNodeFromPath)(scope.pdaPath);
   const seedTypeName = scope.nameApi.pdaSeedsType(pdaNode.name);
@@ -1968,7 +1948,7 @@ function getFunctionFragment2(seeds, scope) {
   const seedTypeName = scope.nameApi.pdaSeedsType(pdaNode.name);
   const findPdaFunction = scope.nameApi.pdaFindFunction(pdaNode.name);
   const docs = getDocblockFragment(pdaNode.docs ?? [], true);
-  const hasVariableSeeds = seeds.filter((0, import_nodes23.isNodeFilter)("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = seeds.filter((0, import_nodes24.isNodeFilter)("variablePdaSeedNode")).length > 0;
   const seedArgument = hasVariableSeeds ? `seeds: ${seedTypeName}, ` : "";
   const programAddress = pdaNode.programId ?? programNode.publicKey;
   const encodedSeeds = mergeFragments(
@@ -1982,8 +1962,8 @@ function getFunctionFragment2(seeds, scope) {
 }
 function parsePdaSeedNodes(seeds, scope) {
   return seeds.map((seed) => {
-    if ((0, import_nodes23.isNode)(seed, "variablePdaSeedNode")) {
-      const name = (0, import_nodes23.camelCase)(seed.name);
+    if ((0, import_nodes24.isNode)(seed, "variablePdaSeedNode")) {
+      const name = (0, import_nodes24.camelCase)(seed.name);
       const docs = getDocblockFragment(seed.docs ?? [], true);
       const { encoder: encoder2, looseType } = (0, import_visitors_core21.visit)(seed.type, scope.typeManifestVisitor);
       return {
@@ -1992,7 +1972,7 @@ function parsePdaSeedNodes(seeds, scope) {
         inputAttribute: fragment`${docs}${name}: ${looseType};`
       };
     }
-    if ((0, import_nodes23.isNode)(seed.value, "programIdValueNode")) {
+    if ((0, import_nodes24.isNode)(seed.value, "programIdValueNode")) {
       const addressEncoder = use("getAddressEncoder", "solanaAddresses");
       return { ...seed, encodedValue: fragment`${addressEncoder}().encode(programAddress)` };
     }
@@ -2012,7 +1992,7 @@ function getPdaPageFragment(scope) {
 }
 
 // src/fragments/programAccounts.ts
-var import_nodes24 = require("@codama/nodes");
+var import_nodes25 = require("@codama/nodes");
 var import_renderers_core10 = require("@codama/renderers-core");
 var import_visitors_core23 = require("@codama/visitors-core");
 function getProgramAccountsFragment(scope) {
@@ -2048,7 +2028,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
           dataName: "data",
           discriminators: account.discriminators ?? [],
           ifTrue: `return ${programAccountsEnum}.${variant};`,
-          struct: (0, import_nodes24.resolveNestedTypeNode)(account.data)
+          struct: (0, import_nodes25.resolveNestedTypeNode)(account.data)
         });
       }),
       (c) => c.join("\n")
@@ -2077,12 +2057,12 @@ function getProgramConstantFragment(scope) {
 }
 
 // src/fragments/programInstructions.ts
-var import_nodes25 = require("@codama/nodes");
+var import_nodes26 = require("@codama/nodes");
 var import_renderers_core11 = require("@codama/renderers-core");
 var import_visitors_core25 = require("@codama/visitors-core");
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return;
-  const allInstructions = (0, import_nodes25.getAllInstructionsWithSubs)(scope.programNode, {
+  const allInstructions = (0, import_nodes26.getAllInstructionsWithSubs)(scope.programNode, {
     leavesOnly: !scope.renderParentInstructions,
     subInstructionsFirst: true
   });
@@ -2121,7 +2101,7 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: (0, import_nodes25.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
+        struct: (0, import_nodes26.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
       });
     }),
     (c) => c.join("\n")
@@ -2308,10 +2288,10 @@ export function isTransactionSigner<TAddress extends string = string>(value: Add
 }
 
 // src/fragments/typeDiscriminatedUnionHelpers.ts
-var import_nodes26 = require("@codama/nodes");
+var import_nodes27 = require("@codama/nodes");
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = (0, import_nodes26.isNode)(typeNode, "enumTypeNode") && (0, import_nodes26.isDataEnum)(typeNode);
+  const isDiscriminatedUnion = (0, import_nodes27.isNode)(typeNode, "enumTypeNode") && (0, import_nodes27.isDataEnum)(typeNode);
   if (!isDiscriminatedUnion) return;
   const functionName = nameApi.discriminatedUnionFunction(name);
   const isDiscriminatedUnionFunctionName = nameApi.isDiscriminatedUnionFunction(name);
@@ -2323,10 +2303,10 @@ function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const variantSignatures = mergeFragments(
     typeNode.variants.map((variant) => {
       const variantName = nameApi.discriminatedUnionVariant(variant.name);
-      if ((0, import_nodes26.isNode)(variant, "enumStructVariantTypeNode")) {
+      if ((0, import_nodes27.isNode)(variant, "enumStructVariantTypeNode")) {
         return fragment`export function ${functionName}(kind: '${variantName}', data: ${getVariantContentType}<${looseName}, '${discriminatorName}', '${variantName}'>): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
       }
-      if ((0, import_nodes26.isNode)(variant, "enumTupleVariantTypeNode")) {
+      if ((0, import_nodes27.isNode)(variant, "enumTupleVariantTypeNode")) {
         return fragment`export function ${functionName}(kind: '${variantName}', data: ${getVariantContentType}<${looseName}, '${discriminatorName}', '${variantName}'>['fields']): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
       }
       return fragment`export function ${functionName}(kind: '${variantName}'): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
@@ -2369,7 +2349,7 @@ function getTypePageFragment(scope) {
 }
 
 // src/visitors/getTypeManifestVisitor.ts
-var import_nodes27 = require("@codama/nodes");
+var import_nodes28 = require("@codama/nodes");
 var import_renderers_core12 = require("@codama/renderers-core");
 var import_visitors_core28 = require("@codama/visitors-core");
 function getTypeManifestVisitor(input) {
@@ -2379,8 +2359,8 @@ function getTypeManifestVisitor(input) {
   return (0, import_visitors_core28.pipe)(
     (0, import_visitors_core28.staticVisitor)(() => typeManifest(), {
       keys: [
-        ...import_nodes27.REGISTERED_TYPE_NODE_KINDS,
-        ...import_nodes27.REGISTERED_VALUE_NODE_KINDS,
+        ...import_nodes28.REGISTERED_TYPE_NODE_KINDS,
+        ...import_nodes28.REGISTERED_VALUE_NODE_KINDS,
         "definedTypeLinkNode",
         "definedTypeNode",
         "accountNode",
@@ -2423,7 +2403,7 @@ function getTypeManifestVisitor(input) {
       visitBooleanType(booleanType, { self }) {
         let sizeEncoder = fragment``;
         let sizeDecoder = fragment``;
-        const resolvedSize = (0, import_nodes27.resolveNestedTypeNode)(booleanType.size);
+        const resolvedSize = (0, import_nodes28.resolveNestedTypeNode)(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
           const size = (0, import_visitors_core28.visit)(booleanType.size, self);
           sizeEncoder = fragment`{ size: ${size.encoder} }`;
@@ -2453,7 +2433,7 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ value: fragment`new Uint8Array([${Array.from(bytes).join(", ")}])` });
       },
       visitConstantValue(node, { self }) {
-        if ((0, import_nodes27.isNode)(node.type, "bytesTypeNode") && (0, import_nodes27.isNode)(node.value, "bytesValueNode")) {
+        if ((0, import_nodes28.isNode)(node.type, "bytesTypeNode") && (0, import_nodes28.isNode)(node.value, "bytesValueNode")) {
           return (0, import_visitors_core28.visit)(node.value, self);
         }
         return typeManifest({
@@ -2486,7 +2466,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes27.camelCase)(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes28.camelCase)(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return typeManifest({
@@ -2499,7 +2479,7 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes27.camelCase)(currentParentName?.strict ?? "")
+          (0, import_nodes28.camelCase)(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -2523,12 +2503,12 @@ function getTypeManifestVisitor(input) {
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes27.camelCase)(currentParentName?.strict ?? "")
+          (0, import_nodes28.camelCase)(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
-        const struct = (0, import_nodes27.structTypeNode)([
-          (0, import_nodes27.structFieldTypeNode)({
+        const struct = (0, import_nodes28.structTypeNode)([
+          (0, import_nodes28.structFieldTypeNode)({
             name: "fields",
             type: enumTupleVariantType.tuple
           })
@@ -2554,16 +2534,16 @@ function getTypeManifestVisitor(input) {
         const currentParentName = parentName;
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = (0, import_nodes27.resolveNestedTypeNode)(enumType.size);
+        const enumSize = (0, import_nodes28.resolveNestedTypeNode)(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
           const sizeManifest = (0, import_visitors_core28.visit)(enumType.size, self);
           encoderOptions.push(fragment`size: ${sizeManifest.encoder}`);
           decoderOptions.push(fragment`size: ${sizeManifest.decoder}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes27.camelCase)(currentParentName?.strict ?? "")
+          (0, import_nodes28.camelCase)(currentParentName?.strict ?? "")
         );
-        if (!(0, import_nodes27.isScalarEnum)(enumType) && discriminator !== "__kind") {
+        if (!(0, import_nodes28.isScalarEnum)(enumType) && discriminator !== "__kind") {
           encoderOptions.push(fragment`discriminator: '${discriminator}'`);
           decoderOptions.push(fragment`discriminator: '${discriminator}'`);
         }
@@ -2575,7 +2555,7 @@ function getTypeManifestVisitor(input) {
           decoderOptions,
           (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
         );
-        if ((0, import_nodes27.isScalarEnum)(enumType)) {
+        if ((0, import_nodes28.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."
@@ -2609,7 +2589,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_nodes27.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes27.isScalarEnum)(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && (0, import_nodes28.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes28.isScalarEnum)(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
           return typeManifest({
@@ -2690,7 +2670,7 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = (0, import_nodes27.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
+        const struct = (0, import_nodes28.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
         const manifest = link ? (0, import_visitors_core28.visit)(link, self) : (0, import_visitors_core28.visit)(struct, self);
         parentName = null;
         return manifest;
@@ -2746,7 +2726,7 @@ function getTypeManifestVisitor(input) {
         const childManifest = (0, import_visitors_core28.visit)(optionType.item, self);
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = (0, import_nodes27.resolveNestedTypeNode)(optionType.prefix);
+        const optionPrefix = (0, import_nodes28.resolveNestedTypeNode)(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
           const prefixManifest = (0, import_visitors_core28.visit)(optionType.prefix, self);
           encoderOptions.push(fragment`prefix: ${prefixManifest.encoder}`);
@@ -2930,7 +2910,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = (0, import_nodes27.camelCase)(structFieldType.name);
+        const name = (0, import_nodes28.camelCase)(structFieldType.name);
         const originalChildManifest = (0, import_visitors_core28.visit)(structFieldType.type, self);
         let docs = getDocblockFragment(structFieldType.docs ?? [], true);
         docs = docs ? fragment`\n${docs}` : docs;
@@ -2982,12 +2962,12 @@ function getTypeManifestVisitor(input) {
         const accountNode = (0, import_visitors_core28.findLastNodeFromPath)(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
-        const fieldDiscriminators = discriminators.filter((0, import_nodes27.isNodeFilter)("fieldDiscriminatorNode"));
+        const fieldDiscriminators = discriminators.filter((0, import_nodes28.isNodeFilter)("fieldDiscriminatorNode"));
         const defaultValues = mergeFragments(
           optionalFields.map((f) => {
-            const key = (0, import_nodes27.camelCase)(f.name);
+            const key = (0, import_nodes28.camelCase)(f.name);
             if (fieldDiscriminators.some((d) => d.name === f.name)) {
-              const constantName = nameApi.constant((0, import_nodes27.camelCase)(`${discriminatorPrefix}_${f.name}`));
+              const constantName = nameApi.constant((0, import_nodes28.camelCase)(`${discriminatorPrefix}_${f.name}`));
               return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${constantName}` : fragment`${key}: value.${key} ?? ${constantName}`;
             }
             const defaultValue = f.defaultValue;
@@ -3058,19 +3038,19 @@ function getTypeManifestVisitor(input) {
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if ((0, import_nodes27.isNode)(count, "fixedCountNode")) {
+  if ((0, import_nodes28.isNode)(count, "fixedCountNode")) {
     return {
       decoder: fragment`size: ${count.value}`,
       encoder: fragment`size: ${count.value}`
     };
   }
-  if ((0, import_nodes27.isNode)(count, "remainderCountNode")) {
+  if ((0, import_nodes28.isNode)(count, "remainderCountNode")) {
     return {
       decoder: fragment`size: 'remainder'`,
       encoder: fragment`size: 'remainder'`
     };
   }
-  const prefix = (0, import_nodes27.resolveNestedTypeNode)(count.prefix);
+  const prefix = (0, import_nodes28.resolveNestedTypeNode)(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: void 0, encoder: void 0 };
   }
@@ -3088,20 +3068,20 @@ function getRenderMapVisitor(options = {}) {
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const renderScopeWithTypeManifestVisitor = {
-    asyncResolvers: (options.asyncResolvers ?? []).map(import_nodes28.camelCase),
+    asyncResolvers: (options.asyncResolvers ?? []).map(import_nodes29.camelCase),
     customAccountData,
     customInstructionData,
     dependencyMap: options.dependencyMap ?? {},
     getImportFrom: getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData),
     linkables,
     nameApi: getNameApi({ ...DEFAULT_NAME_TRANSFORMERS, ...options.nameTransformers }),
-    nonScalarEnums: (options.nonScalarEnums ?? []).map(import_nodes28.camelCase),
+    nonScalarEnums: (options.nonScalarEnums ?? []).map(import_nodes29.camelCase),
     renderParentInstructions: options.renderParentInstructions ?? false,
     useGranularImports: options.useGranularImports ?? false
   };
   const typeManifestVisitor = getTypeManifestVisitor({ ...renderScopeWithTypeManifestVisitor, stack });
   const renderScope = { ...renderScopeWithTypeManifestVisitor, typeManifestVisitor };
-  const internalNodes = (options.internalNodes ?? []).map(import_nodes28.camelCase);
+  const internalNodes = (options.internalNodes ?? []).map(import_nodes29.camelCase);
   const resolvedInstructionInputVisitor = (0, import_visitors_core29.getResolvedInstructionInputsVisitor)();
   const byteSizeVisitor = (0, import_visitors_core29.getByteSizeVisitor)(linkables, { stack });
   const asPage = (fragment2, dependencyMap = {}) => {
@@ -3118,7 +3098,7 @@ function getRenderMapVisitor(options = {}) {
     (v) => (0, import_visitors_core29.extendVisitor)(v, {
       visitAccount(node) {
         return (0, import_renderers_core13.createRenderMap)(
-          `accounts/${(0, import_nodes28.camelCase)(node.name)}.ts`,
+          `accounts/${(0, import_nodes29.camelCase)(node.name)}.ts`,
           asPage(
             getAccountPageFragment({
               ...renderScope,
@@ -3130,7 +3110,7 @@ function getRenderMapVisitor(options = {}) {
       },
       visitDefinedType(node) {
         return (0, import_renderers_core13.createRenderMap)(
-          `types/${(0, import_nodes28.camelCase)(node.name)}.ts`,
+          `types/${(0, import_nodes29.camelCase)(node.name)}.ts`,
           asPage(getTypePageFragment({ ...renderScope, node, size: (0, import_visitors_core29.visit)(node, byteSizeVisitor) }), {
             generatedTypes: "."
           })
@@ -3138,7 +3118,7 @@ function getRenderMapVisitor(options = {}) {
       },
       visitInstruction(node) {
         return (0, import_renderers_core13.createRenderMap)(
-          `instructions/${(0, import_nodes28.camelCase)(node.name)}.ts`,
+          `instructions/${(0, import_nodes29.camelCase)(node.name)}.ts`,
           asPage(
             getInstructionPageFragment({
               ...renderScope,
@@ -3151,7 +3131,7 @@ function getRenderMapVisitor(options = {}) {
       },
       visitPda(node) {
         return (0, import_renderers_core13.createRenderMap)(
-          `pdas/${(0, import_nodes28.camelCase)(node.name)}.ts`,
+          `pdas/${(0, import_nodes29.camelCase)(node.name)}.ts`,
           asPage(getPdaPageFragment({ ...renderScope, pdaPath: stack.getPath("pdaNode") }))
         );
       },
@@ -3163,28 +3143,28 @@ function getRenderMapVisitor(options = {}) {
         const scope = { ...renderScope, programNode: node };
         return (0, import_renderers_core13.mergeRenderMaps)([
           (0, import_renderers_core13.createRenderMap)({
-            [`programs/${(0, import_nodes28.camelCase)(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
-            [`errors/${(0, import_nodes28.camelCase)(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
+            [`programs/${(0, import_nodes29.camelCase)(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
+            [`errors/${(0, import_nodes29.camelCase)(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
           }),
           ...node.pdas.map((p) => (0, import_visitors_core29.visit)(p, self)),
           ...node.accounts.map((a) => (0, import_visitors_core29.visit)(a, self)),
           ...node.definedTypes.map((t) => (0, import_visitors_core29.visit)(t, self)),
           ...customDataDefinedType.map((t) => (0, import_visitors_core29.visit)(t, self)),
-          ...(0, import_nodes28.getAllInstructionsWithSubs)(node, { leavesOnly: !renderScope.renderParentInstructions }).map(
+          ...(0, import_nodes29.getAllInstructionsWithSubs)(node, { leavesOnly: !renderScope.renderParentInstructions }).map(
             (i) => (0, import_visitors_core29.visit)(i, self)
           )
         ]);
       },
       visitRoot(node, { self }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
-        const programsToExport = (0, import_nodes28.getAllPrograms)(node).filter(isNotInternal);
+        const programsToExport = (0, import_nodes29.getAllPrograms)(node).filter(isNotInternal);
         const programsWithErrorsToExport = programsToExport.filter((p) => p.errors.length > 0);
-        const pdasToExport = (0, import_nodes28.getAllPdas)(node);
-        const accountsToExport = (0, import_nodes28.getAllAccounts)(node).filter(isNotInternal);
-        const instructionsToExport = (0, import_nodes28.getAllInstructionsWithSubs)(node, {
+        const pdasToExport = (0, import_nodes29.getAllPdas)(node);
+        const accountsToExport = (0, import_nodes29.getAllAccounts)(node).filter(isNotInternal);
+        const instructionsToExport = (0, import_nodes29.getAllInstructionsWithSubs)(node, {
           leavesOnly: !renderScope.renderParentInstructions
         }).filter(isNotInternal);
-        const definedTypesToExport = (0, import_nodes28.getAllDefinedTypes)(node).filter(isNotInternal);
+        const definedTypesToExport = (0, import_nodes29.getAllDefinedTypes)(node).filter(isNotInternal);
         const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const scope = {
           ...renderScope,
@@ -3205,7 +3185,7 @@ function getRenderMapVisitor(options = {}) {
             ["shared/index.ts"]: hasAnythingToExport ? asPage(getSharedPageFragment()) : void 0,
             ["types/index.ts"]: asPage(getIndexPageFragment(definedTypesToExport))
           }),
-          ...(0, import_nodes28.getAllPrograms)(node).map((p) => (0, import_visitors_core29.visit)(p, self))
+          ...(0, import_nodes29.getAllPrograms)(node).map((p) => (0, import_visitors_core29.visit)(p, self))
         ]);
       }
     }),