@codama/renderers-js 1.0.1 → 1.1.1

package/dist/index.node.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
+var visitorsCore = require('@codama/visitors-core');
 var path = require('path');
 var nodes = require('@codama/nodes');
-var visitorsCore = require('@codama/visitors-core');
 var codecsStrings = require('@solana/codecs-strings');
 var errors = require('@codama/errors');
 require('url');
@@ -424,7 +424,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 = visitorsCore.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)}()`);
@@ -451,8 +452,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 = visitorsCore.getLastNodeFromPath(accountPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(accountPath);
+  const pdaNode = accountNode.pda ? linkables.get([...accountPath, accountNode.pda]) : void 0;
   if (!pdaNode) {
     return fragment("");
   }
@@ -478,10 +481,9 @@ function getAccountPdaHelpersFragment(scope) {
     "type MaybeAccount"
   ]);
 }
-
-// src/fragments/accountSizeHelpers.ts
 function getAccountSizeHelpersFragment(scope) {
-  const { accountNode, nameApi } = scope;
+  const { accountPath, nameApi } = scope;
+  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
   if (accountNode.size == null) {
     return fragment("");
   }
@@ -561,7 +563,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 = visitorsCore.getLastNodeFromPath(accountPath);
   if (customAccountData.has(accountNode.name)) {
     return fragment("");
   }
@@ -632,7 +635,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 = visitorsCore.getLastNodeFromPath(instructionAccountPath);
+  const instructionNode = visitorsCore.findInstructionNodeFromPath(instructionAccountPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(instructionAccountPath);
   const typeParam = `TAccount${nodes.pascalCase(instructionAccountNode.name)}`;
   const accountMeta = allowAccountMeta ? " | IAccountMeta<string>" : "";
   const imports = new ImportMap();
@@ -650,7 +656,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}"`;
@@ -659,7 +665,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
   }
 }
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = scope.instructionNode;
+  const { byteDeltas } = visitorsCore.getLastNodeFromPath(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -715,10 +721,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 = visitorsCore.getLastNodeFromPath(instructionPath);
   if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) {
     return fragment("");
   }
@@ -775,10 +780,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 = visitorsCore.getLastNodeFromPath(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) {
     return fragment("");
   }
