@codama/renderers-js 1.0.0 → 1.1.0

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("");
   }
@@ -974,11 +978,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 +1006,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 +1030,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 +1064,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 +1082,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 +1122,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 +1145,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 +1188,7 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
 function getInstructionFunctionFragment(scope) {
   const {
     useAsync,
-    instructionNode,
-    programNode,
+    instructionPath,
     resolvedInputs,
     renamedArgs,
     dataArgsManifest,
@@ -1188,6 +1196,8 @@ function getInstructionFunctionFragment(scope) {
     nameApi,
     customInstructionData
   } = scope;
+  const instructionNode = getLastNodeFromPath(instructionPath);
+  const programNode = findProgramNodeFromPath(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
     return fragment("");
   }
@@ -1210,6 +1220,7 @@ function getInstructionFunctionFragment(scope) {
   ).length > 0;
   const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
+  const hasInput = hasAccounts || hasAnyArgs;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
   const encoderFunction = customData ? dataArgsManifest.encoder.render : `${nameApi.encoderFunction(instructionDataName)}()`;
@@ -1253,6 +1264,7 @@ function getInstructionFunctionFragment(scope) {
     hasData,
     hasDataArgs,
     hasExtraArgs,
+    hasInput,
     hasLegacyOptionalAccounts,
     hasRemainingAccounts,
     hasResolver,
@@ -1287,7 +1299,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) => {
@@ -1307,24 +1320,22 @@ 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);
   const minimumNumberOfAccounts = instructionNode.optionalAccountStrategy === "omitted" ? instructionNode.accounts.filter((account) => !account.isOptional).length : instructionNode.accounts.length;
   const hasData = !!customData || instructionNode.arguments.length > 0;
-  if (!hasAccounts && !hasData) {
-    return fragment("");
-  }
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
   const dataTypeFragment = fragment(
@@ -1348,7 +1359,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;
@@ -1360,7 +1373,7 @@ function getInstructionTypeFragment(scope) {
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
         allowAccountMeta: true,
-        instructionAccountNode: account
+        instructionAccountPath: [...instructionPath, account]
       })
     ),
     (renders) => renders.join(", ")
@@ -1396,7 +1409,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")) {
@@ -1615,8 +1630,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(
       () => ({
@@ -1627,14 +1642,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 }) {
@@ -1879,7 +1896,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);
@@ -2199,8 +2216,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"));
@@ -2353,7 +2371,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
@@ -2368,16 +2386,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,
@@ -2394,19 +2411,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;
@@ -2472,7 +2488,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);
@@ -2480,14 +2497,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)
         };
@@ -2534,10 +2550,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(
@@ -2549,7 +2566,6 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitProgram(node, { self }) {
-        program = node;
         const customDataDefinedType = [
           ...getDefinedTypeNodesToExtract(node.accounts, customAccountData),
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
@@ -2579,11 +2595,10 @@ function getRenderMapVisitor(options = {}) {
           })
         );
         renderMap.mergeWith(
-          ...getAllInstructionsWithSubs(program, {
+          ...getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
           }).map((ix) => visit(ix, self))
         );
-        program = null;
         return renderMap;
       },
       visitRoot(node, { self }) {
@@ -2650,7 +2665,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) {