@codama/renderers-js 1.0.1 → 1.1.1

package/dist/index.node.mjs

@@ -1,8 +1,8 @@
+import { NodeStack, pipe, staticVisitor, extendVisitor, visit, findLastNodeFromPath, recordNodeStackVisitor, LinkableDictionary, getResolvedInstructionInputsVisitor, findProgramNodeFromPath, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, getLastNodeFromPath, deduplicateInstructionDependencies, findInstructionNodeFromPath } from '@codama/visitors-core';
 import { join, dirname } from 'node:path';
-import { REGISTERED_TYPE_NODE_KINDS, REGISTERED_VALUE_NODE_KINDS, resolveNestedTypeNode, isNode, camelCase, structTypeNode, structFieldTypeNode, isScalarEnum, structTypeNodeFromInstructionArgumentNodes, isNodeFilter, pascalCase, snakeCase, getAllInstructionsWithSubs, getAllPrograms, getAllPdas, getAllAccounts, getAllDefinedTypes, definedTypeLinkNode, definedTypeNode, isDataEnum, capitalize, kebabCase, titleCase, constantDiscriminatorNode, constantValueNodeFromBytes, constantValueNode, VALUE_NODES, accountValueNode, argumentValueNode, assertIsNode, getAllInstructionArguments } from '@codama/nodes';
-import { NodeStack, pipe, staticVisitor, extendVisitor, visit, recordNodeStackVisitor, LinkableDictionary, getResolvedInstructionInputsVisitor, recordLinkablesVisitor, rootNodeVisitor, deduplicateInstructionDependencies } from '@codama/visitors-core';
+import { REGISTERED_TYPE_NODE_KINDS, REGISTERED_VALUE_NODE_KINDS, resolveNestedTypeNode, isNode, camelCase, structTypeNode, structFieldTypeNode, isScalarEnum, structTypeNodeFromInstructionArgumentNodes, isNodeFilter, pascalCase, snakeCase, definedTypeNode, getAllInstructionsWithSubs, getAllPrograms, getAllPdas, getAllAccounts, getAllDefinedTypes, definedTypeLinkNode, VALUE_NODES, isDataEnum, capitalize, kebabCase, titleCase, accountValueNode, argumentValueNode, constantDiscriminatorNode, constantValueNodeFromBytes, constantValueNode, assertIsNode, getAllInstructionArguments } from '@codama/nodes';
 import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder, getBase64Decoder } from '@solana/codecs-strings';
