@codama/renderers-js 1.0.0 → 1.1.0

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("");
   }
@@ -1000,11 +1004,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 +1032,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 +1056,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 +1090,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 +1108,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 +1148,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 +1171,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 +1214,7 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
 function getInstructionFunctionFragment(scope) {
   const {
     useAsync,
-    instructionNode,
-    programNode,
+    instructionPath,
     resolvedInputs,
     renamedArgs,
     dataArgsManifest,
@@ -1214,6 +1222,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("");
   }
@@ -1236,6 +1246,7 @@ function getInstructionFunctionFragment(scope) {
   ).length > 0;
   const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => nodes.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)}()`;
@@ -1279,6 +1290,7 @@ function getInstructionFunctionFragment(scope) {
     hasData,
     hasDataArgs,
     hasExtraArgs,
+    hasInput,
     hasLegacyOptionalAccounts,
     hasRemainingAccounts,
     hasResolver,
@@ -1313,7 +1325,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) => {
@@ -1333,24 +1346,22 @@ 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);
   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(
@@ -1374,7 +1385,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;
@@ -1386,7 +1399,7 @@ function getInstructionTypeFragment(scope) {
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
         allowAccountMeta: true,
-        instructionAccountNode: account
+        instructionAccountPath: [...instructionPath, account]
       })
     ),
     (renders) => renders.join(", ")
@@ -1422,7 +1435,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")) {
@@ -1641,8 +1656,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(
       () => ({
@@ -1653,14 +1668,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 }) {
@@ -1905,7 +1922,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);
@@ -2225,8 +2242,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"));
@@ -2379,7 +2397,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
@@ -2394,16 +2412,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,
@@ -2420,19 +2437,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;
@@ -2498,7 +2514,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);
@@ -2506,14 +2523,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)
         };
@@ -2560,10 +2576,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(
@@ -2575,7 +2592,6 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitProgram(node, { self }) {
-        program = node;
         const customDataDefinedType = [
           ...getDefinedTypeNodesToExtract(node.accounts, customAccountData),
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
@@ -2605,11 +2621,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 }) {
@@ -2676,7 +2691,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) {