@codama/renderers-js 1.2.6 → 1.2.8

package/dist/index.node.cjs

@@ -1,42 +1,46 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var visitorsCore = require('@codama/visitors-core');
-var path = require('path');
-var nodes = require('@codama/nodes');
-var codecsStrings = require('@solana/codecs-strings');
-var errors = require('@codama/errors');
-require('url');
-var nunjucks = require('nunjucks');
-var renderersCore = require('@codama/renderers-core');
-var estreePlugin = require('prettier/plugins/estree');
-var typeScriptPlugin = require('prettier/plugins/typescript');
-var standalone = require('prettier/standalone');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  n.default = e;
-  return Object.freeze(n);
-}
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var nunjucks__default = /*#__PURE__*/_interopDefault(nunjucks);
-var estreePlugin__namespace = /*#__PURE__*/_interopNamespace(estreePlugin);
-var typeScriptPlugin__namespace = /*#__PURE__*/_interopNamespace(typeScriptPlugin);
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_NAME_TRANSFORMERS: () => DEFAULT_NAME_TRANSFORMERS,
+  ImportMap: () => ImportMap,
+  default: () => renderVisitor,
+  getNameApi: () => getNameApi,
+  getRenderMapVisitor: () => getRenderMapVisitor,
+  getTypeManifestVisitor: () => getTypeManifestVisitor,
+  mergeManifests: () => mergeManifests,
+  renderVisitor: () => renderVisitor,
+  typeManifest: () => typeManifest
+});
+module.exports = __toCommonJS(index_exports);
 
 // src/ImportMap.ts
 var DEFAULT_EXTERNAL_MODULE_MAP = {
@@ -83,35 +87,35 @@ var DEFAULT_INTERNAL_MODULE_MAP = {
 var ImportMap = class {
   _imports = /* @__PURE__ */ new Map();
   _aliases = /* @__PURE__ */ new Map();
-  add(module, imports) {
+  add(module2, imports) {
     const newImports = new Set(typeof imports === "string" ? [imports] : imports);
     if (newImports.size === 0) return this;
-    const currentImports = this._imports.get(module) ?? /* @__PURE__ */ new Set();
+    const currentImports = this._imports.get(module2) ?? /* @__PURE__ */ new Set();
     newImports.forEach((i) => currentImports.add(i));
-    this._imports.set(module, currentImports);
+    this._imports.set(module2, currentImports);
     return this;
   }
-  remove(module, imports) {
+  remove(module2, imports) {
     const importsToRemove = new Set(typeof imports === "string" ? [imports] : imports);
     if (importsToRemove.size === 0) return this;
-    const currentImports = this._imports.get(module) ?? /* @__PURE__ */ new Set();
+    const currentImports = this._imports.get(module2) ?? /* @__PURE__ */ new Set();
     importsToRemove.forEach((i) => currentImports.delete(i));
     if (currentImports.size === 0) {
-      this._imports.delete(module);
+      this._imports.delete(module2);
     } else {
-      this._imports.set(module, currentImports);
+      this._imports.set(module2, currentImports);
     }
     return this;
   }
   mergeWith(...others) {
     others.forEach((rawOther) => {
       const other = "imports" in rawOther ? rawOther.imports : rawOther;
-      other._imports.forEach((imports, module) => {
-        this.add(module, imports);
+      other._imports.forEach((imports, module2) => {
+        this.add(module2, imports);
       });
-      other._aliases.forEach((aliases, module) => {
+      other._aliases.forEach((aliases, module2) => {
         Object.entries(aliases).forEach(([name, alias]) => {
-          this.addAlias(module, name, alias);
+          this.addAlias(module2, name, alias);
         });
       });
     });
@@ -120,10 +124,10 @@ var ImportMap = class {
   mergeWithManifest(manifest) {
     return this.mergeWith(manifest.strictType, manifest.looseType, manifest.encoder, manifest.decoder);
   }
-  addAlias(module, name, alias) {
-    const currentAliases = this._aliases.get(module) ?? {};
+  addAlias(module2, name, alias) {
+    const currentAliases = this._aliases.get(module2) ?? {};
     currentAliases[name] = alias;
-    this._aliases.set(module, currentAliases);
+    this._aliases.set(module2, currentAliases);
     return this;
   }
   isEmpty() {
@@ -131,10 +135,10 @@ var ImportMap = class {
   }
   resolve(dependencies = {}, useGranularImports = false) {
     const aliasedMap = new Map(
-      [...this._imports.entries()].map(([module, imports]) => {
-        const aliasMap = this._aliases.get(module) ?? {};
+      [...this._imports.entries()].map(([module2, imports]) => {
+        const aliasMap = this._aliases.get(module2) ?? {};
         const joinedImports = [...imports].map((i) => aliasMap[i] ? `${i} as ${aliasMap[i]}` : i);
-        return [module, new Set(joinedImports)];
+        return [module2, new Set(joinedImports)];
       })
     );
     const dependencyMap = {
@@ -143,8 +147,8 @@ var ImportMap = class {
       ...dependencies
     };
     const resolvedMap = /* @__PURE__ */ new Map();
-    aliasedMap.forEach((imports, module) => {
-      const resolvedModule = dependencyMap[module] ?? module;
+    aliasedMap.forEach((imports, module2) => {
+      const resolvedModule = dependencyMap[module2] ?? module2;
       const currentImports = resolvedMap.get(resolvedModule) ?? /* @__PURE__ */ new Set();
       imports.forEach((i) => currentImports.add(i));
       resolvedMap.set(resolvedModule, currentImports);
@@ -158,7 +162,7 @@ var ImportMap = class {
       if (aIsRelative && !bIsRelative) return 1;
       if (!aIsRelative && bIsRelative) return -1;
       return a.localeCompare(b);
-    }).map(([module, imports]) => {
+    }).map(([module2, imports]) => {
       const joinedImports = [...imports].sort().filter((i) => {
         const name = i.split(" ");
         if (name.length > 1) {
@@ -166,16 +170,26 @@ var ImportMap = class {
         }
         return true;
       }).join(", ");
-      return `import { ${joinedImports} } from '${module}';`;
+      return `import { ${joinedImports} } from '${module2}';`;
     }).join("\n");
   }
 };
+
+// src/fragments/accountFetchHelpers.ts
+var import_visitors_core2 = require("@codama/visitors-core");
+
+// src/fragments/common.ts
+var import_node_path2 = require("path");
+
+// src/utils/async.ts
+var import_nodes = require("@codama/nodes");
+var import_visitors_core = require("@codama/visitors-core");
 function hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers) {
   const hasByteDeltasAsync = (instructionNode.byteDeltas ?? []).some(
-    ({ value }) => nodes.isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
+    ({ value }) => (0, import_nodes.isNode)(value, "resolverValueNode") && asyncResolvers.includes(value.name)
   );
   const hasRemainingAccountsAsync = (instructionNode.remainingAccounts ?? []).some(
-    ({ value }) => nodes.isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
+    ({ value }) => (0, import_nodes.isNode)(value, "resolverValueNode") && asyncResolvers.includes(value.name)
   );
   return hasAsyncDefaultValues(resolvedInputs, asyncResolvers) || hasByteDeltasAsync || hasRemainingAccountsAsync;
 }
@@ -197,8 +211,8 @@ function isAsyncDefaultValue(defaultValue, asyncResolvers) {
   }
 }
 function getInstructionDependencies(input, asyncResolvers, useAsync) {
-  if (nodes.isNode(input, "instructionNode")) {
-    return visitorsCore.deduplicateInstructionDependencies([
+  if ((0, import_nodes.isNode)(input, "instructionNode")) {
+    return (0, import_visitors_core.deduplicateInstructionDependencies)([
       ...input.accounts.flatMap((x) => getInstructionDependencies(x, asyncResolvers, useAsync)),
       ...input.arguments.flatMap((x) => getInstructionDependencies(x, asyncResolvers, useAsync)),
       ...(input.extraArguments ?? []).flatMap((x) => getInstructionDependencies(x, asyncResolvers, useAsync))
@@ -209,29 +223,29 @@ function getInstructionDependencies(input, asyncResolvers, useAsync) {
     if (!defaultValue) return [];
     return getInstructionDependencies({ ...input, defaultValue }, asyncResolvers, useAsync);
   };
-  if (nodes.isNode(input.defaultValue, ["accountValueNode", "accountBumpValueNode"])) {
-    return [nodes.accountValueNode(input.defaultValue.name)];
+  if ((0, import_nodes.isNode)(input.defaultValue, ["accountValueNode", "accountBumpValueNode"])) {
+    return [(0, import_nodes.accountValueNode)(input.defaultValue.name)];
   }
-  if (nodes.isNode(input.defaultValue, ["argumentValueNode"])) {
-    return [nodes.argumentValueNode(input.defaultValue.name)];
+  if ((0, import_nodes.isNode)(input.defaultValue, ["argumentValueNode"])) {
+    return [(0, import_nodes.argumentValueNode)(input.defaultValue.name)];
   }
-  if (nodes.isNode(input.defaultValue, "pdaValueNode")) {
+  if ((0, import_nodes.isNode)(input.defaultValue, "pdaValueNode")) {
     const dependencies = /* @__PURE__ */ new Map();
     input.defaultValue.seeds.forEach((seed) => {
-      if (nodes.isNode(seed.value, ["accountValueNode", "argumentValueNode"])) {
+      if ((0, import_nodes.isNode)(seed.value, ["accountValueNode", "argumentValueNode"])) {
         dependencies.set(seed.value.name, { ...seed.value });
       }
     });
     return [...dependencies.values()];
   }
-  if (nodes.isNode(input.defaultValue, "resolverValueNode")) {
+  if ((0, import_nodes.isNode)(input.defaultValue, "resolverValueNode")) {
     const isSynchronousResolver = !asyncResolvers.includes(input.defaultValue.name);
     if (useAsync || isSynchronousResolver) {
       return input.defaultValue.dependsOn ?? [];
     }
   }
-  if (nodes.isNode(input.defaultValue, "conditionalValueNode")) {
-    return visitorsCore.deduplicateInstructionDependencies([
+  if ((0, import_nodes.isNode)(input.defaultValue, "conditionalValueNode")) {
+    return (0, import_visitors_core.deduplicateInstructionDependencies)([
       ...getNestedDependencies(input.defaultValue.condition),
       ...getNestedDependencies(input.defaultValue.ifTrue),
       ...getNestedDependencies(input.defaultValue.ifFalse)
@@ -239,49 +253,58 @@ function getInstructionDependencies(input, asyncResolvers, useAsync) {
   }
   return [];
 }
+
+// src/utils/codecs.ts
+var import_codecs_strings = require("@solana/codecs-strings");
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
-      return codecsStrings.getUtf8Encoder().encode(node.data);
+      return (0, import_codecs_strings.getUtf8Encoder)().encode(node.data);
     case "base16":
-      return codecsStrings.getBase16Encoder().encode(node.data);
+      return (0, import_codecs_strings.getBase16Encoder)().encode(node.data);
     case "base58":
-      return codecsStrings.getBase58Encoder().encode(node.data);
+      return (0, import_codecs_strings.getBase58Encoder)().encode(node.data);
     case "base64":
     default:
-      return codecsStrings.getBase64Encoder().encode(node.data);
+      return (0, import_codecs_strings.getBase64Encoder)().encode(node.data);
   }
 }
+
+// src/utils/customData.ts
+var import_nodes2 = require("@codama/nodes");
 var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
   customDataOptions.map((o) => {
     const options = typeof o === "string" ? { name: o } : o;
-    const importAs = nodes.camelCase(options.importAs ?? `${options.name}${defaultSuffix}`);
+    const importAs = (0, import_nodes2.camelCase)(options.importAs ?? `${options.name}${defaultSuffix}`);
     const importFrom = options.importFrom ?? "hooked";
     return [
-      nodes.camelCase(options.name),
+      (0, import_nodes2.camelCase)(options.name),
       {
         extract: options.extract ?? false,
-        extractAs: options.extractAs ? nodes.camelCase(options.extractAs) : importAs,
+        extractAs: options.extractAs ? (0, import_nodes2.camelCase)(options.extractAs) : importAs,
         importAs,
         importFrom,
-        linkNode: nodes.definedTypeLinkNode(importAs)
+        linkNode: (0, import_nodes2.definedTypeLinkNode)(importAs)
       }
     ];
   })
 );
-var getDefinedTypeNodesToExtract = (nodes$1, parsedCustomDataOptions) => nodes$1.flatMap((node) => {
+var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.flatMap((node) => {
   const options = parsedCustomDataOptions.get(node.name);
   if (!options || !options.extract) return [];
-  if (nodes.isNode(node, "accountNode")) {
-    return [nodes.definedTypeNode({ name: options.extractAs, type: { ...node.data } })];
+  if ((0, import_nodes2.isNode)(node, "accountNode")) {
+    return [(0, import_nodes2.definedTypeNode)({ name: options.extractAs, type: { ...node.data } })];
   }
   return [
-    nodes.definedTypeNode({
+    (0, import_nodes2.definedTypeNode)({
       name: options.extractAs,
-      type: nodes.structTypeNodeFromInstructionArgumentNodes(node.arguments)
+      type: (0, import_nodes2.structTypeNodeFromInstructionArgumentNodes)(node.arguments)
     })
   ];
 });
+
+// src/utils/linkOverrides.ts
+var import_errors = require("@codama/errors");
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
   const customDataOverrides = Object.fromEntries(
     [...customAccountData.values(), ...customInstructionData.values()].map(({ importFrom, importAs }) => [
@@ -313,7 +336,7 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
       case "resolverValueNode":
         return linkOverrides.resolvers[node.name] ?? "hooked";
       default:
-        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+        throw new import_errors.CodamaError(import_errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
           expectedKinds: [
             "AccountLinkNode",
             "DefinedTypeLinkNode",
@@ -328,6 +351,12 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
     }
   };
 }
+
+// src/utils/render.ts
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_nodes3 = require("@codama/nodes");
+var import_nunjucks = __toESM(require("nunjucks"));
 function jsDocblock(docs) {
   if (docs.length <= 0) return "";
   if (docs.length === 1) return `/** ${docs[0]} */
@@ -339,14 +368,14 @@ ${lines.join("\n")}
 `;
 }
 var render = (template, context, options) => {
-  const dirname = __dirname;
-  const templates = path.join(dirname, "templates");
-  const env = nunjucks__default.default.configure(templates, { autoescape: false, trimBlocks: true, ...options });
-  env.addFilter("pascalCase", nodes.pascalCase);
-  env.addFilter("camelCase", nodes.camelCase);
-  env.addFilter("snakeCase", nodes.snakeCase);
-  env.addFilter("kebabCase", nodes.kebabCase);
-  env.addFilter("titleCase", nodes.titleCase);
+  const dirname = false ? pathDirname(fileURLToPath(import_meta.url)) : __dirname;
+  const templates = false ? (0, import_node_path.join)(dirname, "..", "..", "public", "templates") : (0, import_node_path.join)(dirname, "templates");
+  const env = import_nunjucks.default.configure(templates, { autoescape: false, trimBlocks: true, ...options });
+  env.addFilter("pascalCase", import_nodes3.pascalCase);
+  env.addFilter("camelCase", import_nodes3.camelCase);
+  env.addFilter("snakeCase", import_nodes3.snakeCase);
+  env.addFilter("kebabCase", import_nodes3.kebabCase);
+  env.addFilter("titleCase", import_nodes3.titleCase);
   env.addFilter("jsDocblock", jsDocblock);
   return env.render(template, context);
 };
@@ -356,7 +385,7 @@ function fragment(render2, imports) {
   return new Fragment(render2, imports);
 }
 function fragmentFromTemplate(fragmentFile, context, options) {
-  return fragment(render(path.join("fragments", fragmentFile), context, options));
+  return fragment(render((0, import_node_path2.join)("fragments", fragmentFile), context, options));
 }
 function mergeFragments(fragments, mergeRenders) {
   return new Fragment(
@@ -382,20 +411,20 @@ var Fragment = class _Fragment {
     this.render = fn(this.render);
     return this;
   }
-  addImports(module, imports) {
-    this.imports.add(module, imports);
+  addImports(module2, imports) {
+    this.imports.add(module2, imports);
     return this;
   }
-  removeImports(module, imports) {
-    this.imports.remove(module, imports);
+  removeImports(module2, imports) {
+    this.imports.remove(module2, imports);
     return this;
   }
   mergeImportsWith(...others) {
     this.imports.mergeWith(...others);
     return this;
   }
-  addImportAlias(module, name, alias) {
-    this.imports.addAlias(module, name, alias);
+  addImportAlias(module2, name, alias) {
+    this.imports.addAlias(module2, name, alias);
     return this;
   }
   addFeatures(features) {
@@ -427,7 +456,7 @@ var Fragment = class _Fragment {
 // src/fragments/accountFetchHelpers.ts
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
+  const accountNode = (0, import_visitors_core2.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)}()`);
@@ -453,10 +482,14 @@ function getAccountFetchHelpersFragment(scope) {
     "type MaybeEncodedAccount"
   ]);
 }
+
+// src/fragments/accountPdaHelpers.ts
+var import_nodes4 = require("@codama/nodes");
+var import_visitors_core3 = require("@codama/visitors-core");
 function getAccountPdaHelpersFragment(scope) {
   const { accountPath, nameApi, linkables, customAccountData, typeManifest: typeManifest2 } = scope;
-  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
-  const programNode = visitorsCore.findProgramNodeFromPath(accountPath);
+  const accountNode = (0, import_visitors_core3.getLastNodeFromPath)(accountPath);
+  const programNode = (0, import_visitors_core3.findProgramNodeFromPath)(accountPath);
   const pdaNode = accountNode.pda ? linkables.get([...accountPath, accountNode.pda]) : void 0;
   if (!pdaNode) {
     return fragment("");
@@ -465,7 +498,7 @@ function getAccountPdaHelpersFragment(scope) {
   const importFrom = "generatedPdas";
   const pdaSeedsType = nameApi.pdaSeedsType(pdaNode.name);
   const findPdaFunction = nameApi.pdaFindFunction(pdaNode.name);
-  const hasVariableSeeds = pdaNode.seeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = pdaNode.seeds.filter((0, import_nodes4.isNodeFilter)("variablePdaSeedNode")).length > 0;
   return fragmentFromTemplate("accountPdaHelpers.njk", {
     accountType: accountTypeFragment.render,
     fetchFromSeedsFunction: nameApi.accountFetchFromSeedsFunction(accountNode.name),
@@ -483,9 +516,12 @@ function getAccountPdaHelpersFragment(scope) {
     "type MaybeAccount"
   ]);
 }
+
+// src/fragments/accountSizeHelpers.ts
+var import_visitors_core4 = require("@codama/visitors-core");
 function getAccountSizeHelpersFragment(scope) {
   const { accountPath, nameApi } = scope;
-  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
+  const accountNode = (0, import_visitors_core4.getLastNodeFromPath)(accountPath);
   if (accountNode.size == null) {
     return fragment("");
   }
@@ -495,6 +531,9 @@ function getAccountSizeHelpersFragment(scope) {
   });
 }
 
+// src/fragments/accountType.ts
+var import_visitors_core5 = require("@codama/visitors-core");
+
 // src/fragments/type.ts
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
@@ -566,7 +605,7 @@ function getTypeWithCodecFragment(scope) {
 // src/fragments/accountType.ts
 function getAccountTypeFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
+  const accountNode = (0, import_visitors_core5.getLastNodeFromPath)(accountPath);
   if (customAccountData.has(accountNode.name)) {
     return fragment("");
   }
@@ -576,16 +615,21 @@ function getAccountTypeFragment(scope) {
     nameApi
   });
 }
+
+// src/fragments/discriminatorCondition.ts
+var import_nodes5 = require("@codama/nodes");
+var import_visitors_core6 = require("@codama/visitors-core");
+var import_codecs_strings2 = require("@solana/codecs-strings");
 function getDiscriminatorConditionFragment(scope) {
   return mergeFragments(
     scope.discriminators.flatMap((discriminator) => {
-      if (nodes.isNode(discriminator, "sizeDiscriminatorNode")) {
+      if ((0, import_nodes5.isNode)(discriminator, "sizeDiscriminatorNode")) {
         return [getSizeConditionFragment(discriminator, scope)];
       }
-      if (nodes.isNode(discriminator, "constantDiscriminatorNode")) {
+      if ((0, import_nodes5.isNode)(discriminator, "constantDiscriminatorNode")) {
         return [getByteConditionFragment(discriminator, scope)];
       }
-      if (nodes.isNode(discriminator, "fieldDiscriminatorNode")) {
+      if ((0, import_nodes5.isNode)(discriminator, "fieldDiscriminatorNode")) {
         return [getFieldConditionFragment(discriminator, scope)];
       }
       return [];
@@ -599,7 +643,7 @@ function getSizeConditionFragment(discriminator, scope) {
 }
 function getByteConditionFragment(discriminator, scope) {
   const { dataName, typeManifestVisitor } = scope;
-  const constant = visitorsCore.visit(discriminator.constant, typeManifestVisitor).value;
+  const constant = (0, import_visitors_core6.visit)(discriminator.constant, typeManifestVisitor).value;
   return constant.mapRender((r) => `containsBytes(${dataName}, ${r}, ${discriminator.offset})`).addImports("solanaCodecsCore", "containsBytes");
 }
 function getFieldConditionFragment(discriminator, scope) {
@@ -609,22 +653,25 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if (nodes.isNode(field.type, "arrayTypeNode") && nodes.isNode(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && nodes.isNode(field.type.count, "fixedCountNode") && nodes.isNode(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(nodes.isNodeFilter("numberValueNode"))) {
-    const base64Bytes = codecsStrings.getBase64Decoder().decode(
+  if ((0, import_nodes5.isNode)(field.type, "arrayTypeNode") && (0, import_nodes5.isNode)(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && (0, import_nodes5.isNode)(field.type.count, "fixedCountNode") && (0, import_nodes5.isNode)(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every((0, import_nodes5.isNodeFilter)("numberValueNode"))) {
+    const base64Bytes = (0, import_codecs_strings2.getBase64Decoder)().decode(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
     return getByteConditionFragment(
-      nodes.constantDiscriminatorNode(nodes.constantValueNodeFromBytes("base64", base64Bytes), discriminator.offset),
+      (0, import_nodes5.constantDiscriminatorNode)((0, import_nodes5.constantValueNodeFromBytes)("base64", base64Bytes), discriminator.offset),
       scope
     );
   }
   return getByteConditionFragment(
-    nodes.constantDiscriminatorNode(nodes.constantValueNode(field.type, field.defaultValue), discriminator.offset),
+    (0, import_nodes5.constantDiscriminatorNode)((0, import_nodes5.constantValueNode)(field.type, field.defaultValue), discriminator.offset),
     scope
   );
 }
+
+// src/fragments/instructionAccountMeta.ts
+var import_nodes6 = require("@codama/nodes");
 function getInstructionAccountMetaFragment(instructionAccountNode) {
-  const typeParam = `TAccount${nodes.pascalCase(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${(0, import_nodes6.pascalCase)(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
     return fragment(`WritableSignerAccount<${typeParam}> & IAccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type WritableSignerAccount"]).addImports("solanaSigners", ["type IAccountSignerMeta"]);
   }
@@ -636,15 +683,19 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
   }
   return fragment(`ReadonlyAccount<${typeParam}>`).addImports("solanaInstructions", "type ReadonlyAccount");
 }
+
+// src/fragments/instructionAccountTypeParam.ts
+var import_nodes7 = require("@codama/nodes");
+var import_visitors_core7 = require("@codama/visitors-core");
 function getInstructionAccountTypeParamFragment(scope) {
-  const { instructionAccountPath, 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 = " | IAccountMeta<string>" ;
+  const { instructionAccountPath, allowAccountMeta, linkables } = scope;
+  const instructionAccountNode = (0, import_visitors_core7.getLastNodeFromPath)(instructionAccountPath);
+  const instructionNode = (0, import_visitors_core7.findInstructionNodeFromPath)(instructionAccountPath);
+  const programNode = (0, import_visitors_core7.findProgramNodeFromPath)(instructionAccountPath);
+  const typeParam = `TAccount${(0, import_nodes7.pascalCase)(instructionAccountNode.name)}`;
+  const accountMeta = allowAccountMeta ? " | IAccountMeta<string>" : "";
   const imports = new ImportMap();
-  {
+  if (allowAccountMeta) {
     imports.add("solanaInstructions", "type IAccountMeta");
   }
   if (instructionNode.optionalAccountStrategy === "omitted" && instructionAccountNode.isOptional) {
@@ -666,8 +717,12 @@ function getDefaultAddress(defaultValue, programId, linkables) {
       return "string";
   }
 }
+
+// src/fragments/instructionByteDelta.ts
+var import_nodes8 = require("@codama/nodes");
+var import_visitors_core8 = require("@codama/visitors-core");
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = visitorsCore.getLastNodeFromPath(scope.instructionPath);
+  const { byteDeltas } = (0, import_visitors_core8.getLastNodeFromPath)(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -678,16 +733,16 @@ const byteDelta: number = [${r.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   const bytesFragment = (() => {
-    if (nodes.isNode(byteDelta.value, "numberValueNode")) {
+    if ((0, import_nodes8.isNode)(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if (nodes.isNode(byteDelta.value, "argumentValueNode")) {
+    if ((0, import_nodes8.isNode)(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if (nodes.isNode(byteDelta.value, "accountLinkNode")) {
+    if ((0, import_nodes8.isNode)(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if (nodes.isNode(byteDelta.value, "resolverValueNode")) {
+    if ((0, import_nodes8.isNode)(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -702,30 +757,33 @@ function getByteDeltaFragment(byteDelta, scope) {
   return [bytesFragment];
 }
 function getNumberValueNodeFragment(byteDelta) {
-  nodes.assertIsNode(byteDelta.value, "numberValueNode");
+  (0, import_nodes8.assertIsNode)(byteDelta.value, "numberValueNode");
   return fragment(byteDelta.value.number.toString());
 }
 function getArgumentValueNodeFragment(byteDelta) {
-  nodes.assertIsNode(byteDelta.value, "argumentValueNode");
-  const argumentName = nodes.camelCase(byteDelta.value.name);
+  (0, import_nodes8.assertIsNode)(byteDelta.value, "argumentValueNode");
+  const argumentName = (0, import_nodes8.camelCase)(byteDelta.value.name);
   return fragment(`Number(args.${argumentName})`);
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
-  nodes.assertIsNode(byteDelta.value, "accountLinkNode");
+  (0, import_nodes8.assertIsNode)(byteDelta.value, "accountLinkNode");
   const functionName = scope.nameApi.accountGetSizeFunction(byteDelta.value.name);
   return fragment(`${functionName}()`).addImports(scope.getImportFrom(byteDelta.value), functionName);
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
-  nodes.assertIsNode(byteDelta.value, "resolverValueNode");
+  (0, import_nodes8.assertIsNode)(byteDelta.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(byteDelta.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
   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
+var import_visitors_core9 = require("@codama/visitors-core");
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core9.getLastNodeFromPath)(instructionPath);
   if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) {
     return fragment("");
   }
@@ -736,6 +794,10 @@ function getInstructionDataFragment(scope) {
     nameApi
   });
 }
+
+// src/fragments/discriminatorConstants.ts
+var import_nodes9 = require("@codama/nodes");
+var import_visitors_core10 = require("@codama/visitors-core");
 function getDiscriminatorConstantsFragment(scope) {
   const fragments = scope.discriminatorNodes.map((node) => getDiscriminatorConstantFragment(node, scope)).filter(Boolean);
   return mergeFragments(fragments, (r) => r.join("\n\n"));
@@ -752,22 +814,22 @@ function getDiscriminatorConstantFragment(discriminatorNode, scope) {
 }
 function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
-  const index = discriminatorNodes.filter(nodes.isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const index = discriminatorNodes.filter((0, import_nodes9.isNodeFilter)("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = nodes.camelCase(`${prefix}_discriminator${suffix}`);
-  const encoder = visitorsCore.visit(discriminatorNode.constant.type, typeManifestVisitor).encoder;
-  const value = visitorsCore.visit(discriminatorNode.constant.value, typeManifestVisitor).value;
+  const name = (0, import_nodes9.camelCase)(`${prefix}_discriminator${suffix}`);
+  const encoder = (0, import_visitors_core10.visit)(discriminatorNode.constant.type, typeManifestVisitor).encoder;
+  const value = (0, import_visitors_core10.visit)(discriminatorNode.constant.value, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { fields, prefix, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !nodes.isNode(field.defaultValue, nodes.VALUE_NODES)) {
+  if (!field || !field.defaultValue || !(0, import_nodes9.isNode)(field.defaultValue, import_nodes9.VALUE_NODES)) {
     return null;
   }
-  const name = nodes.camelCase(`${prefix}_${discriminatorNode.name}`);
-  const encoder = visitorsCore.visit(field.type, typeManifestVisitor).encoder;
-  const value = visitorsCore.visit(field.defaultValue, typeManifestVisitor).value;
+  const name = (0, import_nodes9.camelCase)(`${prefix}_${discriminatorNode.name}`);
+  const encoder = (0, import_visitors_core10.visit)(field.type, typeManifestVisitor).encoder;
+  const value = (0, import_visitors_core10.visit)(field.defaultValue, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getConstantFragment(scope) {
@@ -782,9 +844,12 @@ function getConstantFragment(scope) {
     (r) => r.join("\n\n")
   );
 }
+
+// src/fragments/instructionExtraArgs.ts
+var import_visitors_core11 = require("@codama/visitors-core");
 function getInstructionExtraArgsFragment(scope) {
   const { instructionPath, extraArgsManifest, nameApi } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core11.getLastNodeFromPath)(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) {
     return fragment("");
   }
@@ -795,6 +860,18 @@ function getInstructionExtraArgsFragment(scope) {
     strictName: nameApi.dataType(instructionExtraName)
   }).mergeImportsWith(extraArgsManifest.looseType);
 }
+
+// src/fragments/instructionFunction.ts
+var import_nodes14 = require("@codama/nodes");
+var import_visitors_core16 = require("@codama/visitors-core");
+
+// src/fragments/instructionInputResolved.ts
+var import_nodes11 = require("@codama/nodes");
+var import_visitors_core13 = require("@codama/visitors-core");
+
+// src/fragments/instructionInputDefault.ts
+var import_nodes10 = require("@codama/nodes");
+var import_visitors_core12 = require("@codama/visitors-core");
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
   if (!input.defaultValue) {
@@ -805,8 +882,8 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = nodes.camelCase(input.name);
-    if (input.kind === "instructionAccountNode" && nodes.isNode(defaultValue, "resolverValueNode")) {
+    const inputName = (0, import_nodes10.camelCase)(input.name);
+    if (input.kind === "instructionAccountNode" && (0, import_nodes10.isNode)(defaultValue, "resolverValueNode")) {
       return fragment(`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`);
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -822,7 +899,7 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
   };
   switch (defaultValue.kind) {
     case "accountValueNode":
-      const name = nodes.camelCase(defaultValue.name);
+      const name = (0, import_nodes10.camelCase)(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
         return defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`).addImports(
           "shared",
@@ -834,44 +911,44 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
     case "pdaValueNode":
-      if (nodes.isNode(defaultValue.pda, "pdaNode")) {
+      if ((0, import_nodes10.isNode)(defaultValue.pda, "pdaNode")) {
         const pdaProgram = defaultValue.pda.programId ? fragment(
           `'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`
         ).addImports("solanaAddresses", "type Address") : fragment("programAddress");
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
-          if (nodes.isNode(seed, "constantPdaSeedNode") && nodes.isNode(seed.value, "programIdValueNode")) {
+          if ((0, import_nodes10.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes10.isNode)(seed.value, "programIdValueNode")) {
             return [
               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);
+          if ((0, import_nodes10.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes10.isNode)(seed.value, "programIdValueNode")) {
+            const typeManifest2 = (0, import_visitors_core12.visit)(seed.type, typeManifestVisitor);
+            const valueManifest2 = (0, import_visitors_core12.visit)(seed.value, typeManifestVisitor);
             return [
               fragment(
                 `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
               ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
             ];
           }
-          if (nodes.isNode(seed, "variablePdaSeedNode")) {
-            const typeManifest2 = visitorsCore.visit(seed.type, typeManifestVisitor);
+          if ((0, import_nodes10.isNode)(seed, "variablePdaSeedNode")) {
+            const typeManifest2 = (0, import_visitors_core12.visit)(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if (nodes.isNode(valueSeed, "accountValueNode")) {
+            if ((0, import_nodes10.isNode)(valueSeed, "accountValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${nodes.camelCase(valueSeed.name)}.value))`
+                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${(0, import_nodes10.camelCase)(valueSeed.name)}.value))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
               ];
             }
-            if (nodes.isNode(valueSeed, "argumentValueNode")) {
+            if ((0, import_nodes10.isNode)(valueSeed, "argumentValueNode")) {
               return [
                 fragment(
-                  `${typeManifest2.encoder.render}.encode(expectSome(args.${nodes.camelCase(valueSeed.name)}))`
+                  `${typeManifest2.encoder.render}.encode(expectSome(args.${(0, import_nodes10.camelCase)(valueSeed.name)}))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
               ];
             }
-            const valueManifest2 = visitorsCore.visit(valueSeed, typeManifestVisitor);
+            const valueManifest2 = (0, import_visitors_core12.visit)(valueSeed, typeManifestVisitor);
             return [
               fragment(
                 `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
@@ -889,18 +966,18 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
-        if (nodes.isNode(seed.value, "accountValueNode")) {
+        if ((0, import_nodes10.isNode)(seed.value, "accountValueNode")) {
           return fragment(
-            `${seed.name}: expectAddress(accounts.${nodes.camelCase(seed.value.name)}.value)`
+            `${seed.name}: expectAddress(accounts.${(0, import_nodes10.camelCase)(seed.value.name)}.value)`
           ).addImports("shared", "expectAddress");
         }
-        if (nodes.isNode(seed.value, "argumentValueNode")) {
-          return fragment(`${seed.name}: expectSome(args.${nodes.camelCase(seed.value.name)})`).addImports(
+        if ((0, import_nodes10.isNode)(seed.value, "argumentValueNode")) {
+          return fragment(`${seed.name}: expectSome(args.${(0, import_nodes10.camelCase)(seed.value.name)})`).addImports(
             "shared",
             "expectSome"
           );
         }
-        return visitorsCore.visit(seed.value, typeManifestVisitor).value.mapRender((r) => `${seed.name}: ${r}`);
+        return (0, import_visitors_core12.visit)(seed.value, typeManifestVisitor).value.mapRender((r) => `${seed.name}: ${r}`);
       });
       const pdaSeedsFragment = mergeFragments(pdaSeeds, (renders) => renders.join(", ")).mapRender((r) => `{ ${r} }`);
       if (pdaSeeds.length > 0) {
@@ -925,10 +1002,10 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       return fragment("");
     case "accountBumpValueNode":
       return defaultFragment(
-        `expectProgramDerivedAddress(accounts.${nodes.camelCase(defaultValue.name)}.value)[1]`
+        `expectProgramDerivedAddress(accounts.${(0, import_nodes10.camelCase)(defaultValue.name)}.value)[1]`
       ).addImports("shared", "expectProgramDerivedAddress");
     case "argumentValueNode":
-      return defaultFragment(`expectSome(args.${nodes.camelCase(defaultValue.name)})`).addImports(
+      return defaultFragment(`expectSome(args.${(0, import_nodes10.camelCase)(defaultValue.name)})`).addImports(
         "shared",
         "expectSome"
       );
@@ -957,16 +1034,16 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if (nodes.isNode(defaultValue.condition, "resolverValueNode")) {
+      if ((0, import_nodes10.isNode)(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
         conditionalFragment.addImports(getImportFrom(defaultValue.condition), conditionalResolverFunction).addFeatures(["instruction:resolverScopeVariable"]);
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
-        const comparedInputName = nodes.isNode(defaultValue.condition, "accountValueNode") ? `accounts.${nodes.camelCase(defaultValue.condition.name)}.value` : `args.${nodes.camelCase(defaultValue.condition.name)}`;
+        const comparedInputName = (0, import_nodes10.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes10.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes10.camelCase)(defaultValue.condition.name)}`;
         if (defaultValue.value) {
-          const comparedValue = visitorsCore.visit(defaultValue.value, typeManifestVisitor).value;
+          const comparedValue = (0, import_visitors_core12.visit)(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment.mergeImportsWith(comparedValue).mergeFeaturesWith(comparedValue);
           const operator = negatedCondition ? "!==" : "===";
           condition = `${comparedInputName} ${operator} ${comparedValue.render}`;
@@ -989,7 +1066,7 @@ ${ifTrueRenderer ? ifTrueRenderer.render : ifFalseRenderer?.render}
 }`
       );
     default:
-      const valueManifest = visitorsCore.visit(defaultValue, typeManifestVisitor).value;
+      const valueManifest = (0, import_visitors_core12.visit)(defaultValue, typeManifestVisitor).value;
       return defaultFragment(valueManifest.render).mergeImportsWith(valueManifest);
   }
 }
@@ -1004,7 +1081,7 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
-  const instructionNode = visitorsCore.getLastNodeFromPath(scope.instructionPath);
+  const instructionNode = (0, import_visitors_core13.getLastNodeFromPath)(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
@@ -1012,10 +1089,10 @@ function getInstructionInputResolvedFragment(scope) {
       optionalAccountStrategy: instructionNode.optionalAccountStrategy
     });
     if (!inputFragment.render) return [];
-    const camelName = nodes.camelCase(input.name);
+    const camelName = (0, import_nodes11.camelCase)(input.name);
     return [
       inputFragment.mapRender(
-        (r) => nodes.isNode(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (r) => (0, import_nodes11.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${r}
 }` : `if (!accounts.${camelName}.value) {
 ${r}
@@ -1031,9 +1108,13 @@ ${r}
     (renders) => renders.join("\n")
   );
 }
+
+// src/fragments/instructionInputType.ts
+var import_nodes12 = require("@codama/nodes");
+var import_visitors_core14 = require("@codama/visitors-core");
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   const accountsFragment = getAccountsFragment(scope);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
@@ -1057,22 +1138,22 @@ function getInstructionInputTypeFragment(scope) {
 }
 function getAccountsFragment(scope) {
   const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !nodes.isNode(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !(0, import_nodes12.isNode)(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const docblock = account.docs.length > 0 ? jsDocblock(account.docs) : "";
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
     return getAccountTypeFragment2(resolvedAccount).mapRender(
-      (r) => `${docblock}${nodes.camelCase(account.name)}${optionalSign}: ${r};`
+      (r) => `${docblock}${(0, import_nodes12.camelCase)(account.name)}${optionalSign}: ${r};`
     );
   });
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
 function getAccountTypeFragment2(account) {
-  const typeParam = `TAccount${nodes.pascalCase(account.name)}`;
+  const typeParam = `TAccount${(0, import_nodes12.pascalCase)(account.name)}`;
   if (account.isPda && account.isSigner === false) {
     return fragment(`ProgramDerivedAddress<${typeParam}>`).addImports("solanaAddresses", [
       "type ProgramDerivedAddress"
@@ -1091,7 +1172,7 @@ function getAccountTypeFragment2(account) {
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
@@ -1109,7 +1190,7 @@ function getDataArgumentsFragments(scope) {
 }
 function getExtraArgumentsFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
@@ -1120,18 +1201,18 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => nodes.isNode(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => (0, import_nodes12.isNode)(input, "instructionArgumentNode") && input.name === arg.name
   );
   if (arg.defaultValue && arg.defaultValueStrategy === "omitted") return null;
   const renamedName = renamedArgs.get(arg.name) ?? arg.name;
   const optionalSign = arg.defaultValue || resolvedArg?.defaultValue ? "?" : "";
-  return argsType.mapRender((r) => `${nodes.camelCase(renamedName)}${optionalSign}: ${r}["${nodes.camelCase(arg.name)}"];`);
+  return argsType.mapRender((r) => `${(0, import_nodes12.camelCase)(renamedName)}${optionalSign}: ${r}["${(0, import_nodes12.camelCase)(arg.name)}"];`);
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if (nodes.isNode(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if ((0, import_nodes12.isNode)(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
-    const allArguments = nodes.getAllInstructionArguments(instructionNode);
+    const allArguments = (0, import_nodes12.getAllInstructionArguments)(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
     if (argumentExists) return [];
     const isSigner = remainingAccountsNode.isSigner ?? false;
@@ -1143,12 +1224,16 @@ function getRemainingAccountsFragment(instructionNode) {
         return mergeFragments([signerFragment, addressFragment], (r) => r.join(" | "));
       }
       return isSigner ? signerFragment : addressFragment;
-    })().mapRender((r) => `${nodes.camelCase(name)}${optionalSign}: Array<${r}>;`);
+    })().mapRender((r) => `${(0, import_nodes12.camelCase)(name)}${optionalSign}: Array<${r}>;`);
   });
   return mergeFragments(fragments, (r) => r.join("\n"));
 }
+
+// src/fragments/instructionRemainingAccounts.ts
+var import_nodes13 = require("@codama/nodes");
+var import_visitors_core15 = require("@codama/visitors-core");
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = visitorsCore.getLastNodeFromPath(scope.instructionPath);
+  const { remainingAccounts } = (0, import_visitors_core15.getLastNodeFromPath)(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
   if (fragments.length === 0) return fragment("");
   return mergeFragments(
@@ -1159,10 +1244,10 @@ const remainingAccounts: IAccountMeta[] = ${r.length === 1 ? r[0] : `[...${r.joi
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if (nodes.isNode(remainingAccounts.value, "argumentValueNode")) {
+    if ((0, import_nodes13.isNode)(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if (nodes.isNode(remainingAccounts.value, "resolverValueNode")) {
+    if ((0, import_nodes13.isNode)(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1171,9 +1256,9 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const instructionNode = visitorsCore.getLastNodeFromPath(scope.instructionPath);
-  nodes.assertIsNode(remainingAccounts.value, "argumentValueNode");
-  const argumentName = nodes.camelCase(remainingAccounts.value.name);
+  const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(scope.instructionPath);
+  (0, import_nodes13.assertIsNode)(remainingAccounts.value, "argumentValueNode");
+  const argumentName = (0, import_nodes13.camelCase)(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1181,7 +1266,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const signerRole = isWritable ? "AccountRole.WRITABLE_SIGNER" : "AccountRole.READONLY_SIGNER";
   const role = isSigner === true ? signerRole : nonSignerRole;
   const argumentArray = isOptional ? `(args.${argumentName} ?? [])` : `args.${argumentName}`;
-  const allArguments = nodes.getAllInstructionArguments(instructionNode);
+  const allArguments = (0, import_nodes13.getAllInstructionArguments)(instructionNode);
   const argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
     return fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`).addImports(
@@ -1202,7 +1287,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   ).addImports("solanaInstructions", ["AccountRole"]);
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
-  nodes.assertIsNode(remainingAccounts.value, "resolverValueNode");
+  (0, import_nodes13.assertIsNode)(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1222,8 +1307,8 @@ function getInstructionFunctionFragment(scope) {
     nameApi,
     customInstructionData
   } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
-  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(instructionPath);
+  const programNode = (0, import_visitors_core16.findProgramNodeFromPath)(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
     return fragment("");
   }
@@ -1231,7 +1316,7 @@ function getInstructionFunctionFragment(scope) {
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted" && instructionNode.accounts.some((account) => account.isOptional);
   const instructionDependencies = getInstructionDependencies(instructionNode, asyncResolvers, useAsync);
-  const argDependencies = instructionDependencies.filter(nodes.isNodeFilter("argumentValueNode")).map((node) => node.name);
+  const argDependencies = instructionDependencies.filter((0, import_nodes14.isNodeFilter)("argumentValueNode")).map((node) => node.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
   const argIsNotOmitted = (arg) => !(arg.defaultValue && arg.defaultValueStrategy === "omitted");
   const argIsDependent = (arg) => argDependencies.includes(arg.name);
@@ -1244,7 +1329,7 @@ function getInstructionFunctionFragment(scope) {
   const hasExtraArgs = (instructionNode.extraArguments ?? []).filter(
     (field) => argIsNotOmitted(field) && (argIsDependent(field) || argHasDefaultValue(field))
   ).length > 0;
-  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => nodes.isNode(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => (0, import_nodes14.isNode)(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
@@ -1320,18 +1405,18 @@ function getInstructionFunctionFragment(scope) {
   return functionFragment;
 }
 function getTypeParams(instructionNode, programAddressConstant) {
-  const typeParams = instructionNode.accounts.map((account) => `TAccount${nodes.pascalCase(account.name)} extends string`);
+  const typeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes14.pascalCase)(account.name)} extends string`);
   typeParams.push(`TProgramAddress extends Address = typeof ${programAddressConstant}`);
   return fragment(typeParams.filter((x) => !!x).join(", ")).mapRender((r) => `<${r}>`).addImports("generatedPrograms", [programAddressConstant]);
 }
 function getInstructionType(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = `TAccount${nodes.pascalCase(account.name)}`;
-    const camelName = nodes.camelCase(account.name);
+    const typeParam = `TAccount${(0, import_nodes14.pascalCase)(account.name)}`;
+    const camelName = (0, import_nodes14.camelCase)(account.name);
     if (account.isSigner === "either") {
       const signerRole = account.isWritable ? "WritableSignerAccount" : "ReadonlySignerAccount";
       return fragment(
@@ -1347,16 +1432,19 @@ function getInstructionType(scope) {
 }
 function getInputTypeCall(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core16.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(", ");
+  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes14.pascalCase)(account.name)}`).join(", ");
   return fragment(`${inputTypeName}<${accountTypeParams}>`);
 }
+
+// src/fragments/instructionParseFunction.ts
+var import_visitors_core17 = require("@codama/visitors-core");
 function getInstructionParseFunctionFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
-  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core17.getLastNodeFromPath)(instructionPath);
+  const programNode = (0, import_visitors_core17.findProgramNodeFromPath)(instructionPath);
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasOptionalAccounts = instructionNode.accounts.some((account) => account.isOptional);
@@ -1384,20 +1472,25 @@ function getInstructionParseFunctionFragment(scope) {
     programAddressConstant
   }).mergeImportsWith(dataTypeFragment).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaInstructions", ["type IInstruction"]).addImports("solanaInstructions", hasAccounts ? ["type IInstructionWithAccounts", "type IAccountMeta"] : []).addImports("solanaInstructions", hasData ? ["type IInstructionWithData"] : []);
 }
+
+// src/fragments/instructionType.ts
+var import_nodes15 = require("@codama/nodes");
+var import_visitors_core18 = require("@codama/visitors-core");
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
-  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
+  const instructionNode = (0, import_visitors_core18.getLastNodeFromPath)(instructionPath);
+  const programNode = (0, import_visitors_core18.findProgramNodeFromPath)(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  const dataType = customData ? nodes.pascalCase(customData.importAs) : nodes.pascalCase(instructionDataName);
+  const dataType = customData ? (0, import_nodes15.pascalCase)(customData.importAs) : (0, import_nodes15.pascalCase)(instructionDataName);
   const accountTypeParamsFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
+        allowAccountMeta: true,
         instructionAccountPath: [...instructionPath, account]
       })
     ),
@@ -1407,7 +1500,7 @@ function getInstructionTypeFragment(scope) {
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountMetaFragment(account).mapRender((r) => {
-        const typeParam = `TAccount${nodes.pascalCase(account.name)}`;
+        const typeParam = `TAccount${(0, import_nodes15.pascalCase)(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
         const type = `${typeParam} extends string ? ${r} : ${typeParam}`;
         if (!isLegacyOptional) return type;
@@ -1433,28 +1526,32 @@ function getInstructionTypeFragment(scope) {
   ]);
   return fragment2;
 }
+
+// src/fragments/pdaFunction.ts
+var import_nodes16 = require("@codama/nodes");
+var import_visitors_core19 = require("@codama/visitors-core");
 function getPdaFunctionFragment(scope) {
   const { pdaPath, typeManifestVisitor, nameApi } = scope;
-  const pdaNode = visitorsCore.getLastNodeFromPath(pdaPath);
-  const programNode = visitorsCore.findProgramNodeFromPath(pdaPath);
+  const pdaNode = (0, import_visitors_core19.getLastNodeFromPath)(pdaPath);
+  const programNode = (0, import_visitors_core19.findProgramNodeFromPath)(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
-    if (nodes.isNode(seed, "variablePdaSeedNode")) {
-      const seedManifest2 = visitorsCore.visit(seed.type, typeManifestVisitor);
+    if ((0, import_nodes16.isNode)(seed, "variablePdaSeedNode")) {
+      const seedManifest2 = (0, import_visitors_core19.visit)(seed.type, typeManifestVisitor);
       imports.mergeWith(seedManifest2.looseType, seedManifest2.encoder);
       return { ...seed, typeManifest: seedManifest2 };
     }
-    if (nodes.isNode(seed.value, "programIdValueNode")) {
+    if ((0, import_nodes16.isNode)(seed.value, "programIdValueNode")) {
       imports.add("solanaAddresses", "getAddressEncoder");
       return seed;
     }
-    const seedManifest = visitorsCore.visit(seed.type, typeManifestVisitor);
+    const seedManifest = (0, import_visitors_core19.visit)(seed.type, typeManifestVisitor);
     imports.mergeWith(seedManifest.encoder);
-    const valueManifest = visitorsCore.visit(seed.value, typeManifestVisitor).value;
+    const valueManifest = (0, import_visitors_core19.visit)(seed.value, typeManifestVisitor).value;
     imports.mergeWith(valueManifest.imports);
     return { ...seed, typeManifest: seedManifest, valueManifest };
   });
-  const hasVariableSeeds = pdaNode.seeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = pdaNode.seeds.filter((0, import_nodes16.isNodeFilter)("variablePdaSeedNode")).length > 0;
   return fragmentFromTemplate("pdaFunction.njk", {
     findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
     hasVariableSeeds,
@@ -1472,6 +1569,9 @@ function getProgramFragment(scope) {
     programAddressConstant: nameApi.programAddressConstant(programNode.name)
   }).addImports("solanaAddresses", ["type Address"]);
 }
+
+// src/fragments/programAccounts.ts
+var import_nodes17 = require("@codama/nodes");
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return fragment("");
   return mergeFragments(
@@ -1505,7 +1605,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: account.discriminators ?? [],
         ifTrue: `return ${programAccountsEnum}.${variant};`,
-        struct: nodes.resolveNestedTypeNode(account.data)
+        struct: (0, import_nodes17.resolveNestedTypeNode)(account.data)
       });
     }),
     (r) => r.join("\n")
@@ -1533,9 +1633,12 @@ function getProgramErrorsFragment(scope) {
     programIsErrorFunction: nameApi.programIsErrorFunction(programNode.name)
   }).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaPrograms", ["isProgramError"]).addImports("solanaErrors", ["type SolanaError", "type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM"]).addImports("solanaAddresses", ["type Address"]);
 }
+
+// src/fragments/programInstructions.ts
+var import_nodes18 = require("@codama/nodes");
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return fragment("");
-  const allInstructions = nodes.getAllInstructionsWithSubs(scope.programNode, {
+  const allInstructions = (0, import_nodes18.getAllInstructionsWithSubs)(scope.programNode, {
     leavesOnly: !scope.renderParentInstructions,
     subInstructionsFirst: true
   });
@@ -1577,7 +1680,7 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: nodes.structTypeNodeFromInstructionArgumentNodes(instruction.arguments)
+        struct: (0, import_nodes18.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
       });
     }),
     (r) => r.join("\n")
@@ -1610,9 +1713,12 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
     (r) => r.join("\n")
   );
 }
+
+// src/fragments/typeDiscriminatedUnionHelpers.ts
+var import_nodes19 = require("@codama/nodes");
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = nodes.isNode(typeNode, "enumTypeNode") && nodes.isDataEnum(typeNode);
+  const isDiscriminatedUnion = (0, import_nodes19.isNode)(typeNode, "enumTypeNode") && (0, import_nodes19.isDataEnum)(typeNode);
   if (!isDiscriminatedUnion) {
     return fragment("");
   }
@@ -1653,12 +1759,23 @@ function mergeManifests(manifests, options = {}) {
     value: merge((m) => m.value, mergeValues)
   };
 }
+
+// src/getRenderMapVisitor.ts
+var import_node_path3 = require("path");
+var import_errors2 = require("@codama/errors");
+var import_nodes22 = require("@codama/nodes");
+var import_renderers_core = require("@codama/renderers-core");
+var import_visitors_core21 = require("@codama/visitors-core");
+
+// src/getTypeManifestVisitor.ts
+var import_nodes20 = require("@codama/nodes");
+var import_visitors_core20 = require("@codama/visitors-core");
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
-  const stack = input.stack ?? new visitorsCore.NodeStack();
+  const stack = input.stack ?? new import_visitors_core20.NodeStack();
   let parentName = null;
-  return visitorsCore.pipe(
-    visitorsCore.staticVisitor(
+  return (0, import_visitors_core20.pipe)(
+    (0, import_visitors_core20.staticVisitor)(
       () => ({
         decoder: fragment(""),
         encoder: fragment(""),
@@ -1669,8 +1786,8 @@ function getTypeManifestVisitor(input) {
       }),
       {
         keys: [
-          ...nodes.REGISTERED_TYPE_NODE_KINDS,
-          ...nodes.REGISTERED_VALUE_NODE_KINDS,
+          ...import_nodes20.REGISTERED_TYPE_NODE_KINDS,
+          ...import_nodes20.REGISTERED_VALUE_NODE_KINDS,
           "definedTypeLinkNode",
           "definedTypeNode",
           "accountNode",
@@ -1678,22 +1795,22 @@ function getTypeManifestVisitor(input) {
         ]
       }
     ),
-    (visitor) => visitorsCore.extendVisitor(visitor, {
+    (visitor) => (0, import_visitors_core20.extendVisitor)(visitor, {
       visitAccount(account, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(account.name),
           strict: nameApi.dataType(account.name)
         };
         const link = customAccountData.get(account.name)?.linkNode;
-        const manifest = link ? visitorsCore.visit(link, self) : visitorsCore.visit(account.data, self);
+        const manifest = link ? (0, import_visitors_core20.visit)(link, self) : (0, import_visitors_core20.visit)(account.data, self);
         parentName = null;
         return manifest;
       },
       visitAmountType(amountType, { self }) {
-        return visitorsCore.visit(amountType.number, self);
+        return (0, import_visitors_core20.visit)(amountType.number, self);
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = visitorsCore.visit(arrayType.item, self);
+        const childManifest = (0, import_visitors_core20.visit)(arrayType.item, self);
         childManifest.looseType.mapRender((r) => `Array<${r}>`);
         childManifest.strictType.mapRender((r) => `Array<${r}>`);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
@@ -1705,7 +1822,7 @@ function getTypeManifestVisitor(input) {
       },
       visitArrayValue(node, { self }) {
         return mergeManifests(
-          node.items.map((v) => visitorsCore.visit(v, self)),
+          node.items.map((v) => (0, import_visitors_core20.visit)(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
@@ -1714,9 +1831,9 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap().add("solanaCodecsDataStructures", "getBooleanDecoder");
         let sizeEncoder = "";
         let sizeDecoder = "";
-        const resolvedSize = nodes.resolveNestedTypeNode(booleanType.size);
+        const resolvedSize = (0, import_nodes20.resolveNestedTypeNode)(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
-          const size = visitorsCore.visit(booleanType.size, self);
+          const size = (0, import_visitors_core20.visit)(booleanType.size, self);
           encoderImports.mergeWith(size.encoder);
           decoderImports.mergeWith(size.decoder);
           sizeEncoder = `{ size: ${size.encoder.render} }`;
@@ -1765,26 +1882,26 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitConstantValue(node, { self }) {
-        if (nodes.isNode(node.type, "bytesTypeNode") && nodes.isNode(node.value, "bytesValueNode")) {
-          return visitorsCore.visit(node.value, self);
+        if ((0, import_nodes20.isNode)(node.type, "bytesTypeNode") && (0, import_nodes20.isNode)(node.value, "bytesValueNode")) {
+          return (0, import_visitors_core20.visit)(node.value, self);
         }
         return {
           ...typeManifest(),
           value: mergeFragments(
-            [visitorsCore.visit(node.type, self).encoder, visitorsCore.visit(node.value, self).value],
+            [(0, import_visitors_core20.visit)(node.type, self).encoder, (0, import_visitors_core20.visit)(node.value, self).value],
             ([encoderFunction, value]) => `${encoderFunction}.encode(${value})`
           )
         };
       },
       visitDateTimeType(dateTimeType, { self }) {
-        return visitorsCore.visit(dateTimeType.number, self);
+        return (0, import_visitors_core20.visit)(dateTimeType.number, self);
       },
       visitDefinedType(definedType, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(definedType.name),
           strict: nameApi.dataType(definedType.name)
         };
-        const manifest = visitorsCore.visit(definedType.type, self);
+        const manifest = (0, import_visitors_core20.visit)(definedType.type, self);
         parentName = null;
         return manifest;
       },
@@ -1804,7 +1921,7 @@ function getTypeManifestVisitor(input) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator(nodes.camelCase(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes20.camelCase)(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return {
@@ -1825,12 +1942,12 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          nodes.camelCase(currentParentName?.strict ?? "")
+          (0, import_nodes20.camelCase)(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         parentName = null;
-        const structManifest = visitorsCore.visit(enumStructVariantType.struct, self);
+        const structManifest = (0, import_visitors_core20.visit)(enumStructVariantType.struct, self);
         parentName = currentParentName;
         structManifest.strictType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
         structManifest.looseType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
@@ -1841,18 +1958,18 @@ function getTypeManifestVisitor(input) {
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          nodes.camelCase(currentParentName?.strict ?? "")
+          (0, import_nodes20.camelCase)(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
-        const struct = nodes.structTypeNode([
-          nodes.structFieldTypeNode({
+        const struct = (0, import_nodes20.structTypeNode)([
+          (0, import_nodes20.structFieldTypeNode)({
             name: "fields",
             type: enumTupleVariantType.tuple
           })
         ]);
         parentName = null;
-        const structManifest = visitorsCore.visit(struct, self);
+        const structManifest = (0, import_visitors_core20.visit)(struct, self);
         parentName = currentParentName;
         structManifest.strictType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
         structManifest.looseType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
@@ -1866,24 +1983,24 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap();
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = nodes.resolveNestedTypeNode(enumType.size);
+        const enumSize = (0, import_nodes20.resolveNestedTypeNode)(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
-          const sizeManifest = visitorsCore.visit(enumType.size, self);
+          const sizeManifest = (0, import_visitors_core20.visit)(enumType.size, self);
           encoderImports.mergeWith(sizeManifest.encoder);
           decoderImports.mergeWith(sizeManifest.decoder);
           encoderOptions.push(`size: ${sizeManifest.encoder.render}`);
           decoderOptions.push(`size: ${sizeManifest.decoder.render}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          nodes.camelCase(currentParentName?.strict ?? "")
+          (0, import_nodes20.camelCase)(currentParentName?.strict ?? "")
         );
-        if (!nodes.isScalarEnum(enumType) && discriminator !== "__kind") {
+        if (!(0, import_nodes20.isScalarEnum)(enumType) && discriminator !== "__kind") {
           encoderOptions.push(`discriminator: '${discriminator}'`);
           decoderOptions.push(`discriminator: '${discriminator}'`);
         }
         const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
         const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
-        if (nodes.isScalarEnum(enumType)) {
+        if ((0, import_nodes20.isScalarEnum)(enumType)) {
           if (currentParentName === null) {
             throw new Error(
               "Scalar enums cannot be inlined and must be introduced via a defined type. Ensure you are not inlining a defined type that is a scalar enum through a visitor."
@@ -1906,7 +2023,7 @@ function getTypeManifestVisitor(input) {
           };
         }
         const mergedManifest = mergeManifests(
-          enumType.variants.map((variant) => visitorsCore.visit(variant, self)),
+          enumType.variants.map((variant) => (0, import_visitors_core20.visit)(variant, self)),
           {
             mergeCodecs: (renders) => renders.join(", "),
             mergeTypes: (renders) => renders.join(" | ")
@@ -1922,7 +2039,7 @@ function getTypeManifestVisitor(input) {
         const enumFunction = nameApi.discriminatedUnionFunction(node.enum.name);
         const importFrom = getImportFrom(node.enum);
         const enumNode = linkables.get([...stack.getPath(), node.enum])?.type;
-        const isScalar = enumNode && nodes.isNode(enumNode, "enumTypeNode") ? nodes.isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && (0, import_nodes20.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes20.isScalarEnum)(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
           manifest.value.setRender(`${enumName}.${variantName2}`).addImports(importFrom, enumName);
@@ -1933,18 +2050,18 @@ function getTypeManifestVisitor(input) {
           manifest.value.setRender(`${enumFunction}('${variantName}')`).addImports(importFrom, enumFunction);
           return manifest;
         }
-        manifest.value = visitorsCore.visit(node.value, self).value.mapRender((r) => `${enumFunction}('${variantName}', ${r})`).addImports(importFrom, enumFunction);
+        manifest.value = (0, import_visitors_core20.visit)(node.value, self).value.mapRender((r) => `${enumFunction}('${variantName}', ${r})`).addImports(importFrom, enumFunction);
         return manifest;
       },
       visitFixedSizeType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
         manifest.encoder.mapRender((r) => `fixEncoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixEncoderSize");
         manifest.decoder.mapRender((r) => `fixDecoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixDecoderSize");
         return manifest;
       },
       visitHiddenPrefixType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
-        const prefixes = node.prefix.map((c) => visitorsCore.visit(c, self).value);
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
+        const prefixes = node.prefix.map((c) => (0, import_visitors_core20.visit)(c, self).value);
         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");
@@ -1952,8 +2069,8 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitHiddenSuffixType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
-        const suffixes = node.suffix.map((c) => visitorsCore.visit(c, self).value);
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
+        const suffixes = node.suffix.map((c) => (0, import_visitors_core20.visit)(c, self).value);
         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");
@@ -1967,19 +2084,19 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = nodes.structTypeNodeFromInstructionArgumentNodes(instruction.arguments);
-        const manifest = link ? visitorsCore.visit(link, self) : visitorsCore.visit(struct, self);
+        const struct = (0, import_nodes20.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
+        const manifest = link ? (0, import_visitors_core20.visit)(link, self) : (0, import_visitors_core20.visit)(struct, self);
         parentName = null;
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeManifests([visitorsCore.visit(node.key, self), visitorsCore.visit(node.value, self)], {
+        return mergeManifests([(0, import_visitors_core20.visit)(node.key, self), (0, import_visitors_core20.visit)(node.value, self)], {
           mergeValues: (renders) => `[${renders.join(", ")}]`
         });
       },
       visitMapType(mapType, { self }) {
-        const key = visitorsCore.visit(mapType.key, self);
-        const value = visitorsCore.visit(mapType.value, self);
+        const key = (0, import_visitors_core20.visit)(mapType.key, self);
+        const value = (0, import_visitors_core20.visit)(mapType.value, self);
         const mergedManifest = mergeManifests([key, value], {
           mergeCodecs: ([k, v]) => `${k}, ${v}`,
           mergeTypes: ([k, v]) => `Map<${k}, ${v}>`
@@ -1992,7 +2109,7 @@ function getTypeManifestVisitor(input) {
         return mergedManifest;
       },
       visitMapValue(node, { self }) {
-        const entryFragments = node.entries.map((entry) => visitorsCore.visit(entry, self));
+        const entryFragments = node.entries.map((entry) => (0, import_visitors_core20.visit)(entry, self));
         return mergeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
@@ -2029,14 +2146,14 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visitorsCore.visit(optionType.item, self);
+        const childManifest = (0, import_visitors_core20.visit)(optionType.item, self);
         childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = nodes.resolveNestedTypeNode(optionType.prefix);
+        const optionPrefix = (0, import_nodes20.resolveNestedTypeNode)(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = visitorsCore.visit(optionType.prefix, self);
+          const prefixManifest = (0, import_visitors_core20.visit)(optionType.prefix, self);
           childManifest.encoder.mergeImportsWith(prefixManifest.encoder);
           childManifest.decoder.mergeImportsWith(prefixManifest.decoder);
           encoderOptions.push(`prefix: ${prefixManifest.encoder.render}`);
@@ -2053,7 +2170,7 @@ function getTypeManifestVisitor(input) {
         return childManifest;
       },
       visitPostOffsetType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
         if (node.strategy === "padded") {
           manifest.encoder.mapRender((r) => `padRightEncoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padRightEncoder");
           manifest.decoder.mapRender((r) => `padRightDecoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padRightDecoder");
@@ -2075,7 +2192,7 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitPreOffsetType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
         if (node.strategy === "padded") {
           manifest.encoder.mapRender((r) => `padLeftEncoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padLeftEncoder");
           manifest.decoder.mapRender((r) => `padLeftDecoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padLeftDecoder");
@@ -2111,7 +2228,7 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = visitorsCore.visit(node.item, self);
+        const childManifest = (0, import_visitors_core20.visit)(node.item, self);
         childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = ["prefix: null"];
@@ -2123,14 +2240,14 @@ function getTypeManifestVisitor(input) {
         return childManifest;
       },
       visitSentinelType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
-        const sentinel = visitorsCore.visit(node.sentinel, self).value;
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
+        const sentinel = (0, import_visitors_core20.visit)(node.sentinel, self).value;
         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 }) {
-        const childManifest = visitorsCore.visit(setType.item, self);
+        const childManifest = (0, import_visitors_core20.visit)(setType.item, self);
         childManifest.strictType.mapRender((r) => `Set<${r}>`);
         childManifest.looseType.mapRender((r) => `Set<${r}>`);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
@@ -2142,19 +2259,19 @@ function getTypeManifestVisitor(input) {
       },
       visitSetValue(node, { self }) {
         return mergeManifests(
-          node.items.map((v) => visitorsCore.visit(v, self)),
+          node.items.map((v) => (0, import_visitors_core20.visit)(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
       },
       visitSizePrefixType(node, { self }) {
-        const manifest = visitorsCore.visit(node.type, self);
-        const prefix = visitorsCore.visit(node.prefix, self);
+        const manifest = (0, import_visitors_core20.visit)(node.type, self);
+        const prefix = (0, import_visitors_core20.visit)(node.prefix, self);
         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 }) {
-        const numberManifest = visitorsCore.visit(number, self);
+        const numberManifest = (0, import_visitors_core20.visit)(number, self);
         const lamportsType = "Lamports";
         const lamportsImport = new ImportMap().add("solanaRpcTypes", "type Lamports");
         return {
@@ -2167,7 +2284,7 @@ function getTypeManifestVisitor(input) {
       },
       visitSomeValue(node, { self }) {
         const manifest = typeManifest();
-        manifest.value = visitorsCore.visit(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
+        manifest.value = (0, import_visitors_core20.visit)(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
         return manifest;
       },
       visitStringType(stringType) {
@@ -2200,8 +2317,8 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = nodes.camelCase(structFieldType.name);
-        const childManifest = visitorsCore.visit(structFieldType.type, self);
+        const name = (0, import_nodes20.camelCase)(structFieldType.name);
+        const childManifest = (0, import_visitors_core20.visit)(structFieldType.type, self);
         const docblock = structFieldType.docs.length > 0 ? `
 ${jsDocblock(structFieldType.docs)}` : "";
         const originalLooseType = childManifest.looseType.render;
@@ -2221,13 +2338,13 @@ ${jsDocblock(structFieldType.docs)}` : "";
       },
       visitStructFieldValue(node, { self }) {
         const manifest = typeManifest();
-        manifest.value = visitorsCore.visit(node.value, self).value.mapRender((r) => `${node.name}: ${r}`);
+        manifest.value = (0, import_visitors_core20.visit)(node.value, self).value.mapRender((r) => `${node.name}: ${r}`);
         return manifest;
       },
       visitStructType(structType, { self }) {
         const optionalFields = structType.fields.filter((f) => !!f.defaultValue);
         const mergedManifest = mergeManifests(
-          structType.fields.map((field) => visitorsCore.visit(field, self)),
+          structType.fields.map((field) => (0, import_visitors_core20.visit)(field, self)),
           {
             mergeCodecs: (renders) => `([${renders.join(", ")}])`,
             mergeTypes: (renders) => `{ ${renders.join("")} }`
@@ -2239,19 +2356,19 @@ ${jsDocblock(structFieldType.docs)}` : "";
           return mergedManifest;
         }
         const parentPath = stack.getPath();
-        const instructionNode = visitorsCore.findLastNodeFromPath(parentPath, "instructionNode");
-        const accountNode = visitorsCore.findLastNodeFromPath(parentPath, "accountNode");
+        const instructionNode = (0, import_visitors_core20.findLastNodeFromPath)(parentPath, "instructionNode");
+        const accountNode = (0, import_visitors_core20.findLastNodeFromPath)(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
-        const fieldDiscriminators = discriminators.filter(nodes.isNodeFilter("fieldDiscriminatorNode"));
+        const fieldDiscriminators = discriminators.filter((0, import_nodes20.isNodeFilter)("fieldDiscriminatorNode"));
         const defaultValues = optionalFields.map((f) => {
-          const key = nodes.camelCase(f.name);
+          const key = (0, import_nodes20.camelCase)(f.name);
           if (fieldDiscriminators.some((d) => d.name === f.name)) {
-            const constantName = nameApi.constant(nodes.camelCase(`${discriminatorPrefix}_${f.name}`));
+            const constantName = nameApi.constant((0, import_nodes20.camelCase)(`${discriminatorPrefix}_${f.name}`));
             return f.defaultValueStrategy === "omitted" ? `${key}: ${constantName}` : `${key}: value.${key} ?? ${constantName}`;
           }
           const defaultValue = f.defaultValue;
-          const { render: renderedValue, imports } = visitorsCore.visit(defaultValue, self).value;
+          const { render: renderedValue, imports } = (0, import_visitors_core20.visit)(defaultValue, self).value;
           mergedManifest.encoder.mergeImportsWith(imports);
           return f.defaultValueStrategy === "omitted" ? `${key}: ${renderedValue}` : `${key}: value.${key} ?? ${renderedValue}`;
         }).join(", ");
@@ -2260,12 +2377,12 @@ ${jsDocblock(structFieldType.docs)}` : "";
       },
       visitStructValue(node, { self }) {
         return mergeManifests(
-          node.fields.map((field) => visitorsCore.visit(field, self)),
+          node.fields.map((field) => (0, import_visitors_core20.visit)(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visitorsCore.visit(item, self));
+        const items = tupleType.items.map((item) => (0, import_visitors_core20.visit)(item, self));
         const mergedManifest = mergeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
@@ -2276,18 +2393,18 @@ ${jsDocblock(structFieldType.docs)}` : "";
       },
       visitTupleValue(node, { self }) {
         return mergeManifests(
-          node.items.map((v) => visitorsCore.visit(v, self)),
+          node.items.map((v) => (0, import_visitors_core20.visit)(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = visitorsCore.visit(node.item, self);
+        const childManifest = (0, import_visitors_core20.visit)(node.item, self);
         childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
         if (node.zeroValue) {
-          const zeroValueManifest = visitorsCore.visit(node.zeroValue, self);
+          const zeroValueManifest = (0, import_visitors_core20.visit)(node.zeroValue, self);
           childManifest.encoder.mergeImportsWith(zeroValueManifest.value);
           childManifest.decoder.mergeImportsWith(zeroValueManifest.value);
           encoderOptions.push(`noneValue: ${zeroValueManifest.value.render}`);
@@ -2303,97 +2420,100 @@ ${jsDocblock(structFieldType.docs)}` : "";
         return childManifest;
       }
     }),
-    (visitor) => visitorsCore.recordNodeStackVisitor(visitor, stack)
+    (visitor) => (0, import_visitors_core20.recordNodeStackVisitor)(visitor, stack)
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if (nodes.isNode(count, "fixedCountNode")) {
+  if ((0, import_nodes20.isNode)(count, "fixedCountNode")) {
     return {
       decoder: fragment(`size: ${count.value}`),
       encoder: fragment(`size: ${count.value}`)
     };
   }
-  if (nodes.isNode(count, "remainderCountNode")) {
+  if ((0, import_nodes20.isNode)(count, "remainderCountNode")) {
     return {
       decoder: fragment(`size: 'remainder'`),
       encoder: fragment(`size: 'remainder'`)
     };
   }
-  const prefix = nodes.resolveNestedTypeNode(count.prefix);
+  const prefix = (0, import_nodes20.resolveNestedTypeNode)(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: fragment(""), encoder: fragment("") };
   }
-  const prefixManifest = visitorsCore.visit(count.prefix, visitor);
+  const prefixManifest = (0, import_visitors_core20.visit)(count.prefix, visitor);
   prefixManifest.encoder.mapRender((r) => `size: ${r}`);
   prefixManifest.decoder.mapRender((r) => `size: ${r}`);
   return prefixManifest;
 }
+
+// src/nameTransformers.ts
+var import_nodes21 = require("@codama/nodes");
 function getNameApi(transformers) {
   const helpers = {
-    camelCase: nodes.camelCase,
-    capitalize: nodes.capitalize,
-    kebabCase: nodes.kebabCase,
-    pascalCase: nodes.pascalCase,
-    snakeCase: nodes.snakeCase,
-    titleCase: nodes.titleCase
+    camelCase: import_nodes21.camelCase,
+    capitalize: import_nodes21.capitalize,
+    kebabCase: import_nodes21.kebabCase,
+    pascalCase: import_nodes21.pascalCase,
+    snakeCase: import_nodes21.snakeCase,
+    titleCase: import_nodes21.titleCase
   };
   return Object.fromEntries(
     Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
   );
 }
 var DEFAULT_NAME_TRANSFORMERS = {
-  accountDecodeFunction: (name) => `decode${nodes.pascalCase(name)}`,
-  accountFetchAllFunction: (name) => `fetchAll${nodes.pascalCase(name)}`,
-  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${nodes.pascalCase(name)}`,
-  accountFetchFromSeedsFunction: (name) => `fetch${nodes.pascalCase(name)}FromSeeds`,
-  accountFetchFunction: (name) => `fetch${nodes.pascalCase(name)}`,
-  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${nodes.pascalCase(name)}FromSeeds`,
-  accountFetchMaybeFunction: (name) => `fetchMaybe${nodes.pascalCase(name)}`,
-  accountGetSizeFunction: (name) => `get${nodes.pascalCase(name)}Size`,
-  codecFunction: (name) => `get${nodes.pascalCase(name)}Codec`,
-  constant: (name) => nodes.snakeCase(name).toUpperCase(),
-  constantFunction: (name) => `get${nodes.pascalCase(name)}Bytes`,
-  dataArgsType: (name) => `${nodes.pascalCase(name)}Args`,
-  dataType: (name) => `${nodes.pascalCase(name)}`,
-  decoderFunction: (name) => `get${nodes.pascalCase(name)}Decoder`,
+  accountDecodeFunction: (name) => `decode${(0, import_nodes21.pascalCase)(name)}`,
+  accountFetchAllFunction: (name) => `fetchAll${(0, import_nodes21.pascalCase)(name)}`,
+  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${(0, import_nodes21.pascalCase)(name)}`,
+  accountFetchFromSeedsFunction: (name) => `fetch${(0, import_nodes21.pascalCase)(name)}FromSeeds`,
+  accountFetchFunction: (name) => `fetch${(0, import_nodes21.pascalCase)(name)}`,
+  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${(0, import_nodes21.pascalCase)(name)}FromSeeds`,
+  accountFetchMaybeFunction: (name) => `fetchMaybe${(0, import_nodes21.pascalCase)(name)}`,
+  accountGetSizeFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Size`,
+  codecFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Codec`,
+  constant: (name) => (0, import_nodes21.snakeCase)(name).toUpperCase(),
+  constantFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Bytes`,
+  dataArgsType: (name) => `${(0, import_nodes21.pascalCase)(name)}Args`,
+  dataType: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
+  decoderFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Decoder`,
   discriminatedUnionDiscriminator: () => "__kind",
-  discriminatedUnionFunction: (name) => `${nodes.camelCase(name)}`,
-  discriminatedUnionVariant: (name) => `${nodes.pascalCase(name)}`,
-  encoderFunction: (name) => `get${nodes.pascalCase(name)}Encoder`,
-  enumVariant: (name) => `${nodes.pascalCase(name)}`,
-  instructionAsyncFunction: (name) => `get${nodes.pascalCase(name)}InstructionAsync`,
-  instructionAsyncInputType: (name) => `${nodes.pascalCase(name)}AsyncInput`,
-  instructionDataType: (name) => `${nodes.pascalCase(name)}InstructionData`,
-  instructionExtraType: (name) => `${nodes.pascalCase(name)}InstructionExtra`,
-  instructionParseFunction: (name) => `parse${nodes.pascalCase(name)}Instruction`,
-  instructionParsedType: (name) => `Parsed${nodes.pascalCase(name)}Instruction`,
-  instructionSyncFunction: (name) => `get${nodes.pascalCase(name)}Instruction`,
-  instructionSyncInputType: (name) => `${nodes.pascalCase(name)}Input`,
-  instructionType: (name) => `${nodes.pascalCase(name)}Instruction`,
-  isDiscriminatedUnionFunction: (name) => `is${nodes.pascalCase(name)}`,
-  pdaFindFunction: (name) => `find${nodes.pascalCase(name)}Pda`,
-  pdaSeedsType: (name) => `${nodes.pascalCase(name)}Seeds`,
-  programAccountsEnum: (name) => `${nodes.pascalCase(name)}Account`,
-  programAccountsEnumVariant: (name) => `${nodes.pascalCase(name)}`,
-  programAccountsIdentifierFunction: (name) => `identify${nodes.pascalCase(name)}Account`,
-  programAddressConstant: (name) => `${nodes.snakeCase(name).toUpperCase()}_PROGRAM_ADDRESS`,
-  programErrorConstant: (name) => nodes.snakeCase(name).toUpperCase(),
-  programErrorConstantPrefix: (name) => `${nodes.snakeCase(name).toUpperCase()}_ERROR__`,
-  programErrorMessagesMap: (name) => `${nodes.camelCase(name)}ErrorMessages`,
-  programErrorUnion: (name) => `${nodes.pascalCase(name)}Error`,
-  programGetErrorMessageFunction: (name) => `get${nodes.pascalCase(name)}ErrorMessage`,
-  programInstructionsEnum: (name) => `${nodes.pascalCase(name)}Instruction`,
-  programInstructionsEnumVariant: (name) => `${nodes.pascalCase(name)}`,
-  programInstructionsIdentifierFunction: (name) => `identify${nodes.pascalCase(name)}Instruction`,
-  programInstructionsParsedUnionType: (name) => `Parsed${nodes.pascalCase(name)}Instruction`,
-  programIsErrorFunction: (name) => `is${nodes.pascalCase(name)}Error`,
-  resolverFunction: (name) => `${nodes.camelCase(name)}`
+  discriminatedUnionFunction: (name) => `${(0, import_nodes21.camelCase)(name)}`,
+  discriminatedUnionVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
+  encoderFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Encoder`,
+  enumVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
+  instructionAsyncFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}InstructionAsync`,
+  instructionAsyncInputType: (name) => `${(0, import_nodes21.pascalCase)(name)}AsyncInput`,
+  instructionDataType: (name) => `${(0, import_nodes21.pascalCase)(name)}InstructionData`,
+  instructionExtraType: (name) => `${(0, import_nodes21.pascalCase)(name)}InstructionExtra`,
+  instructionParseFunction: (name) => `parse${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  instructionParsedType: (name) => `Parsed${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  instructionSyncFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  instructionSyncInputType: (name) => `${(0, import_nodes21.pascalCase)(name)}Input`,
+  instructionType: (name) => `${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  isDiscriminatedUnionFunction: (name) => `is${(0, import_nodes21.pascalCase)(name)}`,
+  pdaFindFunction: (name) => `find${(0, import_nodes21.pascalCase)(name)}Pda`,
+  pdaSeedsType: (name) => `${(0, import_nodes21.pascalCase)(name)}Seeds`,
+  programAccountsEnum: (name) => `${(0, import_nodes21.pascalCase)(name)}Account`,
+  programAccountsEnumVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
+  programAccountsIdentifierFunction: (name) => `identify${(0, import_nodes21.pascalCase)(name)}Account`,
+  programAddressConstant: (name) => `${(0, import_nodes21.snakeCase)(name).toUpperCase()}_PROGRAM_ADDRESS`,
+  programErrorConstant: (name) => (0, import_nodes21.snakeCase)(name).toUpperCase(),
+  programErrorConstantPrefix: (name) => `${(0, import_nodes21.snakeCase)(name).toUpperCase()}_ERROR__`,
+  programErrorMessagesMap: (name) => `${(0, import_nodes21.camelCase)(name)}ErrorMessages`,
+  programErrorUnion: (name) => `${(0, import_nodes21.pascalCase)(name)}Error`,
+  programGetErrorMessageFunction: (name) => `get${(0, import_nodes21.pascalCase)(name)}ErrorMessage`,
+  programInstructionsEnum: (name) => `${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  programInstructionsEnumVariant: (name) => `${(0, import_nodes21.pascalCase)(name)}`,
+  programInstructionsIdentifierFunction: (name) => `identify${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  programInstructionsParsedUnionType: (name) => `Parsed${(0, import_nodes21.pascalCase)(name)}Instruction`,
+  programIsErrorFunction: (name) => `is${(0, import_nodes21.pascalCase)(name)}Error`,
+  resolverFunction: (name) => `${(0, import_nodes21.camelCase)(name)}`
 };
 
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
-  const linkables = new visitorsCore.LinkableDictionary();
-  const stack = new visitorsCore.NodeStack();
+  const linkables = new import_visitors_core21.LinkableDictionary();
+  const stack = new import_visitors_core21.NodeStack();
   const nameTransformers = {
     ...DEFAULT_NAME_TRANSFORMERS,
     ...options.nameTransformers
@@ -2402,9 +2522,9 @@ function getRenderMapVisitor(options = {}) {
   const renderParentInstructions = options.renderParentInstructions ?? false;
   const dependencyMap = options.dependencyMap ?? {};
   const useGranularImports = options.useGranularImports ?? false;
-  const asyncResolvers = (options.asyncResolvers ?? []).map(nodes.camelCase);
-  const nonScalarEnums = (options.nonScalarEnums ?? []).map(nodes.camelCase);
-  const internalNodes = (options.internalNodes ?? []).map(nodes.camelCase);
+  const asyncResolvers = (options.asyncResolvers ?? []).map(import_nodes22.camelCase);
+  const nonScalarEnums = (options.nonScalarEnums ?? []).map(import_nodes22.camelCase);
+  const internalNodes = (options.internalNodes ?? []).map(import_nodes22.camelCase);
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const getImportFrom = getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData);
@@ -2417,7 +2537,7 @@ function getRenderMapVisitor(options = {}) {
     nonScalarEnums,
     stack
   });
-  const resolvedInstructionInputVisitor = visitorsCore.getResolvedInstructionInputsVisitor();
+  const resolvedInstructionInputVisitor = (0, import_visitors_core21.getResolvedInstructionInputsVisitor)();
   const globalScope = {
     asyncResolvers,
     customAccountData,
@@ -2430,24 +2550,24 @@ function getRenderMapVisitor(options = {}) {
     typeManifestVisitor
   };
   const render2 = (template, context, renderOptions) => {
-    return render(path.join("pages", template), context, renderOptions);
+    return render((0, import_node_path3.join)("pages", template), context, renderOptions);
   };
-  return visitorsCore.pipe(
-    visitorsCore.staticVisitor(() => new renderersCore.RenderMap(), {
+  return (0, import_visitors_core21.pipe)(
+    (0, import_visitors_core21.staticVisitor)(() => new import_renderers_core.RenderMap(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
-    (v) => visitorsCore.extendVisitor(v, {
+    (v) => (0, import_visitors_core21.extendVisitor)(v, {
       visitAccount(node) {
         const accountPath = stack.getPath("accountNode");
-        if (!visitorsCore.findProgramNodeFromPath(accountPath)) {
+        if (!(0, import_visitors_core21.findProgramNodeFromPath)(accountPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = {
           ...globalScope,
           accountPath,
-          typeManifest: visitorsCore.visit(node, typeManifestVisitor)
+          typeManifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor)
         };
-        const fields = nodes.resolveNestedTypeNode(node.data).fields;
+        const fields = (0, import_nodes22.resolveNestedTypeNode)(node.data).fields;
         const accountDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
           discriminatorNodes: node.discriminators ?? [],
@@ -2465,8 +2585,8 @@ function getRenderMapVisitor(options = {}) {
           accountSizeHelpersFragment,
           accountPdaHelpersFragment
         );
-        return new renderersCore.RenderMap().add(
-          `accounts/${nodes.camelCase(node.name)}.ts`,
+        return new import_renderers_core.RenderMap().add(
+          `accounts/${(0, import_nodes22.camelCase)(node.name)}.ts`,
           render2("accountsPage.njk", {
             accountDiscriminatorConstantsFragment,
             accountFetchHelpersFragment,
@@ -2483,7 +2603,7 @@ function getRenderMapVisitor(options = {}) {
           codecDocs: [],
           decoderDocs: [],
           encoderDocs: [],
-          manifest: visitorsCore.visit(node, typeManifestVisitor),
+          manifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor),
           name: node.name,
           typeDocs: node.docs,
           typeNode: node.type
@@ -2497,8 +2617,8 @@ function getRenderMapVisitor(options = {}) {
           nameApi.decoderFunction(node.name),
           nameApi.codecFunction(node.name)
         ]);
-        return new renderersCore.RenderMap().add(
-          `types/${nodes.camelCase(node.name)}.ts`,
+        return new import_renderers_core.RenderMap().add(
+          `types/${(0, import_nodes22.camelCase)(node.name)}.ts`,
           render2("definedTypesPage.njk", {
             imports: imports.toString({
               ...dependencyMap,
@@ -2511,23 +2631,23 @@ function getRenderMapVisitor(options = {}) {
       },
       visitInstruction(node) {
         const instructionPath = stack.getPath("instructionNode");
-        if (!visitorsCore.findProgramNodeFromPath(instructionPath)) {
+        if (!(0, import_visitors_core21.findProgramNodeFromPath)(instructionPath)) {
           throw new Error("Instruction must be visited inside a program.");
         }
         const instructionExtraName = nameApi.instructionExtraType(node.name);
         const scope = {
           ...globalScope,
-          dataArgsManifest: visitorsCore.visit(node, typeManifestVisitor),
-          extraArgsManifest: visitorsCore.visit(
-            nodes.definedTypeNode({
+          dataArgsManifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor),
+          extraArgsManifest: (0, import_visitors_core21.visit)(
+            (0, import_nodes22.definedTypeNode)({
               name: instructionExtraName,
-              type: nodes.structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? [])
+              type: (0, import_nodes22.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
             }),
             typeManifestVisitor
           ),
           instructionPath,
           renamedArgs: getRenamedArgsMap(node),
-          resolvedInputs: visitorsCore.visit(node, resolvedInstructionInputVisitor)
+          resolvedInputs: (0, import_visitors_core21.visit)(node, resolvedInstructionInputVisitor)
         };
         const instructionDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
@@ -2556,8 +2676,8 @@ function getRenderMapVisitor(options = {}) {
           instructionFunctionSyncFragment,
           instructionParseFunctionFragment
         );
-        return new renderersCore.RenderMap().add(
-          `instructions/${nodes.camelCase(node.name)}.ts`,
+        return new import_renderers_core.RenderMap().add(
+          `instructions/${(0, import_nodes22.camelCase)(node.name)}.ts`,
           render2("instructionsPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             instruction: node,
@@ -2573,14 +2693,14 @@ function getRenderMapVisitor(options = {}) {
       },
       visitPda(node) {
         const pdaPath = stack.getPath("pdaNode");
-        if (!visitorsCore.findProgramNodeFromPath(pdaPath)) {
+        if (!(0, import_visitors_core21.findProgramNodeFromPath)(pdaPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = { ...globalScope, pdaPath };
         const pdaFunctionFragment = getPdaFunctionFragment(scope);
         const imports = new ImportMap().mergeWith(pdaFunctionFragment);
-        return new renderersCore.RenderMap().add(
-          `pdas/${nodes.camelCase(node.name)}.ts`,
+        return new import_renderers_core.RenderMap().add(
+          `pdas/${(0, import_nodes22.camelCase)(node.name)}.ts`,
           render2("pdasPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             pdaFunctionFragment
@@ -2593,11 +2713,11 @@ function getRenderMapVisitor(options = {}) {
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
         ];
         const scope = { ...globalScope, programNode: node };
-        const renderMap = new renderersCore.RenderMap().mergeWith(...node.pdas.map((p) => visitorsCore.visit(p, self))).mergeWith(...node.accounts.map((a) => visitorsCore.visit(a, self))).mergeWith(...node.definedTypes.map((t) => visitorsCore.visit(t, self))).mergeWith(...customDataDefinedType.map((t) => visitorsCore.visit(t, self)));
+        const renderMap = new import_renderers_core.RenderMap().mergeWith(...node.pdas.map((p) => (0, import_visitors_core21.visit)(p, self))).mergeWith(...node.accounts.map((a) => (0, import_visitors_core21.visit)(a, self))).mergeWith(...node.definedTypes.map((t) => (0, import_visitors_core21.visit)(t, self))).mergeWith(...customDataDefinedType.map((t) => (0, import_visitors_core21.visit)(t, self)));
         if (node.errors.length > 0) {
           const programErrorsFragment = getProgramErrorsFragment(scope);
           renderMap.add(
-            `errors/${nodes.camelCase(node.name)}.ts`,
+            `errors/${(0, import_nodes22.camelCase)(node.name)}.ts`,
             render2("errorsPage.njk", {
               imports: new ImportMap().mergeWith(programErrorsFragment).toString(dependencyMap, useGranularImports),
               programErrorsFragment
@@ -2608,7 +2728,7 @@ function getRenderMapVisitor(options = {}) {
         const programAccountsFragment = getProgramAccountsFragment(scope);
         const programInstructionsFragment = getProgramInstructionsFragment(scope);
         renderMap.add(
-          `programs/${nodes.camelCase(node.name)}.ts`,
+          `programs/${(0, import_nodes22.camelCase)(node.name)}.ts`,
           render2("programsPage.njk", {
             imports: new ImportMap().mergeWith(programFragment, programAccountsFragment, programInstructionsFragment).toString(dependencyMap, useGranularImports),
             programAccountsFragment,
@@ -2617,22 +2737,22 @@ function getRenderMapVisitor(options = {}) {
           })
         );
         renderMap.mergeWith(
-          ...nodes.getAllInstructionsWithSubs(node, {
+          ...(0, import_nodes22.getAllInstructionsWithSubs)(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => visitorsCore.visit(ix, self))
+          }).map((ix) => (0, import_visitors_core21.visit)(ix, self))
         );
         return renderMap;
       },
       visitRoot(node, { self }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
-        const programsToExport = nodes.getAllPrograms(node).filter(isNotInternal);
+        const programsToExport = (0, import_nodes22.getAllPrograms)(node).filter(isNotInternal);
         const programsWithErrorsToExport = programsToExport.filter((p) => p.errors.length > 0);
-        const pdasToExport = nodes.getAllPdas(node);
-        const accountsToExport = nodes.getAllAccounts(node).filter(isNotInternal);
-        const instructionsToExport = nodes.getAllInstructionsWithSubs(node, {
+        const pdasToExport = (0, import_nodes22.getAllPdas)(node);
+        const accountsToExport = (0, import_nodes22.getAllAccounts)(node).filter(isNotInternal);
+        const instructionsToExport = (0, import_nodes22.getAllInstructionsWithSubs)(node, {
           leavesOnly: !renderParentInstructions
         }).filter(isNotInternal);
-        const definedTypesToExport = nodes.getAllDefinedTypes(node).filter(isNotInternal);
+        const definedTypesToExport = (0, import_nodes22.getAllDefinedTypes)(node).filter(isNotInternal);
         const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const ctx = {
           accountsToExport,
@@ -2644,7 +2764,7 @@ function getRenderMapVisitor(options = {}) {
           programsWithErrorsToExport,
           root: node
         };
-        const map = new renderersCore.RenderMap();
+        const map = new import_renderers_core.RenderMap();
         if (hasAnythingToExport) {
           map.add(
             "shared/index.ts",
@@ -2684,11 +2804,11 @@ function getRenderMapVisitor(options = {}) {
         if (definedTypesToExport.length > 0) {
           map.add("types/index.ts", render2("definedTypesIndex.njk", ctx));
         }
-        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...nodes.getAllPrograms(node).map((p) => visitorsCore.visit(p, self)));
+        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...(0, import_nodes22.getAllPrograms)(node).map((p) => (0, import_visitors_core21.visit)(p, self)));
       }
     }),
-    (v) => visitorsCore.recordNodeStackVisitor(v, stack),
-    (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)
+    (v) => (0, import_visitors_core21.recordNodeStackVisitor)(v, stack),
+    (v) => (0, import_visitors_core21.recordLinkablesOnFirstVisitVisitor)(v, linkables)
   );
 }
 function getRenamedArgsMap(instruction) {
@@ -2703,15 +2823,22 @@ function getRenamedArgsMap(instruction) {
   const allNames = [...instruction.accounts.map((account) => account.name), ...argNames];
   const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
   if (duplicates.length === 0) return /* @__PURE__ */ new Map();
-  errors.logWarn(
+  (0, import_errors2.logWarn)(
     `[JavaScript] Accounts and args of instruction [${instruction.name}] have the following conflicting attributes [${duplicates.join(", ")}]. Thus, the arguments have been renamed to avoid conflicts in the input type.`
   );
-  return new Map(duplicates.map((name) => [nodes.camelCase(name), nodes.camelCase(`${name}Arg`)]));
+  return new Map(duplicates.map((name) => [(0, import_nodes22.camelCase)(name), (0, import_nodes22.camelCase)(`${name}Arg`)]));
 }
+
+// src/renderVisitor.ts
+var import_renderers_core2 = require("@codama/renderers-core");
+var import_visitors_core22 = require("@codama/visitors-core");
+var estreePlugin = __toESM(require("prettier/plugins/estree"));
+var typeScriptPlugin = __toESM(require("prettier/plugins/typescript"));
+var import_standalone = require("prettier/standalone");
 var DEFAULT_PRETTIER_OPTIONS = {
   arrowParens: "always",
   parser: "typescript",
-  plugins: [estreePlugin__namespace, typeScriptPlugin__namespace],
+  plugins: [estreePlugin, typeScriptPlugin],
   printWidth: 80,
   semi: true,
   singleQuote: true,
@@ -2720,27 +2847,27 @@ var DEFAULT_PRETTIER_OPTIONS = {
   useTabs: false
 };
 function renderVisitor(path, options = {}) {
-  return visitorsCore.rootNodeVisitor(async (root) => {
+  return (0, import_visitors_core22.rootNodeVisitor)(async (root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
-      renderersCore.deleteDirectory(path);
+      (0, import_renderers_core2.deleteDirectory)(path);
     }
-    const renderMap = visitorsCore.visit(root, getRenderMapVisitor(options));
+    const renderMap = (0, import_visitors_core22.visit)(root, getRenderMapVisitor(options));
     if (options.formatCode ?? true) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      await renderMap.mapContentAsync((code) => standalone.format(code, prettierOptions));
+      await renderMap.mapContentAsync((code) => (0, import_standalone.format)(code, prettierOptions));
     }
     renderMap.write(path);
   });
 }
-
-exports.DEFAULT_NAME_TRANSFORMERS = DEFAULT_NAME_TRANSFORMERS;
-exports.ImportMap = ImportMap;
-exports.default = renderVisitor;
-exports.getNameApi = getNameApi;
-exports.getRenderMapVisitor = getRenderMapVisitor;
-exports.getTypeManifestVisitor = getTypeManifestVisitor;
-exports.mergeManifests = mergeManifests;
-exports.renderVisitor = renderVisitor;
-exports.typeManifest = typeManifest;
-//# sourceMappingURL=index.node.cjs.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_NAME_TRANSFORMERS,
+  ImportMap,
+  getNameApi,
+  getRenderMapVisitor,
+  getTypeManifestVisitor,
+  mergeManifests,
+  renderVisitor,
+  typeManifest
+});
 //# sourceMappingURL=index.node.cjs.map