-import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND, logWarn } from '@codama/errors';
+import { logWarn, CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
 import { fileURLToPath } from 'node:url';
 import nunjucks from 'nunjucks';
 import { RenderMap, deleteDirectory } from '@codama/renderers-core';
@@ -398,7 +398,8 @@ var Fragment = class _Fragment {
 
 // src/fragments/accountFetchHelpers.ts
 function getAccountFetchHelpersFragment(scope) {
-  const { accountNode, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
+  const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
+  const accountNode = getLastNodeFromPath(accountPath);
   const hasCustomData = customAccountData.has(accountNode.name);
   const accountTypeFragment = hasCustomData ? typeManifest2.strictType.clone() : fragment(nameApi.dataType(accountNode.name));
   const decoderFunctionFragment = hasCustomData ? typeManifest2.decoder.clone() : fragment(`${nameApi.decoderFunction(accountNode.name)}()`);
@@ -425,8 +426,10 @@ function getAccountFetchHelpersFragment(scope) {
   ]);
 }
 function getAccountPdaHelpersFragment(scope) {
-  const { accountNode, programNode, nameApi, linkables, customAccountData, typeManifest: typeManifest2 } = scope;
-  const pdaNode = accountNode.pda ? linkables.get(accountNode.pda) : void 0;
+  const { accountPath, nameApi, linkables, customAccountData, typeManifest: typeManifest2 } = scope;
+  const accountNode = getLastNodeFromPath(accountPath);
+  const programNode = findProgramNodeFromPath(accountPath);
+  const pdaNode = accountNode.pda ? linkables.get([...accountPath, accountNode.pda]) : void 0;
   if (!pdaNode) {
     return fragment("");
   }
@@ -452,10 +455,9 @@ function getAccountPdaHelpersFragment(scope) {
     "type MaybeAccount"
   ]);
 }
-
-// src/fragments/accountSizeHelpers.ts
 function getAccountSizeHelpersFragment(scope) {
-  const { accountNode, nameApi } = scope;
+  const { accountPath, nameApi } = scope;
+  const accountNode = getLastNodeFromPath(accountPath);
   if (accountNode.size == null) {
     return fragment("");
   }
@@ -535,7 +537,8 @@ function getTypeWithCodecFragment(scope) {
 
 // src/fragments/accountType.ts
 function getAccountTypeFragment(scope) {
-  const { accountNode, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
+  const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
+  const accountNode = getLastNodeFromPath(accountPath);
   if (customAccountData.has(accountNode.name)) {
     return fragment("");
   }
@@ -606,7 +609,10 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
   return fragment(`ReadonlyAccount<${typeParam}>`).addImports("solanaInstructions", "type ReadonlyAccount");
 }
 function getInstructionAccountTypeParamFragment(scope) {
-  const { instructionNode, instructionAccountNode, programNode, allowAccountMeta, linkables } = scope;
+  const { instructionAccountPath, allowAccountMeta, linkables } = scope;
+  const instructionAccountNode = getLastNodeFromPath(instructionAccountPath);
+  const instructionNode = findInstructionNodeFromPath(instructionAccountPath);
+  const programNode = findProgramNodeFromPath(instructionAccountPath);
   const typeParam = `TAccount${pascalCase(instructionAccountNode.name)}`;
   const accountMeta = allowAccountMeta ? " | IAccountMeta<string>" : "";
   const imports = new ImportMap();
@@ -624,7 +630,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
     case "publicKeyValueNode":
       return `"${defaultValue.publicKey}"`;
     case "programLinkNode":
-      const programNode = linkables.get(defaultValue);
+      const programNode = linkables.get([defaultValue]);
       return programNode ? `"${programNode.publicKey}"` : "string";
     case "programIdValueNode":
       return `"${programId}"`;
@@ -633,7 +639,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
   }
 }
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = scope.instructionNode;
+  const { byteDeltas } = getLastNodeFromPath(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -689,10 +695,9 @@ function getResolverValueNodeFragment(byteDelta, scope) {
   const functionName = scope.nameApi.resolverFunction(byteDelta.value.name);
   return fragment(`${awaitKeyword}${functionName}(resolverScope)`).addImports(scope.getImportFrom(byteDelta.value), functionName).addFeatures(["instruction:resolverScopeVariable"]);
 }
-
-// src/fragments/instructionData.ts
 function getInstructionDataFragment(scope) {
-  const { instructionNode, dataArgsManifest, nameApi, customInstructionData } = scope;
+  const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) {
     return fragment("");
   }
@@ -749,10 +754,9 @@ function getConstantFragment(scope) {
     (r) => r.join("\n\n")
   );
 }
-
-// src/fragments/instructionExtraArgs.ts
 function getInstructionExtraArgsFragment(scope) {
-  const { instructionNode, extraArgsManifest, nameApi } = scope;
+  const { instructionPath, extraArgsManifest, nameApi } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) {
     return fragment("");
   }
@@ -809,17 +813,16 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
           if (isNode(seed, "constantPdaSeedNode") && isNode(seed.value, "programIdValueNode")) {
             return [
-              fragment(`getAddressEncoder().encode(${pdaProgram})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
+              fragment(`getAddressEncoder().encode(${pdaProgram.render})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
             ];
           }
           if (isNode(seed, "constantPdaSeedNode") && !isNode(seed.value, "programIdValueNode")) {
             const typeManifest2 = visit(seed.type, typeManifestVisitor);
             const valueManifest2 = visit(seed.value, typeManifestVisitor);
             return [
-              fragment(`${typeManifest2.encoder}.encode(${valueManifest2.value})`).mergeImportsWith(
-                typeManifest2.encoder,
-                valueManifest2.value
-              )
+              fragment(
+                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
+              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
             ];
           }
           if (isNode(seed, "variablePdaSeedNode")) {
@@ -829,23 +832,22 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
             if (isNode(valueSeed, "accountValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder}.encode(expectAddress(accounts.${camelCase(valueSeed.name)}.value))`
+                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${camelCase(valueSeed.name)}.value))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
               ];
             }
             if (isNode(valueSeed, "argumentValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder}.encode(expectSome(args.${camelCase(valueSeed.name)}))`
+                  `${typeManifest2.encoder.render}.encode(expectSome(args.${camelCase(valueSeed.name)}))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
               ];
             }
             const valueManifest2 = visit(valueSeed, typeManifestVisitor);
             return [
-              fragment(`${typeManifest2.encoder}.encode(${valueManifest2.value})`).mergeImportsWith(
-                typeManifest2.encoder,
-                valueManifest2.value
-              )
+              fragment(
+                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
+              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
             ];
           }
           return [];
@@ -974,11 +976,12 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
+  const instructionNode = getLastNodeFromPath(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
       input,
-      optionalAccountStrategy: scope.instructionNode.optionalAccountStrategy
+      optionalAccountStrategy: instructionNode.optionalAccountStrategy
     });
     if (!inputFragment.render) return [];
     const camelName = camelCase(input.name);
@@ -1001,7 +1004,8 @@ ${r}
   );
 }
 function getInstructionInputTypeFragment(scope) {
-  const { instructionNode, useAsync, nameApi } = scope;
+  const { instructionPath, useAsync, nameApi } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   const accountsFragment = getAccountsFragment(scope);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
@@ -1024,7 +1028,8 @@ function getInstructionInputTypeFragment(scope) {
   ).addImports("solanaAddresses", ["type Address"]);
 }
 function getAccountsFragment(scope) {
-  const { instructionNode, resolvedInputs, useAsync, asyncResolvers } = scope;
+  const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
@@ -1057,7 +1062,8 @@ function getAccountTypeFragment2(account) {
   return fragment(`Address<${typeParam}>`).addImports("solanaAddresses", ["type Address"]);
 }
 function getDataArgumentsFragments(scope) {
-  const { instructionNode, nameApi } = scope;
+  const { instructionPath, nameApi } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
@@ -1074,7 +1080,8 @@ function getDataArgumentsFragments(scope) {
   return [mergeFragments(fragments, (r) => r.join("\n")), fragment("")];
 }
 function getExtraArgumentsFragment(scope) {
-  const { instructionNode, nameApi } = scope;
+  const { instructionPath, nameApi } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
@@ -1113,7 +1120,7 @@ function getRemainingAccountsFragment(instructionNode) {
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = scope.instructionNode;
+  const { remainingAccounts } = getLastNodeFromPath(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -1136,7 +1143,7 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const { instructionNode } = scope;
+  const instructionNode = getLastNodeFromPath(scope.instructionPath);
   assertIsNode(remainingAccounts.value, "argumentValueNode");
   const argumentName = camelCase(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
@@ -1179,8 +1186,7 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
 function getInstructionFunctionFragment(scope) {
   const {
     useAsync,
-    instructionNode,
-    programNode,
+    instructionPath,
     resolvedInputs,
     renamedArgs,
     dataArgsManifest,
@@ -1188,6 +1194,8 @@ function getInstructionFunctionFragment(scope) {
     nameApi,
     customInstructionData
   } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
+  const programNode = findProgramNodeFromPath(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
     return fragment("");
   }
@@ -1289,7 +1297,8 @@ function getTypeParams(instructionNode, programAddressConstant) {
   return fragment(typeParams.filter((x) => !!x).join(", ")).mapRender((r) => `<${r}>`).addImports("generatedPrograms", [programAddressConstant]);
 }
 function getInstructionType(scope) {
-  const { instructionNode, nameApi } = scope;
+  const { instructionPath, nameApi } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
@@ -1309,16 +1318,17 @@ function getInstructionType(scope) {
   ).mapRender((r) => `${instructionTypeName}<${r}>`);
 }
 function getInputTypeCall(scope) {
-  const { instructionNode, useAsync, nameApi } = scope;
+  const { instructionPath, useAsync, nameApi } = scope;
+  const instructionNode = 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${pascalCase(account.name)}`).join(", ");
   return fragment(`${inputTypeName}<${accountTypeParams}>`);
 }
-
-// src/fragments/instructionParseFunction.ts
 function getInstructionParseFunctionFragment(scope) {
-  const { instructionNode, programNode, dataArgsManifest, nameApi, customInstructionData } = scope;
+  const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
+  const programNode = findProgramNodeFromPath(instructionPath);
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasOptionalAccounts = instructionNode.accounts.some((account) => account.isOptional);
@@ -1347,7 +1357,9 @@ function getInstructionParseFunctionFragment(scope) {
   }).mergeImportsWith(dataTypeFragment).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaInstructions", ["type IInstruction"]).addImports("solanaInstructions", hasAccounts ? ["type IInstructionWithAccounts", "type IAccountMeta"] : []).addImports("solanaInstructions", hasData ? ["type IInstructionWithData"] : []);
 }
 function getInstructionTypeFragment(scope) {
-  const { instructionNode, programNode, nameApi, customInstructionData } = scope;
+  const { instructionPath, nameApi, customInstructionData } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
+  const programNode = findProgramNodeFromPath(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
@@ -1359,7 +1371,7 @@ function getInstructionTypeFragment(scope) {
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
         allowAccountMeta: true,
-        instructionAccountNode: account
+        instructionAccountPath: [...instructionPath, account]
       })
     ),
     (renders) => renders.join(", ")
@@ -1395,7 +1407,9 @@ function getInstructionTypeFragment(scope) {
   return fragment2;
 }
 function getPdaFunctionFragment(scope) {
-  const { pdaNode, programNode, typeManifestVisitor, nameApi } = scope;
+  const { pdaPath, typeManifestVisitor, nameApi } = scope;
+  const pdaNode = getLastNodeFromPath(pdaPath);
+  const programNode = findProgramNodeFromPath(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
     if (isNode(seed, "variablePdaSeedNode")) {
@@ -1614,8 +1628,8 @@ function mergeManifests(manifests, options = {}) {
 }
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
-  const stack = new NodeStack();
-  let parentName = input.parentName ?? null;
+  const stack = input.stack ?? new NodeStack();
+  let parentName = null;
   return pipe(
     staticVisitor(
       () => ({
@@ -1626,14 +1640,16 @@ function getTypeManifestVisitor(input) {
         strictType: fragment(""),
         value: fragment("")
       }),
-      [
-        ...REGISTERED_TYPE_NODE_KINDS,
-        ...REGISTERED_VALUE_NODE_KINDS,
-        "definedTypeLinkNode",
-        "definedTypeNode",
-        "accountNode",
-        "instructionNode"
-      ]
+      {
+        keys: [
+          ...REGISTERED_TYPE_NODE_KINDS,
+          ...REGISTERED_VALUE_NODE_KINDS,
+          "definedTypeLinkNode",
+          "definedTypeNode",
+          "accountNode",
+          "instructionNode"
+        ]
+      }
     ),
     (visitor) => extendVisitor(visitor, {
       visitAccount(account, { self }) {
@@ -1878,7 +1894,7 @@ function getTypeManifestVisitor(input) {
         const enumName = nameApi.dataType(node.enum.name);
         const enumFunction = nameApi.discriminatedUnionFunction(node.enum.name);
         const importFrom = getImportFrom(node.enum);
-        const enumNode = linkables.get(node.enum)?.type;
+        const enumNode = linkables.get([...stack.getPath(), node.enum])?.type;
         const isScalar = enumNode && isNode(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
@@ -1902,19 +1918,19 @@ function getTypeManifestVisitor(input) {
       visitHiddenPrefixType(node, { self }) {
         const manifest = visit(node.type, self);
         const prefixes = node.prefix.map((c) => visit(c, self).value);
-        const prefixEncoders = fragment(prefixes.map((c) => `getConstantEncoder(${c})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...prefixes);
-        const prefixDecoders = fragment(prefixes.map((c) => `getConstantDecoder(${c})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...prefixes);
-        manifest.encoder.mapRender((r) => `getHiddenPrefixEncoder(${r}, [${prefixEncoders}])`).mergeImportsWith(prefixEncoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixEncoder");
-        manifest.decoder.mapRender((r) => `getHiddenPrefixDecoder(${r}, [${prefixDecoders}])`).mergeImportsWith(prefixDecoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixDecoder");
+        const prefixEncoders = fragment(prefixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...prefixes);
+        const prefixDecoders = fragment(prefixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...prefixes);
+        manifest.encoder.mapRender((r) => `getHiddenPrefixEncoder(${r}, [${prefixEncoders.render}])`).mergeImportsWith(prefixEncoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixEncoder");
+        manifest.decoder.mapRender((r) => `getHiddenPrefixDecoder(${r}, [${prefixDecoders.render}])`).mergeImportsWith(prefixDecoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixDecoder");
         return manifest;
       },
       visitHiddenSuffixType(node, { self }) {
         const manifest = visit(node.type, self);
         const suffixes = node.suffix.map((c) => visit(c, self).value);
-        const suffixEncoders = fragment(suffixes.map((c) => `getConstantEncoder(${c})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...suffixes);
-        const suffixDecoders = fragment(suffixes.map((c) => `getConstantDecoder(${c})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...suffixes);
-        manifest.encoder.mapRender((r) => `getHiddenSuffixEncoder(${r}, [${suffixEncoders}])`).mergeImportsWith(suffixEncoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixEncoder");
-        manifest.decoder.mapRender((r) => `getHiddenSuffixDecoder(${r}, [${suffixDecoders}])`).mergeImportsWith(suffixDecoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixDecoder");
+        const suffixEncoders = fragment(suffixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...suffixes);
+        const suffixDecoders = fragment(suffixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...suffixes);
+        manifest.encoder.mapRender((r) => `getHiddenSuffixEncoder(${r}, [${suffixEncoders.render}])`).mergeImportsWith(suffixEncoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixEncoder");
+        manifest.decoder.mapRender((r) => `getHiddenSuffixDecoder(${r}, [${suffixDecoders.render}])`).mergeImportsWith(suffixDecoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixDecoder");
         return manifest;
       },
       visitInstruction(instruction, { self }) {
@@ -2082,8 +2098,8 @@ function getTypeManifestVisitor(input) {
       visitSentinelType(node, { self }) {
         const manifest = visit(node.type, self);
         const sentinel = visit(node.sentinel, self).value;
-        manifest.encoder.mapRender((r) => `addEncoderSentinel(${r}, ${sentinel})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addEncoderSentinel");
-        manifest.decoder.mapRender((r) => `addDecoderSentinel(${r}, ${sentinel})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addDecoderSentinel");
+        manifest.encoder.mapRender((r) => `addEncoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addEncoderSentinel");
+        manifest.decoder.mapRender((r) => `addDecoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addDecoderSentinel");
         return manifest;
       },
       visitSetType(setType, { self }) {
@@ -2106,8 +2122,8 @@ function getTypeManifestVisitor(input) {
       visitSizePrefixType(node, { self }) {
         const manifest = visit(node.type, self);
         const prefix = visit(node.prefix, self);
-        manifest.encoder.mapRender((r) => `addEncoderSizePrefix(${r}, ${prefix.encoder})`).mergeImportsWith(prefix.encoder).addImports("solanaCodecsCore", "addEncoderSizePrefix");
-        manifest.decoder.mapRender((r) => `addDecoderSizePrefix(${r}, ${prefix.decoder})`).mergeImportsWith(prefix.decoder).addImports("solanaCodecsCore", "addDecoderSizePrefix");
+        manifest.encoder.mapRender((r) => `addEncoderSizePrefix(${r}, ${prefix.encoder.render})`).mergeImportsWith(prefix.encoder).addImports("solanaCodecsCore", "addEncoderSizePrefix");
+        manifest.decoder.mapRender((r) => `addDecoderSizePrefix(${r}, ${prefix.decoder.render})`).mergeImportsWith(prefix.decoder).addImports("solanaCodecsCore", "addDecoderSizePrefix");
         return manifest;
       },
       visitSolAmountType({ number }, { self }) {
@@ -2198,8 +2214,9 @@ ${jsDocblock(structFieldType.docs)}` : "";
         if (optionalFields.length === 0) {
           return mergedManifest;
         }
-        const instructionNode = stack.find("instructionNode");
-        const accountNode = stack.find("accountNode");
+        const parentPath = stack.getPath();
+        const instructionNode = findLastNodeFromPath(parentPath, "instructionNode");
+        const accountNode = findLastNodeFromPath(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
         const fieldDiscriminators = discriminators.filter(isNodeFilter("fieldDiscriminatorNode"));
@@ -2352,7 +2369,7 @@ var DEFAULT_NAME_TRANSFORMERS = {
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
   const linkables = new LinkableDictionary();
-  let program = null;
+  const stack = new NodeStack();
   const nameTransformers = {
     ...DEFAULT_NAME_TRANSFORMERS,
     ...options.nameTransformers
@@ -2367,16 +2384,15 @@ function getRenderMapVisitor(options = {}) {
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const getImportFrom = getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData);
-  const getTypeManifestVisitor2 = (parentName) => getTypeManifestVisitor({
+  const typeManifestVisitor = getTypeManifestVisitor({
     customAccountData,
     customInstructionData,
     getImportFrom,
     linkables,
     nameApi,
     nonScalarEnums,
-    parentName
+    stack
   });
-  const typeManifestVisitor = getTypeManifestVisitor2();
   const resolvedInstructionInputVisitor = getResolvedInstructionInputsVisitor();
   const globalScope = {
     asyncResolvers,
@@ -2393,19 +2409,18 @@ function getRenderMapVisitor(options = {}) {
     return render(join("pages", template), context, renderOptions);
   };
   return pipe(
-    staticVisitor(
-      () => new RenderMap(),
-      ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
-    ),
+    staticVisitor(() => new RenderMap(), {
+      keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
+    }),
     (v) => extendVisitor(v, {
       visitAccount(node) {
-        if (!program) {
+        const accountPath = stack.getPath("accountNode");
+        if (!findProgramNodeFromPath(accountPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = {
           ...globalScope,
-          accountNode: node,
-          programNode: program,
+          accountPath,
           typeManifest: visit(node, typeManifestVisitor)
         };
         const fields = resolveNestedTypeNode(node.data).fields;
@@ -2471,7 +2486,8 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitInstruction(node) {
-        if (!program) {
+        const instructionPath = stack.getPath("instructionNode");
+        if (!findProgramNodeFromPath(instructionPath)) {
           throw new Error("Instruction must be visited inside a program.");
         }
         const instructionExtraName = nameApi.instructionExtraType(node.name);
@@ -2479,14 +2495,13 @@ function getRenderMapVisitor(options = {}) {
           ...globalScope,
           dataArgsManifest: visit(node, typeManifestVisitor),
           extraArgsManifest: visit(
-            structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? []),
-            getTypeManifestVisitor2({
-              loose: nameApi.dataArgsType(instructionExtraName),
-              strict: nameApi.dataType(instructionExtraName)
-            })
+            definedTypeNode({
+              name: instructionExtraName,
+              type: structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? [])
+            }),
+            typeManifestVisitor
           ),
-          instructionNode: node,
-          programNode: program,
+          instructionPath,
           renamedArgs: getRenamedArgsMap(node),
           resolvedInputs: visit(node, resolvedInstructionInputVisitor)
         };
@@ -2533,10 +2548,11 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitPda(node) {
-        if (!program) {
+        const pdaPath = stack.getPath("pdaNode");
+        if (!findProgramNodeFromPath(pdaPath)) {
           throw new Error("Account must be visited inside a program.");
         }
-        const scope = { ...globalScope, pdaNode: node, programNode: program };
+        const scope = { ...globalScope, pdaPath };
         const pdaFunctionFragment = getPdaFunctionFragment(scope);
         const imports = new ImportMap().mergeWith(pdaFunctionFragment);
         return new RenderMap().add(
@@ -2548,7 +2564,6 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitProgram(node, { self }) {
-        program = node;
         const customDataDefinedType = [
           ...getDefinedTypeNodesToExtract(node.accounts, customAccountData),
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
@@ -2578,11 +2593,10 @@ function getRenderMapVisitor(options = {}) {
           })
         );
         renderMap.mergeWith(
-          ...getAllInstructionsWithSubs(program, {
+          ...getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
           }).map((ix) => visit(ix, self))
         );
-        program = null;
         return renderMap;
       },
       visitRoot(node, { self }) {
@@ -2649,7 +2663,8 @@ function getRenderMapVisitor(options = {}) {
         return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit(p, self)));
       }
     }),
-    (v) => recordLinkablesVisitor(v, linkables)
+    (v) => recordNodeStackVisitor(v, stack),
+    (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
 function getRenamedArgsMap(instruction) {