@@ -835,17 +839,16 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
           if (nodes.isNode(seed, "constantPdaSeedNode") && nodes.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 (nodes.isNode(seed, "constantPdaSeedNode") && !nodes.isNode(seed.value, "programIdValueNode")) {
             const typeManifest2 = visitorsCore.visit(seed.type, typeManifestVisitor);
             const valueManifest2 = visitorsCore.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 (nodes.isNode(seed, "variablePdaSeedNode")) {
@@ -855,23 +858,22 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
             if (nodes.isNode(valueSeed, "accountValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder}.encode(expectAddress(accounts.${nodes.camelCase(valueSeed.name)}.value))`
+                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${nodes.camelCase(valueSeed.name)}.value))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
               ];
             }
             if (nodes.isNode(valueSeed, "argumentValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder}.encode(expectSome(args.${nodes.camelCase(valueSeed.name)}))`
+                  `${typeManifest2.encoder.render}.encode(expectSome(args.${nodes.camelCase(valueSeed.name)}))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
               ];
             }
             const valueManifest2 = visitorsCore.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 [];
@@ -1000,11 +1002,12 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
+  const instructionNode = visitorsCore.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 = nodes.camelCase(input.name);
@@ -1027,7 +1030,8 @@ ${r}
   );
 }
 function getInstructionInputTypeFragment(scope) {
-  const { instructionNode, useAsync, nameApi } = scope;
+  const { instructionPath, useAsync, nameApi } = scope;
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   const accountsFragment = getAccountsFragment(scope);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
@@ -1050,7 +1054,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 = visitorsCore.getLastNodeFromPath(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
@@ -1083,7 +1088,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 = visitorsCore.getLastNodeFromPath(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
@@ -1100,7 +1106,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 = visitorsCore.getLastNodeFromPath(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
@@ -1139,7 +1146,7 @@ function getRemainingAccountsFragment(instructionNode) {
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = scope.instructionNode;
+  const { remainingAccounts } = visitorsCore.getLastNodeFromPath(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -1162,7 +1169,7 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const { instructionNode } = scope;
+  const instructionNode = visitorsCore.getLastNodeFromPath(scope.instructionPath);
   nodes.assertIsNode(remainingAccounts.value, "argumentValueNode");
   const argumentName = nodes.camelCase(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
@@ -1205,8 +1212,7 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
 function getInstructionFunctionFragment(scope) {
   const {
     useAsync,
-    instructionNode,
-    programNode,
+    instructionPath,
     resolvedInputs,
     renamedArgs,
     dataArgsManifest,
@@ -1214,6 +1220,8 @@ function getInstructionFunctionFragment(scope) {
     nameApi,
     customInstructionData
   } = scope;
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
     return fragment("");
   }
@@ -1315,7 +1323,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 = visitorsCore.getLastNodeFromPath(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
@@ -1335,16 +1344,17 @@ function getInstructionType(scope) {
   ).mapRender((r) => `${instructionTypeName}<${r}>`);
 }
 function getInputTypeCall(scope) {
-  const { instructionNode, useAsync, nameApi } = scope;
+  const { instructionPath, useAsync, nameApi } = scope;
+  const instructionNode = visitorsCore.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${nodes.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 = visitorsCore.getLastNodeFromPath(instructionPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasOptionalAccounts = instructionNode.accounts.some((account) => account.isOptional);
@@ -1373,7 +1383,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 = visitorsCore.getLastNodeFromPath(instructionPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
@@ -1385,7 +1397,7 @@ function getInstructionTypeFragment(scope) {
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
         allowAccountMeta: true,
-        instructionAccountNode: account
+        instructionAccountPath: [...instructionPath, account]
       })
     ),
     (renders) => renders.join(", ")
@@ -1421,7 +1433,9 @@ function getInstructionTypeFragment(scope) {
   return fragment2;
 }
 function getPdaFunctionFragment(scope) {
-  const { pdaNode, programNode, typeManifestVisitor, nameApi } = scope;
+  const { pdaPath, typeManifestVisitor, nameApi } = scope;
+  const pdaNode = visitorsCore.getLastNodeFromPath(pdaPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
     if (nodes.isNode(seed, "variablePdaSeedNode")) {
@@ -1640,8 +1654,8 @@ function mergeManifests(manifests, options = {}) {
 }
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
-  const stack = new visitorsCore.NodeStack();
-  let parentName = input.parentName ?? null;
+  const stack = input.stack ?? new visitorsCore.NodeStack();
+  let parentName = null;
   return visitorsCore.pipe(
     visitorsCore.staticVisitor(
       () => ({
@@ -1652,14 +1666,16 @@ function getTypeManifestVisitor(input) {
         strictType: fragment(""),
         value: fragment("")
       }),
-      [
-        ...nodes.REGISTERED_TYPE_NODE_KINDS,
-        ...nodes.REGISTERED_VALUE_NODE_KINDS,
-        "definedTypeLinkNode",
-        "definedTypeNode",
-        "accountNode",
-        "instructionNode"
-      ]
+      {
+        keys: [
+          ...nodes.REGISTERED_TYPE_NODE_KINDS,
+          ...nodes.REGISTERED_VALUE_NODE_KINDS,
+          "definedTypeLinkNode",
+          "definedTypeNode",
+          "accountNode",
+          "instructionNode"
+        ]
+      }
     ),
     (visitor) => visitorsCore.extendVisitor(visitor, {
       visitAccount(account, { self }) {
@@ -1904,7 +1920,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 && nodes.isNode(enumNode, "enumTypeNode") ? nodes.isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
@@ -1928,19 +1944,19 @@ function getTypeManifestVisitor(input) {
       visitHiddenPrefixType(node, { self }) {
         const manifest = visitorsCore.visit(node.type, self);
         const prefixes = node.prefix.map((c) => visitorsCore.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 = visitorsCore.visit(node.type, self);
         const suffixes = node.suffix.map((c) => visitorsCore.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 }) {
@@ -2108,8 +2124,8 @@ function getTypeManifestVisitor(input) {
       visitSentinelType(node, { self }) {
         const manifest = visitorsCore.visit(node.type, self);
         const sentinel = visitorsCore.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 }) {
@@ -2132,8 +2148,8 @@ function getTypeManifestVisitor(input) {
       visitSizePrefixType(node, { self }) {
         const manifest = visitorsCore.visit(node.type, self);
         const prefix = visitorsCore.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 }) {
@@ -2224,8 +2240,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 = visitorsCore.findLastNodeFromPath(parentPath, "instructionNode");
+        const accountNode = visitorsCore.findLastNodeFromPath(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
         const fieldDiscriminators = discriminators.filter(nodes.isNodeFilter("fieldDiscriminatorNode"));
@@ -2378,7 +2395,7 @@ var DEFAULT_NAME_TRANSFORMERS = {
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
   const linkables = new visitorsCore.LinkableDictionary();
-  let program = null;
+  const stack = new visitorsCore.NodeStack();
   const nameTransformers = {
     ...DEFAULT_NAME_TRANSFORMERS,
     ...options.nameTransformers
@@ -2393,16 +2410,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 = visitorsCore.getResolvedInstructionInputsVisitor();
   const globalScope = {
     asyncResolvers,
@@ -2419,19 +2435,18 @@ function getRenderMapVisitor(options = {}) {
     return render(path.join("pages", template), context, renderOptions);
   };
   return visitorsCore.pipe(
-    visitorsCore.staticVisitor(
-      () => new renderersCore.RenderMap(),
-      ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
-    ),
+    visitorsCore.staticVisitor(() => new renderersCore.RenderMap(), {
+      keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
+    }),
     (v) => visitorsCore.extendVisitor(v, {
       visitAccount(node) {
-        if (!program) {
+        const accountPath = stack.getPath("accountNode");
+        if (!visitorsCore.findProgramNodeFromPath(accountPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = {
           ...globalScope,
-          accountNode: node,
-          programNode: program,
+          accountPath,
           typeManifest: visitorsCore.visit(node, typeManifestVisitor)
         };
         const fields = nodes.resolveNestedTypeNode(node.data).fields;
@@ -2497,7 +2512,8 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitInstruction(node) {
-        if (!program) {
+        const instructionPath = stack.getPath("instructionNode");
+        if (!visitorsCore.findProgramNodeFromPath(instructionPath)) {
           throw new Error("Instruction must be visited inside a program.");
         }
         const instructionExtraName = nameApi.instructionExtraType(node.name);
@@ -2505,14 +2521,13 @@ function getRenderMapVisitor(options = {}) {
           ...globalScope,
           dataArgsManifest: visitorsCore.visit(node, typeManifestVisitor),
           extraArgsManifest: visitorsCore.visit(
-            nodes.structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? []),
-            getTypeManifestVisitor2({
-              loose: nameApi.dataArgsType(instructionExtraName),
-              strict: nameApi.dataType(instructionExtraName)
-            })
+            nodes.definedTypeNode({
+              name: instructionExtraName,
+              type: nodes.structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? [])
+            }),
+            typeManifestVisitor
           ),
-          instructionNode: node,
-          programNode: program,
+          instructionPath,
           renamedArgs: getRenamedArgsMap(node),
           resolvedInputs: visitorsCore.visit(node, resolvedInstructionInputVisitor)
         };
@@ -2559,10 +2574,11 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitPda(node) {
-        if (!program) {
+        const pdaPath = stack.getPath("pdaNode");
+        if (!visitorsCore.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 renderersCore.RenderMap().add(
@@ -2574,7 +2590,6 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitProgram(node, { self }) {
-        program = node;
         const customDataDefinedType = [
           ...getDefinedTypeNodesToExtract(node.accounts, customAccountData),
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
@@ -2604,11 +2619,10 @@ function getRenderMapVisitor(options = {}) {
           })
         );
         renderMap.mergeWith(
-          ...nodes.getAllInstructionsWithSubs(program, {
+          ...nodes.getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
           }).map((ix) => visitorsCore.visit(ix, self))
         );
-        program = null;
         return renderMap;
       },
       visitRoot(node, { self }) {
@@ -2675,7 +2689,8 @@ function getRenderMapVisitor(options = {}) {
         return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...nodes.getAllPrograms(node).map((p) => visitorsCore.visit(p, self)));
       }
     }),
-    (v) => visitorsCore.recordLinkablesVisitor(v, linkables)
+    (v) => visitorsCore.recordNodeStackVisitor(v, stack),
+    (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
 function getRenamedArgsMap(instruction) {