@codama/renderers-js 1.5.1 → 1.5.3

package/dist/index.browser.cjs

@@ -1,51 +1,37 @@
-"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 });
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var nodes = require('@codama/nodes');
+var renderersCore = require('@codama/renderers-core');
+var visitorsCore = require('@codama/visitors-core');
+var codecsStrings = require('@solana/codecs-strings');
+var prettier = require('prettier');
+var estreePlugin = require('prettier/plugins/estree');
+var typeScriptPlugin = require('prettier/plugins/typescript');
+var errors = require('@codama/errors');
+var semver = require('semver');
+
+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]; }
+        });
+      }
+    });
   }
-  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);
+  n.default = e;
+  return Object.freeze(n);
+}
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DEFAULT_NAME_TRANSFORMERS: () => DEFAULT_NAME_TRANSFORMERS,
-  addToImportMap: () => addToImportMap,
-  createImportMap: () => createImportMap,
-  default: () => renderVisitor,
-  getNameApi: () => getNameApi,
-  getRenderMapVisitor: () => getRenderMapVisitor,
-  getTypeManifestVisitor: () => getTypeManifestVisitor,
-  importMapToString: () => importMapToString,
-  mergeImportMaps: () => mergeImportMaps,
-  mergeTypeManifests: () => mergeTypeManifests,
-  parseImportInput: () => parseImportInput,
-  removeFromImportMap: () => removeFromImportMap,
-  renderVisitor: () => renderVisitor,
-  typeManifest: () => typeManifest
-});
-module.exports = __toCommonJS(index_exports);
+var estreePlugin__namespace = /*#__PURE__*/_interopNamespace(estreePlugin);
+var typeScriptPlugin__namespace = /*#__PURE__*/_interopNamespace(typeScriptPlugin);
 
 // src/utils/importMap.ts
 var DEFAULT_EXTERNAL_MODULE_MAP = {
@@ -102,20 +88,20 @@ function parseImportInput(input) {
     usedIdentifier: alias ?? name
   });
 }
-function addToImportMap(importMap, module2, imports) {
+function addToImportMap(importMap, module, imports) {
   const parsedImports = imports.map(parseImportInput).map((i) => [i.usedIdentifier, i]);
-  return mergeImportMaps([importMap, /* @__PURE__ */ new Map([[module2, new Map(parsedImports)]])]);
+  return mergeImportMaps([importMap, /* @__PURE__ */ new Map([[module, new Map(parsedImports)]])]);
 }
-function removeFromImportMap(importMap, module2, usedIdentifiers) {
+function removeFromImportMap(importMap, module, usedIdentifiers) {
   const newMap = new Map(importMap);
-  const newModuleMap = new Map(newMap.get(module2));
+  const newModuleMap = new Map(newMap.get(module));
   usedIdentifiers.forEach((usedIdentifier) => {
     newModuleMap.delete(usedIdentifier);
   });
   if (newModuleMap.size === 0) {
-    newMap.delete(module2);
+    newMap.delete(module);
   } else {
-    newMap.set(module2, newModuleMap);
+    newMap.set(module, newModuleMap);
   }
   return Object.freeze(newMap);
 }
@@ -124,8 +110,8 @@ function mergeImportMaps(importMaps) {
   if (importMaps.length === 1) return importMaps[0];
   const mergedMap = new Map(importMaps[0]);
   for (const map of importMaps.slice(1)) {
-    for (const [module2, imports] of map) {
-      const mergedModuleMap = mergedMap.get(module2) ?? /* @__PURE__ */ new Map();
+    for (const [module, imports] of map) {
+      const mergedModuleMap = mergedMap.get(module) ?? /* @__PURE__ */ new Map();
       for (const [usedIdentifier, importInfo] of imports) {
         const existingImportInfo = mergedModuleMap.get(usedIdentifier);
         const shouldOverwriteTypeOnly = existingImportInfo && existingImportInfo.importedIdentifier === importInfo.importedIdentifier && existingImportInfo.isType && !importInfo.isType;
@@ -133,7 +119,7 @@ function mergeImportMaps(importMaps) {
           mergedModuleMap.set(usedIdentifier, importInfo);
         }
       }
-      mergedMap.set(module2, mergedModuleMap);
+      mergedMap.set(module, mergedModuleMap);
     }
   }
   return Object.freeze(mergedMap);
@@ -144,11 +130,15 @@ function importMapToString(importMap, dependencyMap = {}, useGranularImports = f
     const relative = Number(a.startsWith(".")) - Number(b.startsWith("."));
     if (relative !== 0) return relative;
     return a.localeCompare(b);
-  }).map(([module2, imports]) => {
+  }).map(([module, imports]) => {
     const innerImports = [...imports.values()].map(importInfoToString).sort((a, b) => a.localeCompare(b)).join(", ");
-    return `import { ${innerImports} } from '${module2}';`;
+    return `import { ${innerImports} } from '${module}';`;
   }).join("\n");
 }
+function getExternalDependencies(importMap, dependencyMap, useGranularImports) {
+  const resolvedImports = resolveImportMapModules(importMap, dependencyMap, useGranularImports);
+  return new Set([...resolvedImports.keys()].filter((module) => !module.startsWith(".")));
+}
 function resolveImportMapModules(importMap, dependencyMap, useGranularImports) {
   const dependencyMapWithDefaults = {
     ...useGranularImports ? DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP : DEFAULT_EXTERNAL_MODULE_MAP,
@@ -156,8 +146,8 @@ function resolveImportMapModules(importMap, dependencyMap, useGranularImports) {
     ...dependencyMap
   };
   return mergeImportMaps(
-    [...importMap.entries()].map(([module2, imports]) => {
-      const resolvedModule = dependencyMapWithDefaults[module2] ?? module2;
+    [...importMap.entries()].map(([module, imports]) => {
+      const resolvedModule = dependencyMapWithDefaults[module] ?? module;
       return /* @__PURE__ */ new Map([[resolvedModule, imports]]);
     })
   );
@@ -166,73 +156,67 @@ function importInfoToString({ importedIdentifier, isType, usedIdentifier }) {
   const alias = importedIdentifier !== usedIdentifier ? ` as ${usedIdentifier}` : "";
   return `${isType ? "type " : ""}${importedIdentifier}${alias}`;
 }
-
-// src/utils/nameTransformers.ts
-var import_nodes = require("@codama/nodes");
 function getNameApi(transformers) {
   const helpers = {
-    camelCase: import_nodes.camelCase,
-    capitalize: import_nodes.capitalize,
-    kebabCase: import_nodes.kebabCase,
-    pascalCase: import_nodes.pascalCase,
-    snakeCase: import_nodes.snakeCase,
-    titleCase: import_nodes.titleCase
+    camelCase: nodes.camelCase,
+    capitalize: nodes.capitalize,
+    kebabCase: nodes.kebabCase,
+    pascalCase: nodes.pascalCase,
+    snakeCase: nodes.snakeCase,
+    titleCase: nodes.titleCase
   };
   return Object.fromEntries(
     Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
   );
 }
 var DEFAULT_NAME_TRANSFORMERS = {
-  accountDecodeFunction: (name) => `decode${(0, import_nodes.pascalCase)(name)}`,
-  accountFetchAllFunction: (name) => `fetchAll${(0, import_nodes.pascalCase)(name)}`,
-  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${(0, import_nodes.pascalCase)(name)}`,
-  accountFetchFromSeedsFunction: (name) => `fetch${(0, import_nodes.pascalCase)(name)}FromSeeds`,
-  accountFetchFunction: (name) => `fetch${(0, import_nodes.pascalCase)(name)}`,
-  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${(0, import_nodes.pascalCase)(name)}FromSeeds`,
-  accountFetchMaybeFunction: (name) => `fetchMaybe${(0, import_nodes.pascalCase)(name)}`,
-  accountGetSizeFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}Size`,
-  codecFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}Codec`,
-  constant: (name) => (0, import_nodes.snakeCase)(name).toUpperCase(),
-  constantFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}Bytes`,
-  dataArgsType: (name) => `${(0, import_nodes.pascalCase)(name)}Args`,
-  dataType: (name) => `${(0, import_nodes.pascalCase)(name)}`,
-  decoderFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}Decoder`,
+  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`,
   discriminatedUnionDiscriminator: () => "__kind",
-  discriminatedUnionFunction: (name) => `${(0, import_nodes.camelCase)(name)}`,
-  discriminatedUnionVariant: (name) => `${(0, import_nodes.pascalCase)(name)}`,
-  encoderFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}Encoder`,
-  enumVariant: (name) => `${(0, import_nodes.pascalCase)(name)}`,
-  instructionAsyncFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}InstructionAsync`,
-  instructionAsyncInputType: (name) => `${(0, import_nodes.pascalCase)(name)}AsyncInput`,
-  instructionDataType: (name) => `${(0, import_nodes.pascalCase)(name)}InstructionData`,
-  instructionExtraType: (name) => `${(0, import_nodes.pascalCase)(name)}InstructionExtra`,
-  instructionParseFunction: (name) => `parse${(0, import_nodes.pascalCase)(name)}Instruction`,
-  instructionParsedType: (name) => `Parsed${(0, import_nodes.pascalCase)(name)}Instruction`,
-  instructionSyncFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}Instruction`,
-  instructionSyncInputType: (name) => `${(0, import_nodes.pascalCase)(name)}Input`,
-  instructionType: (name) => `${(0, import_nodes.pascalCase)(name)}Instruction`,
-  isDiscriminatedUnionFunction: (name) => `is${(0, import_nodes.pascalCase)(name)}`,
-  pdaFindFunction: (name) => `find${(0, import_nodes.pascalCase)(name)}Pda`,
-  pdaSeedsType: (name) => `${(0, import_nodes.pascalCase)(name)}Seeds`,
-  programAccountsEnum: (name) => `${(0, import_nodes.pascalCase)(name)}Account`,
-  programAccountsEnumVariant: (name) => `${(0, import_nodes.pascalCase)(name)}`,
-  programAccountsIdentifierFunction: (name) => `identify${(0, import_nodes.pascalCase)(name)}Account`,
-  programAddressConstant: (name) => `${(0, import_nodes.snakeCase)(name).toUpperCase()}_PROGRAM_ADDRESS`,
-  programErrorConstant: (name) => (0, import_nodes.snakeCase)(name).toUpperCase(),
-  programErrorConstantPrefix: (name) => `${(0, import_nodes.snakeCase)(name).toUpperCase()}_ERROR__`,
-  programErrorMessagesMap: (name) => `${(0, import_nodes.camelCase)(name)}ErrorMessages`,
-  programErrorUnion: (name) => `${(0, import_nodes.pascalCase)(name)}Error`,
-  programGetErrorMessageFunction: (name) => `get${(0, import_nodes.pascalCase)(name)}ErrorMessage`,
-  programInstructionsEnum: (name) => `${(0, import_nodes.pascalCase)(name)}Instruction`,
-  programInstructionsEnumVariant: (name) => `${(0, import_nodes.pascalCase)(name)}`,
-  programInstructionsIdentifierFunction: (name) => `identify${(0, import_nodes.pascalCase)(name)}Instruction`,
-  programInstructionsParsedUnionType: (name) => `Parsed${(0, import_nodes.pascalCase)(name)}Instruction`,
-  programIsErrorFunction: (name) => `is${(0, import_nodes.pascalCase)(name)}Error`,
-  resolverFunction: (name) => `${(0, import_nodes.camelCase)(name)}`
+  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)}`
 };
-
-// src/utils/fragment.ts
-var import_renderers_core = require("@codama/renderers-core");
 function createFragment(content) {
   return Object.freeze({ content, features: /* @__PURE__ */ new Set(), imports: createImportMap() });
 }
@@ -240,7 +224,7 @@ function isFragment(value) {
   return typeof value === "object" && value !== null && "content" in value;
 }
 function fragment(template, ...items) {
-  return (0, import_renderers_core.createFragmentTemplate)(template, items, isFragment, mergeFragments);
+  return renderersCore.createFragmentTemplate(template, items, isFragment, mergeFragments);
 }
 function mergeFragments(fragments, mergeContent) {
   const filteredFragments = fragments.filter((f) => f !== void 0);
@@ -250,24 +234,24 @@ function mergeFragments(fragments, mergeContent) {
     imports: mergeImportMaps(filteredFragments.map((f) => f.imports))
   });
 }
-function use(importInput, module2) {
+function use(importInput, module) {
   const importInfo = parseImportInput(importInput);
-  return addFragmentImports(createFragment(importInfo.usedIdentifier), module2, [importInput]);
+  return addFragmentImports(createFragment(importInfo.usedIdentifier), module, [importInput]);
 }
 function mergeFragmentImports(fragment2, importMaps) {
   return Object.freeze({ ...fragment2, imports: mergeImportMaps([fragment2.imports, ...importMaps]) });
 }
-function addFragmentImports(fragment2, module2, importInputs) {
-  return Object.freeze({ ...fragment2, imports: addToImportMap(fragment2.imports, module2, importInputs) });
+function addFragmentImports(fragment2, module, importInputs) {
+  return Object.freeze({ ...fragment2, imports: addToImportMap(fragment2.imports, module, importInputs) });
 }
-function removeFragmentImports(fragment2, module2, usedIdentifiers) {
-  return Object.freeze({ ...fragment2, imports: removeFromImportMap(fragment2.imports, module2, usedIdentifiers) });
+function removeFragmentImports(fragment2, module, usedIdentifiers) {
+  return Object.freeze({ ...fragment2, imports: removeFromImportMap(fragment2.imports, module, usedIdentifiers) });
 }
 function addFragmentFeatures(fragment2, features) {
   return Object.freeze({ ...fragment2, features: /* @__PURE__ */ new Set([...fragment2.features, ...features]) });
 }
-function getExportAllFragment(module2) {
-  return fragment`export * from '${module2}';`;
+function getExportAllFragment(module) {
+  return fragment`export * from '${module}';`;
 }
 function getDocblockFragment(lines, withLineJump = false) {
   const lineJump = withLineJump ? "\n" : "";
@@ -312,24 +296,12 @@ function mergeTypeManifests(manifests, options = {}) {
     value: merge((m) => m.value, mergeValues)
   });
 }
-
-// src/visitors/getRenderMapVisitor.ts
-var import_nodes29 = require("@codama/nodes");
-var import_renderers_core13 = require("@codama/renderers-core");
-var import_visitors_core29 = require("@codama/visitors-core");
-
-// src/fragments/accountFetchHelpers.ts
-var import_visitors_core2 = require("@codama/visitors-core");
-
-// src/utils/async.ts
-var import_nodes2 = require("@codama/nodes");
-var import_visitors_core = require("@codama/visitors-core");
 function hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers) {
   const hasByteDeltasAsync = (instructionNode.byteDeltas ?? []).some(
-    ({ value }) => (0, import_nodes2.isNode)(value, "resolverValueNode") && asyncResolvers.includes(value.name)
+    ({ value }) => nodes.isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
   );
   const hasRemainingAccountsAsync = (instructionNode.remainingAccounts ?? []).some(
-    ({ value }) => (0, import_nodes2.isNode)(value, "resolverValueNode") && asyncResolvers.includes(value.name)
+    ({ value }) => nodes.isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
   );
   return hasAsyncDefaultValues(resolvedInputs, asyncResolvers) || hasByteDeltasAsync || hasRemainingAccountsAsync;
 }
@@ -351,8 +323,8 @@ function isAsyncDefaultValue(defaultValue, asyncResolvers) {
   }
 }
 function getInstructionDependencies(input, asyncResolvers, useAsync) {
-  if ((0, import_nodes2.isNode)(input, "instructionNode")) {
-    return (0, import_visitors_core.deduplicateInstructionDependencies)([
+  if (nodes.isNode(input, "instructionNode")) {
+    return visitorsCore.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))
@@ -363,29 +335,29 @@ function getInstructionDependencies(input, asyncResolvers, useAsync) {
     if (!defaultValue) return [];
     return getInstructionDependencies({ ...input, defaultValue }, asyncResolvers, useAsync);
   };
-  if ((0, import_nodes2.isNode)(input.defaultValue, ["accountValueNode", "accountBumpValueNode"])) {
-    return [(0, import_nodes2.accountValueNode)(input.defaultValue.name)];
+  if (nodes.isNode(input.defaultValue, ["accountValueNode", "accountBumpValueNode"])) {
+    return [nodes.accountValueNode(input.defaultValue.name)];
   }
-  if ((0, import_nodes2.isNode)(input.defaultValue, ["argumentValueNode"])) {
-    return [(0, import_nodes2.argumentValueNode)(input.defaultValue.name)];
+  if (nodes.isNode(input.defaultValue, ["argumentValueNode"])) {
+    return [nodes.argumentValueNode(input.defaultValue.name)];
   }
-  if ((0, import_nodes2.isNode)(input.defaultValue, "pdaValueNode")) {
+  if (nodes.isNode(input.defaultValue, "pdaValueNode")) {
     const dependencies = /* @__PURE__ */ new Map();
     input.defaultValue.seeds.forEach((seed) => {
-      if ((0, import_nodes2.isNode)(seed.value, ["accountValueNode", "argumentValueNode"])) {
+      if (nodes.isNode(seed.value, ["accountValueNode", "argumentValueNode"])) {
         dependencies.set(seed.value.name, { ...seed.value });
       }
     });
     return [...dependencies.values()];
   }
-  if ((0, import_nodes2.isNode)(input.defaultValue, "resolverValueNode")) {
+  if (nodes.isNode(input.defaultValue, "resolverValueNode")) {
     const isSynchronousResolver = !asyncResolvers.includes(input.defaultValue.name);
     if (useAsync || isSynchronousResolver) {
       return input.defaultValue.dependsOn ?? [];
     }
   }
-  if ((0, import_nodes2.isNode)(input.defaultValue, "conditionalValueNode")) {
-    return (0, import_visitors_core.deduplicateInstructionDependencies)([
+  if (nodes.isNode(input.defaultValue, "conditionalValueNode")) {
+    return visitorsCore.deduplicateInstructionDependencies([
       ...getNestedDependencies(input.defaultValue.condition),
       ...getNestedDependencies(input.defaultValue.ifTrue),
       ...getNestedDependencies(input.defaultValue.ifFalse)
@@ -393,58 +365,75 @@ 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 (0, import_codecs_strings.getUtf8Encoder)().encode(node.data);
+      return codecsStrings.getUtf8Encoder().encode(node.data);
     case "base16":
-      return (0, import_codecs_strings.getBase16Encoder)().encode(node.data);
+      return codecsStrings.getBase16Encoder().encode(node.data);
     case "base58":
-      return (0, import_codecs_strings.getBase58Encoder)().encode(node.data);
+      return codecsStrings.getBase58Encoder().encode(node.data);
     case "base64":
     default:
-      return (0, import_codecs_strings.getBase64Encoder)().encode(node.data);
+      return codecsStrings.getBase64Encoder().encode(node.data);
   }
 }
-
-// src/utils/customData.ts
-var import_nodes3 = require("@codama/nodes");
 var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
   customDataOptions.map((o) => {
     const options = typeof o === "string" ? { name: o } : o;
-    const importAs = (0, import_nodes3.camelCase)(options.importAs ?? `${options.name}${defaultSuffix}`);
+    const importAs = nodes.camelCase(options.importAs ?? `${options.name}${defaultSuffix}`);
     const importFrom = options.importFrom ?? "hooked";
     return [
-      (0, import_nodes3.camelCase)(options.name),
+      nodes.camelCase(options.name),
       {
         extract: options.extract ?? false,
-        extractAs: options.extractAs ? (0, import_nodes3.camelCase)(options.extractAs) : importAs,
+        extractAs: options.extractAs ? nodes.camelCase(options.extractAs) : importAs,
         importAs,
         importFrom,
-        linkNode: (0, import_nodes3.definedTypeLinkNode)(importAs)
+        linkNode: nodes.definedTypeLinkNode(importAs)
       }
     ];
   })
 );
-var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.flatMap((node) => {
+var getDefinedTypeNodesToExtract = (nodes$1, parsedCustomDataOptions) => nodes$1.flatMap((node) => {
   const options = parsedCustomDataOptions.get(node.name);
   if (!options || !options.extract) return [];
-  if ((0, import_nodes3.isNode)(node, "accountNode")) {
-    return [(0, import_nodes3.definedTypeNode)({ name: options.extractAs, type: { ...node.data } })];
+  if (nodes.isNode(node, "accountNode")) {
+    return [nodes.definedTypeNode({ name: options.extractAs, type: { ...node.data } })];
   }
   return [
-    (0, import_nodes3.definedTypeNode)({
+    nodes.definedTypeNode({
       name: options.extractAs,
-      type: (0, import_nodes3.structTypeNodeFromInstructionArgumentNodes)(node.arguments)
+      type: nodes.structTypeNodeFromInstructionArgumentNodes(node.arguments)
     })
   ];
 });
-
-// src/utils/linkOverrides.ts
-var import_errors = require("@codama/errors");
+var DEFAULT_PRETTIER_OPTIONS = {
+  arrowParens: "always",
+  parser: "typescript",
+  plugins: [estreePlugin__namespace, typeScriptPlugin__namespace],
+  printWidth: 80,
+  semi: true,
+  singleQuote: true,
+  tabWidth: 2,
+  trailingComma: "es5",
+  useTabs: false
+};
+async function formatCode(renderMap, options) {
+  const shouldFormatCode = options.formatCode ?? true;
+  if (!shouldFormatCode) return renderMap;
+  const prettierOptions = {
+    ...DEFAULT_PRETTIER_OPTIONS,
+    ...await resolvePrettierOptions(options.packageFolder),
+    ...options.prettierOptions
+  };
+  return await renderersCore.mapRenderMapContentAsync(renderMap, (code) => prettier.format(code, prettierOptions));
+}
+async function resolvePrettierOptions(packageFolder) {
+  {
+    return null;
+  }
+}
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
   const customDataOverrides = Object.fromEntries(
     [...customAccountData.values(), ...customInstructionData.values()].map(({ importFrom, importAs }) => [
@@ -476,7 +465,7 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
       case "resolverValueNode":
         return linkOverrides.resolvers[node.name] ?? "hooked";
       default:
-        throw new import_errors.CodamaError(import_errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
           expectedKinds: [
             "AccountLinkNode",
             "DefinedTypeLinkNode",
@@ -491,11 +480,177 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
     }
   };
 }
+var DEFAULT_DEPENDENCY_VERSIONS = {
+  "@solana/accounts": "^5.0.0",
+  "@solana/addresses": "^5.0.0",
+  "@solana/codecs": "^5.0.0",
+  "@solana/errors": "^5.0.0",
+  "@solana/instructions": "^5.0.0",
+  "@solana/kit": "^5.0.0",
+  "@solana/programs": "^5.0.0",
+  "@solana/rpc-types": "^5.0.0",
+  "@solana/signers": "^5.0.0"
+};
+function syncPackageJson(renderMap, options) {
+  const shouldSyncPackageJson = options.syncPackageJson ?? false;
+  const packageFolder = options.packageFolder;
+  if (!packageFolder) {
+    if (shouldSyncPackageJson) {
+      errors.logWarn("Cannot sync package.json. Please provide the 'packageFolder' option.");
+    }
+    return;
+  }
+  const packageJsonPath = renderersCore.joinPath(packageFolder, "package.json");
+  const usedDependencies = getUsedDependencyVersions(
+    renderMap,
+    options.dependencyMap ?? {},
+    options.dependencyVersions ?? {},
+    options.useGranularImports ?? false
+  );
+  if (!shouldSyncPackageJson) {
+    if (renderersCore.fileExists(packageJsonPath)) {
+      checkExistingPackageJson(renderersCore.readJson(packageJsonPath), usedDependencies);
+    }
+    return;
+  }
+  if (renderersCore.fileExists(packageJsonPath)) {
+    const packageJson = updateExistingPackageJson(renderersCore.readJson(packageJsonPath), usedDependencies);
+    renderersCore.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  } else {
+    const packageJson = createNewPackageJson(usedDependencies);
+    renderersCore.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  }
+}
+function createNewPackageJson(dependencyVersions) {
+  return updateExistingPackageJson(
+    {
+      name: "js-client",
+      version: "1.0.0",
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      description: "",
+      main: "src/index.ts",
+      scripts: { test: 'echo "Error: no test specified" && exit 1' },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      keywords: [],
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      author: ""
+    },
+    dependencyVersions
+  );
+}
+function updateExistingPackageJson(packageJson, dependencyVersions) {
+  const updatedDependencies = { ...packageJson.dependencies };
+  const updatedPeerDependencies = { ...packageJson.peerDependencies };
+  const updatedDevDependencies = { ...packageJson.devDependencies };
+  for (const [dependency, requiredRange] of Object.entries(dependencyVersions)) {
+    let found = false;
+    if (updatedDependencies[dependency]) {
+      updateDependency(updatedDependencies, dependency, requiredRange);
+      found = true;
+    }
+    if (updatedPeerDependencies[dependency]) {
+      updateDependency(updatedPeerDependencies, dependency, requiredRange);
+      found = true;
+    }
+    if (updatedDevDependencies[dependency]) {
+      updateDependency(updatedDevDependencies, dependency, requiredRange);
+      found = true;
+    }
+    if (!found) {
+      const dependencyGroupToAdd = dependency === "@solana/kit" ? updatedPeerDependencies : updatedDependencies;
+      dependencyGroupToAdd[dependency] = requiredRange;
+    }
+  }
+  return {
+    ...packageJson,
+    ...Object.entries(updatedPeerDependencies).length > 0 ? { peerDependencies: updatedPeerDependencies } : {},
+    ...Object.entries(updatedDependencies).length > 0 ? { dependencies: updatedDependencies } : {},
+    ...Object.entries(updatedDevDependencies).length > 0 ? { devDependencies: updatedDevDependencies } : {}
+  };
+}
+function checkExistingPackageJson(packageJson, dependencyVersions) {
+  const missingDependencies = [];
+  const dependenciesToUpdate = [];
+  const existingDependencies = {
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.dependencies
+  };
+  for (const [dependency, requiredRange] of Object.entries(dependencyVersions)) {
+    if (!existingDependencies[dependency]) {
+      missingDependencies.push(dependency);
+    } else if (shouldUpdateRange(dependency, existingDependencies[dependency], requiredRange)) {
+      dependenciesToUpdate.push(dependency);
+    }
+  }
+  if (missingDependencies.length === 0 && dependenciesToUpdate.length === 0) return;
+  const missingList = missingDependencies.map((d) => `- ${d} missing: ${dependencyVersions[d]}
+`).join("");
+  const outdatedList = dependenciesToUpdate.map((d) => `- ${d} outdated: ${existingDependencies[d]} -> ${dependencyVersions[d]}
+`).join("");
+  errors.logWarn(
+    `The following dependencies in your \`package.json\` are out-of-date or missing:
+${missingList}${outdatedList}`
+  );
+}
+function getUsedDependencyVersions(renderMap, dependencyMap, dependencyVersions, useGranularImports) {
+  const dependencyVersionsWithDefaults = {
+    ...DEFAULT_DEPENDENCY_VERSIONS,
+    ...dependencyVersions
+  };
+  const fragment2 = mergeFragments([...renderMap.values()], () => "");
+  const usedDependencies = getExternalDependencies(fragment2.imports, dependencyMap, useGranularImports);
+  const [usedDependencyVersion, missingDependencies] = [...usedDependencies].reduce(
+    ([acc, missingDependencies2], dependency) => {
+      const version = dependencyVersionsWithDefaults[dependency];
+      if (version) {
+        acc[dependency] = version;
+      } else {
+        missingDependencies2.add(dependency);
+      }
+      return [acc, missingDependencies2];
+    },
+    [{}, /* @__PURE__ */ new Set()]
+  );
+  if (missingDependencies.size > 0) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS, {
+      dependencies: [...missingDependencies],
+      message: "Please add these dependencies to the `dependencyVersions` option."
+    });
+  }
+  return usedDependencyVersion;
+}
+function shouldUpdateRange(dependency, currentRange, requiredRange) {
+  try {
+    if (semver.subset(currentRange, requiredRange)) {
+      return false;
+    }
+    const minRequiredVersion = semver.minVersion(requiredRange);
+    const minCurrentVersion = semver.minVersion(currentRange);
+    if (!minCurrentVersion || !minRequiredVersion) {
+      throw new Error("Could not determine minimum versions.");
+    }
+    if (semver.lt(minCurrentVersion, minRequiredVersion)) {
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.warn(
+      `Could not parse the following ranges for dependency "${dependency}": [${currentRange}] and/or [${requiredRange}]. Caused by: ${error.message}`
+    );
+    return false;
+  }
+}
+function updateDependency(dependencyGroup, dependency, requiredRange) {
+  const currentRange = dependencyGroup[dependency];
+  if (!shouldUpdateRange(dependency, currentRange, requiredRange)) return;
+  dependencyGroup[dependency] = requiredRange;
+}
 
 // src/fragments/accountFetchHelpers.ts
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = (0, import_visitors_core2.getLastNodeFromPath)(accountPath);
+  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
   const decodeFunction = nameApi.accountDecodeFunction(accountNode.name);
   const fetchAllFunction = nameApi.accountFetchAllFunction(accountNode.name);
   const fetchAllMaybeFunction = nameApi.accountFetchAllMaybeFunction(accountNode.name);
@@ -504,7 +659,7 @@ function getAccountFetchHelpersFragment(scope) {
   const hasCustomData = customAccountData.has(accountNode.name);
   const accountType = hasCustomData ? typeManifest2.strictType : nameApi.dataType(accountNode.name);
   const decoderFunction = hasCustomData ? typeManifest2.decoder : `${nameApi.decoderFunction(accountNode.name)}()`;
-  return (0, import_visitors_core2.pipe)(
+  return visitorsCore.pipe(
     fragment`export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<${accountType}, TAddress>;
 export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<${accountType}, TAddress>;
 export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<${accountType}, TAddress> | MaybeAccount<${accountType}, TAddress> {
@@ -564,28 +719,20 @@ export async function ${fetchAllMaybeFunction}(
     ])
   );
 }
-
-// src/fragments/accountPage.ts
-var import_nodes9 = require("@codama/nodes");
-var import_visitors_core7 = require("@codama/visitors-core");
-
-// 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 = (0, import_visitors_core3.getLastNodeFromPath)(accountPath);
+  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
   const pdaNode = accountNode.pda ? linkables.get([...accountPath, accountNode.pda]) : void 0;
   if (!pdaNode) return;
   const accountType = customAccountData.has(accountNode.name) ? typeManifest2.strictType : nameApi.dataType(accountNode.name);
   const importFrom = "generatedPdas";
   const pdaSeedsType = nameApi.pdaSeedsType(pdaNode.name);
   const findPdaFunction = nameApi.pdaFindFunction(pdaNode.name);
-  const hasVariableSeeds = pdaNode.seeds.filter((0, import_nodes4.isNodeFilter)("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = pdaNode.seeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length > 0;
   const fetchFromSeedsFunction = nameApi.accountFetchFromSeedsFunction(accountNode.name);
   const fetchMaybeFromSeedsFunction = nameApi.accountFetchMaybeFromSeedsFunction(accountNode.name);
   const fetchMaybeFunction = nameApi.accountFetchMaybeFunction(accountNode.name);
-  return (0, import_visitors_core3.pipe)(
+  return visitorsCore.pipe(
     fragment`export async function ${fetchFromSeedsFunction}(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   ${hasVariableSeeds ? `seeds: ${pdaSeedsType},` : ""}
@@ -615,12 +762,9 @@ export async function ${fetchMaybeFromSeedsFunction}(
     ])
   );
 }
-
-// src/fragments/accountSizeHelpers.ts
-var import_visitors_core4 = require("@codama/visitors-core");
 function getAccountSizeHelpersFragment(scope) {
   const { accountPath, nameApi } = scope;
-  const accountNode = (0, import_visitors_core4.getLastNodeFromPath)(accountPath);
+  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
   if (accountNode.size == null) return;
   const getSizeFunction = nameApi.accountGetSizeFunction(accountNode.name);
   return fragment`export function ${getSizeFunction}(): number {
@@ -628,10 +772,6 @@ function getAccountSizeHelpersFragment(scope) {
 }`;
 }
 
-// src/fragments/accountType.ts
-var import_nodes7 = require("@codama/nodes");
-var import_visitors_core5 = require("@codama/visitors-core");
-
 // src/fragments/type.ts
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
@@ -645,9 +785,6 @@ function getTypeFragment(scope) {
   const looseExport = manifest.strictType.content === manifest.looseType.content ? aliasedLooseName : fragment`export type ${looseName} = ${manifest.looseType};`;
   return fragment`${docblock}export type ${strictName} = ${manifest.strictType};\n\n${looseExport}`;
 }
-
-// src/fragments/typeDecoder.ts
-var import_nodes5 = require("@codama/nodes");
 function getTypeDecoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const decoderFunction = nameApi.decoderFunction(name);
@@ -657,15 +794,12 @@ function getTypeDecoderFragment(scope) {
     typeof scope.size === "number" ? "type FixedSizeDecoder" : "type Decoder",
     "solanaCodecsCore"
   );
-  const useTypeCast = (0, import_nodes5.isNode)(node, "enumTypeNode") && (0, import_nodes5.isDataEnum)(node) && typeof scope.size === "number";
+  const useTypeCast = nodes.isNode(node, "enumTypeNode") && nodes.isDataEnum(node) && typeof scope.size === "number";
   const typeCast = useTypeCast ? fragment` as ${decoderType}<${strictName}>` : "";
   return fragment`${docblock}export function ${decoderFunction}(): ${decoderType}<${strictName}> {
     return ${manifest.decoder}${typeCast};
 }`;
 }
-
-// src/fragments/typeEncoder.ts
-var import_nodes6 = require("@codama/nodes");
 function getTypeEncoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const encoderFunction = nameApi.encoderFunction(name);
@@ -675,7 +809,7 @@ function getTypeEncoderFragment(scope) {
     typeof scope.size === "number" ? "type FixedSizeEncoder" : "type Encoder",
     "solanaCodecsCore"
   );
-  const useTypeCast = (0, import_nodes6.isNode)(node, "enumTypeNode") && (0, import_nodes6.isDataEnum)(node) && typeof scope.size === "number";
+  const useTypeCast = nodes.isNode(node, "enumTypeNode") && nodes.isDataEnum(node) && typeof scope.size === "number";
   const typeCast = useTypeCast ? fragment` as ${encoderType}<${looseName}>` : "";
   return fragment`${docblock}export function ${encoderFunction}(): ${encoderType}<${looseName}> {
     return ${manifest.encoder}${typeCast};
@@ -715,7 +849,7 @@ function getTypeWithCodecFragment(scope) {
 // src/fragments/accountType.ts
 function getAccountTypeFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = (0, import_visitors_core5.getLastNodeFromPath)(accountPath);
+  const accountNode = visitorsCore.getLastNodeFromPath(accountPath);
   if (customAccountData.has(accountNode.name)) return;
   return getTypeWithCodecFragment({
     codecDocs: [`Gets the codec for {@link ${nameApi.dataType(accountNode.name)}} account data.`],
@@ -724,15 +858,11 @@ function getAccountTypeFragment(scope) {
     manifest: typeManifest2,
     name: accountNode.name,
     nameApi,
-    node: (0, import_nodes7.resolveNestedTypeNode)(accountNode.data),
+    node: nodes.resolveNestedTypeNode(accountNode.data),
     size: scope.size,
     typeDocs: accountNode.docs
   });
 }
-
-// src/fragments/discriminatorConstants.ts
-var import_nodes8 = require("@codama/nodes");
-var import_visitors_core6 = require("@codama/visitors-core");
 function getDiscriminatorConstantsFragment(scope) {
   const fragments = scope.discriminatorNodes.map((node) => getDiscriminatorConstantFragment(node, scope)).filter(Boolean);
   return mergeFragments(fragments, (c) => c.join("\n\n"));
@@ -749,22 +879,22 @@ function getDiscriminatorConstantFragment(discriminatorNode, scope) {
 }
 function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
-  const index = discriminatorNodes.filter((0, import_nodes8.isNodeFilter)("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const index = discriminatorNodes.filter(nodes.isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = (0, import_nodes8.camelCase)(`${prefix}_discriminator${suffix}`);
-  const encoder = (0, import_visitors_core6.visit)(discriminatorNode.constant.type, typeManifestVisitor).encoder;
-  const value = (0, import_visitors_core6.visit)(discriminatorNode.constant.value, typeManifestVisitor).value;
+  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;
   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 || !(0, import_nodes8.isNode)(field.defaultValue, import_nodes8.VALUE_NODES)) {
+  if (!field || !field.defaultValue || !nodes.isNode(field.defaultValue, nodes.VALUE_NODES)) {
     return null;
   }
-  const name = (0, import_nodes8.camelCase)(`${prefix}_${discriminatorNode.name}`);
-  const encoder = (0, import_visitors_core6.visit)(field.type, typeManifestVisitor).encoder;
-  const value = (0, import_visitors_core6.visit)(field.defaultValue, typeManifestVisitor).value;
+  const name = nodes.camelCase(`${prefix}_${discriminatorNode.name}`);
+  const encoder = visitorsCore.visit(field.type, typeManifestVisitor).encoder;
+  const value = visitorsCore.visit(field.defaultValue, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getConstantFragment(scope) {
@@ -776,12 +906,12 @@ function getConstantFragment(scope) {
 
 // src/fragments/accountPage.ts
 function getAccountPageFragment(scope) {
-  const node = (0, import_visitors_core7.getLastNodeFromPath)(scope.accountPath);
-  if (!(0, import_visitors_core7.findProgramNodeFromPath)(scope.accountPath)) {
+  const node = visitorsCore.getLastNodeFromPath(scope.accountPath);
+  if (!visitorsCore.findProgramNodeFromPath(scope.accountPath)) {
     throw new Error("Account must be visited inside a program.");
   }
-  const typeManifest2 = (0, import_visitors_core7.visit)(node, scope.typeManifestVisitor);
-  const fields = (0, import_nodes9.resolveNestedTypeNode)(node.data).fields;
+  const typeManifest2 = visitorsCore.visit(node, scope.typeManifestVisitor);
+  const fields = nodes.resolveNestedTypeNode(node.data).fields;
   return mergeFragments(
     [
       getDiscriminatorConstantsFragment({
@@ -798,30 +928,24 @@ function getAccountPageFragment(scope) {
     (cs) => cs.join("\n\n")
   );
 }
-
-// src/fragments/discriminatorCondition.ts
-var import_nodes10 = require("@codama/nodes");
-var import_renderers_core2 = require("@codama/renderers-core");
-var import_visitors_core8 = require("@codama/visitors-core");
-var import_codecs_strings2 = require("@solana/codecs-strings");
 function getDiscriminatorConditionFragment(scope) {
-  return (0, import_visitors_core8.pipe)(
+  return visitorsCore.pipe(
     mergeFragments(
       scope.discriminators.flatMap((discriminator) => {
-        if ((0, import_nodes10.isNode)(discriminator, "sizeDiscriminatorNode")) {
+        if (nodes.isNode(discriminator, "sizeDiscriminatorNode")) {
           return [getSizeConditionFragment(discriminator, scope)];
         }
-        if ((0, import_nodes10.isNode)(discriminator, "constantDiscriminatorNode")) {
+        if (nodes.isNode(discriminator, "constantDiscriminatorNode")) {
           return [getByteConditionFragment(discriminator, scope)];
         }
-        if ((0, import_nodes10.isNode)(discriminator, "fieldDiscriminatorNode")) {
+        if (nodes.isNode(discriminator, "fieldDiscriminatorNode")) {
           return [getFieldConditionFragment(discriminator, scope)];
         }
         return [];
       }),
       (c) => c.join(" && ")
     ),
-    (f) => (0, import_renderers_core2.mapFragmentContent)(f, (c) => `if (${c}) { ${scope.ifTrue} }`)
+    (f) => renderersCore.mapFragmentContent(f, (c) => `if (${c}) { ${scope.ifTrue} }`)
   );
 }
 function getSizeConditionFragment(discriminator, scope) {
@@ -830,7 +954,7 @@ function getSizeConditionFragment(discriminator, scope) {
 }
 function getByteConditionFragment(discriminator, scope) {
   const { dataName, typeManifestVisitor } = scope;
-  const constant = (0, import_visitors_core8.visit)(discriminator.constant, typeManifestVisitor).value;
+  const constant = visitorsCore.visit(discriminator.constant, typeManifestVisitor).value;
   return fragment`${use("containsBytes", "solanaCodecsCore")}(${dataName}, ${constant}, ${discriminator.offset})`;
 }
 function getFieldConditionFragment(discriminator, scope) {
@@ -840,17 +964,17 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if ((0, import_nodes10.isNode)(field.type, "arrayTypeNode") && (0, import_nodes10.isNode)(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && (0, import_nodes10.isNode)(field.type.count, "fixedCountNode") && (0, import_nodes10.isNode)(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every((0, import_nodes10.isNodeFilter)("numberValueNode"))) {
-    const base64Bytes = (0, import_codecs_strings2.getBase64Decoder)().decode(
+  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(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
     return getByteConditionFragment(
-      (0, import_nodes10.constantDiscriminatorNode)((0, import_nodes10.constantValueNodeFromBytes)("base64", base64Bytes), discriminator.offset),
+      nodes.constantDiscriminatorNode(nodes.constantValueNodeFromBytes("base64", base64Bytes), discriminator.offset),
       scope
     );
   }
   return getByteConditionFragment(
-    (0, import_nodes10.constantDiscriminatorNode)((0, import_nodes10.constantValueNode)(field.type, field.defaultValue), discriminator.offset),
+    nodes.constantDiscriminatorNode(nodes.constantValueNode(field.type, field.defaultValue), discriminator.offset),
     scope
   );
 }
@@ -930,19 +1054,13 @@ function getIsErrorFunctionFragment(scope) {
   return ${use("isProgramError", "solanaPrograms")}<TProgramErrorCode>(error, transactionMessage, ${programAddressConstant}, code);
 }`;
 }
-
-// src/fragments/indexPage.ts
-var import_nodes11 = require("@codama/nodes");
 function getIndexPageFragment(items) {
   if (items.length === 0) return;
-  const names = items.map((item) => (0, import_nodes11.camelCase)(item.name)).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
+  const names = items.map((item) => nodes.camelCase(item.name)).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
   return mergeFragments(names, (cs) => cs.join("\n"));
 }
-
-// src/fragments/instructionAccountMeta.ts
-var import_nodes12 = require("@codama/nodes");
 function getInstructionAccountMetaFragment(instructionAccountNode) {
-  const typeParam = `TAccount${(0, import_nodes12.pascalCase)(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${nodes.pascalCase(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
     return fragment`${use("type WritableSignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
@@ -954,17 +1072,13 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
   }
   return fragment`${use("type ReadonlyAccount", "solanaInstructions")}<${typeParam}>`;
 }
-
-// src/fragments/instructionAccountTypeParam.ts
-var import_nodes13 = require("@codama/nodes");
-var import_visitors_core9 = require("@codama/visitors-core");
 function getInstructionAccountTypeParamFragment(scope) {
-  const { instructionAccountPath, allowAccountMeta, linkables } = scope;
-  const instructionAccountNode = (0, import_visitors_core9.getLastNodeFromPath)(instructionAccountPath);
-  const instructionNode = (0, import_visitors_core9.findInstructionNodeFromPath)(instructionAccountPath);
-  const programNode = (0, import_visitors_core9.findProgramNodeFromPath)(instructionAccountPath);
-  const typeParam = `TAccount${(0, import_nodes13.pascalCase)(instructionAccountNode.name)}`;
-  const accountMeta = allowAccountMeta ? fragment` | ${use("type AccountMeta", "solanaInstructions")}<string>` : void 0;
+  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 = fragment` | ${use("type AccountMeta", "solanaInstructions")}<string>` ;
   if (instructionNode.optionalAccountStrategy === "omitted" && instructionAccountNode.isOptional) {
     return fragment`${typeParam} extends string${accountMeta} | undefined = undefined`;
   }
@@ -984,13 +1098,8 @@ function getDefaultAddress(defaultValue, programId, linkables) {
       return "string";
   }
 }
-
-// src/fragments/instructionByteDelta.ts
-var import_nodes14 = require("@codama/nodes");
-var import_renderers_core3 = require("@codama/renderers-core");
-var import_visitors_core10 = require("@codama/visitors-core");
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = (0, import_visitors_core10.getLastNodeFromPath)(scope.instructionPath);
+  const { byteDeltas } = visitorsCore.getLastNodeFromPath(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((c) => getByteDeltaFragment(c, scope));
   if (fragments.length === 0) return;
   return mergeFragments(
@@ -1001,16 +1110,16 @@ const byteDelta: number = [${c.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   let bytesFragment = (() => {
-    if ((0, import_nodes14.isNode)(byteDelta.value, "numberValueNode")) {
+    if (nodes.isNode(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if ((0, import_nodes14.isNode)(byteDelta.value, "argumentValueNode")) {
+    if (nodes.isNode(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if ((0, import_nodes14.isNode)(byteDelta.value, "accountLinkNode")) {
+    if (nodes.isNode(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if ((0, import_nodes14.isNode)(byteDelta.value, "resolverValueNode")) {
+    if (nodes.isNode(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -1020,21 +1129,21 @@ function getByteDeltaFragment(byteDelta, scope) {
     bytesFragment = fragment`${bytesFragment} + ${use("BASE_ACCOUNT_SIZE", "solanaAccounts")}`;
   }
   if (byteDelta.subtract) {
-    bytesFragment = (0, import_visitors_core10.pipe)(bytesFragment, (f) => (0, import_renderers_core3.mapFragmentContent)(f, (c) => `- (${c})`));
+    bytesFragment = visitorsCore.pipe(bytesFragment, (f) => renderersCore.mapFragmentContent(f, (c) => `- (${c})`));
   }
   return [bytesFragment];
 }
 function getNumberValueNodeFragment(byteDelta) {
-  (0, import_nodes14.assertIsNode)(byteDelta.value, "numberValueNode");
+  nodes.assertIsNode(byteDelta.value, "numberValueNode");
   return fragment`${byteDelta.value.number}`;
 }
 function getArgumentValueNodeFragment(byteDelta) {
-  (0, import_nodes14.assertIsNode)(byteDelta.value, "argumentValueNode");
-  const argumentName = (0, import_nodes14.camelCase)(byteDelta.value.name);
+  nodes.assertIsNode(byteDelta.value, "argumentValueNode");
+  const argumentName = nodes.camelCase(byteDelta.value.name);
   return fragment`Number(args.${argumentName})`;
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
-  (0, import_nodes14.assertIsNode)(byteDelta.value, "accountLinkNode");
+  nodes.assertIsNode(byteDelta.value, "accountLinkNode");
   const functionName = use(
     scope.nameApi.accountGetSizeFunction(byteDelta.value.name),
     scope.getImportFrom(byteDelta.value)
@@ -1042,7 +1151,7 @@ function getAccountLinkNodeFragment(byteDelta, scope) {
   return fragment`${functionName}()`;
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
-  (0, import_nodes14.assertIsNode)(byteDelta.value, "resolverValueNode");
+  nodes.assertIsNode(byteDelta.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(byteDelta.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1050,55 +1159,32 @@ function getResolverValueNodeFragment(byteDelta, scope) {
     scope.nameApi.resolverFunction(byteDelta.value.name),
     scope.getImportFrom(byteDelta.value)
   );
-  return (0, import_visitors_core10.pipe)(
+  return visitorsCore.pipe(
     fragment`${awaitKeyword}${functionName}(resolverScope)`,
     (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
   );
 }
-
-// src/fragments/instructionData.ts
-var import_nodes15 = require("@codama/nodes");
-var import_visitors_core11 = require("@codama/visitors-core");
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = (0, import_visitors_core11.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) return;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   return getTypeWithCodecFragment({
     manifest: dataArgsManifest,
     name: instructionDataName,
     nameApi,
-    node: (0, import_nodes15.structTypeNodeFromInstructionArgumentNodes)(instructionNode.arguments),
+    node: nodes.structTypeNodeFromInstructionArgumentNodes(instructionNode.arguments),
     size: scope.size
   });
 }
-
-// src/fragments/instructionExtraArgs.ts
-var import_renderers_core4 = require("@codama/renderers-core");
-var import_visitors_core12 = require("@codama/visitors-core");
 function getInstructionExtraArgsFragment(scope) {
   const { instructionPath, extraArgsManifest, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core12.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) return;
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const looseName = nameApi.dataArgsType(instructionExtraName);
-  return (0, import_renderers_core4.mapFragmentContent)(extraArgsManifest.looseType, (c) => `export type ${looseName} = ${c};`);
+  return renderersCore.mapFragmentContent(extraArgsManifest.looseType, (c) => `export type ${looseName} = ${c};`);
 }
-
-// src/fragments/instructionFunction.ts
-var import_nodes20 = require("@codama/nodes");
-var import_renderers_core8 = require("@codama/renderers-core");
-var import_visitors_core17 = require("@codama/visitors-core");
-
-// src/fragments/instructionInputResolved.ts
-var import_nodes17 = require("@codama/nodes");
-var import_renderers_core6 = require("@codama/renderers-core");
-var import_visitors_core14 = require("@codama/visitors-core");
-
-// src/fragments/instructionInputDefault.ts
-var import_nodes16 = require("@codama/nodes");
-var import_renderers_core5 = require("@codama/renderers-core");
-var import_visitors_core13 = require("@codama/visitors-core");
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
   if (!input.defaultValue) {
@@ -1109,8 +1195,8 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = (0, import_nodes16.camelCase)(input.name);
-    if (input.kind === "instructionAccountNode" && (0, import_nodes16.isNode)(defaultValue, "resolverValueNode")) {
+    const inputName = nodes.camelCase(input.name);
+    if (input.kind === "instructionAccountNode" && nodes.isNode(defaultValue, "resolverValueNode")) {
       return fragment`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`;
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -1128,7 +1214,7 @@ function getInstructionInputDefaultFragment(scope) {
   const addressType = use("type Address", "solanaAddresses");
   switch (defaultValue.kind) {
     case "accountValueNode":
-      const name = (0, import_nodes16.camelCase)(defaultValue.name);
+      const name = nodes.camelCase(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
         return defaultFragment(fragment`${expectTransactionSigner}(accounts.${name}.value).address`);
       }
@@ -1138,13 +1224,13 @@ function getInstructionInputDefaultFragment(scope) {
       return defaultFragment(fragment`${expectAddress}(accounts.${name}.value)`);
     case "pdaValueNode":
       let pdaProgramValue;
-      if ((0, import_nodes16.isNode)(defaultValue.programId, "accountValueNode")) {
-        pdaProgramValue = fragment`${expectAddress}(accounts.${(0, import_nodes16.camelCase)(defaultValue.programId.name)}.value)`;
+      if (nodes.isNode(defaultValue.programId, "accountValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(accounts.${nodes.camelCase(defaultValue.programId.name)}.value)`;
       }
-      if ((0, import_nodes16.isNode)(defaultValue.programId, "argumentValueNode")) {
-        pdaProgramValue = fragment`${expectAddress}(args.${(0, import_nodes16.camelCase)(defaultValue.programId.name)})`;
+      if (nodes.isNode(defaultValue.programId, "argumentValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(args.${nodes.camelCase(defaultValue.programId.name)})`;
       }
-      if ((0, import_nodes16.isNode)(defaultValue.pda, "pdaNode")) {
+      if (nodes.isNode(defaultValue.pda, "pdaNode")) {
         let pdaProgram = fragment`programAddress`;
         if (pdaProgramValue) {
           pdaProgram = pdaProgramValue;
@@ -1152,29 +1238,29 @@ function getInstructionInputDefaultFragment(scope) {
           pdaProgram = fragment`'${defaultValue.pda.programId}' as ${addressType}<'${defaultValue.pda.programId}'>`;
         }
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
-          if ((0, import_nodes16.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes16.isNode)(seed.value, "programIdValueNode")) {
+          if (nodes.isNode(seed, "constantPdaSeedNode") && nodes.isNode(seed.value, "programIdValueNode")) {
             return [fragment`${use("getAddressEncoder", "solanaAddresses")}().encode(${pdaProgram})`];
           }
-          if ((0, import_nodes16.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes16.isNode)(seed.value, "programIdValueNode")) {
-            const typeManifest2 = (0, import_visitors_core13.visit)(seed.type, typeManifestVisitor);
-            const valueManifest2 = (0, import_visitors_core13.visit)(seed.value, typeManifestVisitor);
+          if (nodes.isNode(seed, "constantPdaSeedNode") && !nodes.isNode(seed.value, "programIdValueNode")) {
+            const typeManifest2 = visitorsCore.visit(seed.type, typeManifestVisitor);
+            const valueManifest2 = visitorsCore.visit(seed.value, typeManifestVisitor);
             return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
-          if ((0, import_nodes16.isNode)(seed, "variablePdaSeedNode")) {
-            const typeManifest2 = (0, import_visitors_core13.visit)(seed.type, typeManifestVisitor);
+          if (nodes.isNode(seed, "variablePdaSeedNode")) {
+            const typeManifest2 = visitorsCore.visit(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if ((0, import_nodes16.isNode)(valueSeed, "accountValueNode")) {
+            if (nodes.isNode(valueSeed, "accountValueNode")) {
               return [
-                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${(0, import_nodes16.camelCase)(valueSeed.name)}.value))`
+                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${nodes.camelCase(valueSeed.name)}.value))`
               ];
             }
-            if ((0, import_nodes16.isNode)(valueSeed, "argumentValueNode")) {
+            if (nodes.isNode(valueSeed, "argumentValueNode")) {
               return [
-                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${(0, import_nodes16.camelCase)(valueSeed.name)}))`
+                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${nodes.camelCase(valueSeed.name)}))`
               ];
             }
-            const valueManifest2 = (0, import_visitors_core13.visit)(valueSeed, typeManifestVisitor);
+            const valueManifest2 = visitorsCore.visit(valueSeed, typeManifestVisitor);
             return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
           return [];
@@ -1189,20 +1275,20 @@ function getInstructionInputDefaultFragment(scope) {
       const pdaFunction = use(nameApi.pdaFindFunction(defaultValue.pda.name), getImportFrom(defaultValue.pda));
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
-        if ((0, import_nodes16.isNode)(seed.value, "accountValueNode")) {
-          return fragment`${seed.name}: ${expectAddress}(accounts.${(0, import_nodes16.camelCase)(seed.value.name)}.value)`;
+        if (nodes.isNode(seed.value, "accountValueNode")) {
+          return fragment`${seed.name}: ${expectAddress}(accounts.${nodes.camelCase(seed.value.name)}.value)`;
         }
-        if ((0, import_nodes16.isNode)(seed.value, "argumentValueNode")) {
-          return fragment`${seed.name}: ${expectSome}(args.${(0, import_nodes16.camelCase)(seed.value.name)})`;
+        if (nodes.isNode(seed.value, "argumentValueNode")) {
+          return fragment`${seed.name}: ${expectSome}(args.${nodes.camelCase(seed.value.name)})`;
         }
-        return (0, import_visitors_core13.pipe)(
-          (0, import_visitors_core13.visit)(seed.value, typeManifestVisitor).value,
-          (f) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => `${seed.name}: ${c}`)
+        return visitorsCore.pipe(
+          visitorsCore.visit(seed.value, typeManifestVisitor).value,
+          (f) => renderersCore.mapFragmentContent(f, (c) => `${seed.name}: ${c}`)
         );
       });
-      const pdaSeedsFragment = (0, import_visitors_core13.pipe)(
+      const pdaSeedsFragment = visitorsCore.pipe(
         mergeFragments(pdaSeeds, (renders) => renders.join(", ")),
-        (f) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => `{ ${c} }`)
+        (f) => renderersCore.mapFragmentContent(f, (c) => `{ ${c} }`)
       );
       if (pdaSeeds.length > 0) {
         pdaArgs.push(pdaSeedsFragment);
@@ -1228,14 +1314,14 @@ function getInstructionInputDefaultFragment(scope) {
       return fragment``;
     case "accountBumpValueNode":
       return defaultFragment(
-        fragment`${expectProgramDerivedAddress}(accounts.${(0, import_nodes16.camelCase)(defaultValue.name)}.value)[1]`
+        fragment`${expectProgramDerivedAddress}(accounts.${nodes.camelCase(defaultValue.name)}.value)[1]`
       );
     case "argumentValueNode":
-      return defaultFragment(fragment`${expectSome}(args.${(0, import_nodes16.camelCase)(defaultValue.name)})`);
+      return defaultFragment(fragment`${expectSome}(args.${nodes.camelCase(defaultValue.name)})`);
     case "resolverValueNode":
       const resolverFunction = use(nameApi.resolverFunction(defaultValue.name), getImportFrom(defaultValue));
       const resolverAwait = useAsync && asyncResolvers.includes(defaultValue.name) ? "await " : "";
-      return (0, import_visitors_core13.pipe)(
+      return visitorsCore.pipe(
         defaultFragment(fragment`${resolverAwait}${resolverFunction}(resolverScope)`),
         (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
       );
@@ -1260,21 +1346,21 @@ function getInstructionInputDefaultFragment(scope) {
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if ((0, import_nodes16.isNode)(defaultValue.condition, "resolverValueNode")) {
+      if (nodes.isNode(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
-        const module2 = getImportFrom(defaultValue.condition);
-        conditionalFragment = (0, import_visitors_core13.pipe)(
+        const module = getImportFrom(defaultValue.condition);
+        conditionalFragment = visitorsCore.pipe(
           conditionalFragment,
-          (f) => addFragmentImports(f, module2, [conditionalResolverFunction]),
+          (f) => addFragmentImports(f, module, [conditionalResolverFunction]),
           (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
         );
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
-        const comparedInputName = (0, import_nodes16.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes16.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes16.camelCase)(defaultValue.condition.name)}`;
+        const comparedInputName = nodes.isNode(defaultValue.condition, "accountValueNode") ? `accounts.${nodes.camelCase(defaultValue.condition.name)}.value` : `args.${nodes.camelCase(defaultValue.condition.name)}`;
         if (defaultValue.value) {
-          const comparedValue = (0, import_visitors_core13.visit)(defaultValue.value, typeManifestVisitor).value;
+          const comparedValue = visitorsCore.visit(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
           const operator = negatedCondition ? "!==" : "===";
           condition = `${comparedInputName} ${operator} ${comparedValue.content}`;
@@ -1283,7 +1369,7 @@ function getInstructionInputDefaultFragment(scope) {
         }
       }
       if (ifTrueRenderer && ifFalseRenderer) {
-        return (0, import_renderers_core5.setFragmentContent)(
+        return renderersCore.setFragmentContent(
           conditionalFragment,
           `if (${condition}) {
 ${ifTrueRenderer.content}
@@ -1292,14 +1378,14 @@ ${ifFalseRenderer.content}
 }`
         );
       }
-      return (0, import_renderers_core5.setFragmentContent)(
+      return renderersCore.setFragmentContent(
         conditionalFragment,
         `if (${condition}) {
 ${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
 }`
       );
     default:
-      const valueManifest = (0, import_visitors_core13.visit)(defaultValue, typeManifestVisitor).value;
+      const valueManifest = visitorsCore.visit(defaultValue, typeManifestVisitor).value;
       return defaultFragment(valueManifest);
   }
 }
@@ -1314,19 +1400,19 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
-  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(scope.instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
       input,
-      optionalAccountStrategy: (0, import_nodes17.parseOptionalAccountStrategy)(instructionNode.optionalAccountStrategy)
+      optionalAccountStrategy: nodes.parseOptionalAccountStrategy(instructionNode.optionalAccountStrategy)
     });
     if (!inputFragment.content) return [];
-    const camelName = (0, import_nodes17.camelCase)(input.name);
+    const camelName = nodes.camelCase(input.name);
     return [
-      (0, import_renderers_core6.mapFragmentContent)(
+      renderersCore.mapFragmentContent(
         inputFragment,
-        (c) => (0, import_nodes17.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (c) => nodes.isNode(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${c}
 }` : `if (!accounts.${camelName}.value) {
 ${c}
@@ -1339,19 +1425,14 @@ ${c}
   }
   return mergeFragments([fragment`// Resolve default values.`, ...resolvedInputFragments], (c) => c.join("\n"));
 }
-
-// src/fragments/instructionInputType.ts
-var import_nodes18 = require("@codama/nodes");
-var import_renderers_core7 = require("@codama/renderers-core");
-var import_visitors_core15 = require("@codama/visitors-core");
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
   let accountTypeParams = "";
   if (instructionNode.accounts.length > 0) {
-    accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes18.pascalCase)(account.name)} extends string = string`).join(", ");
+    accountTypeParams = instructionNode.accounts.map((account) => `TAccount${nodes.pascalCase(account.name)} extends string = string`).join(", ");
     accountTypeParams = `<${accountTypeParams}>`;
   }
   const typeBodyFragment = mergeFragments(
@@ -1369,20 +1450,20 @@ function getInstructionInputTypeFragment(scope) {
 }
 function getAccountsFragment(scope) {
   const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
-  const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !(0, import_nodes18.isNode)(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !nodes.isNode(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const docs = getDocblockFragment(account.docs ?? [], true);
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return fragment`${docs}${(0, import_nodes18.camelCase)(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
+    return fragment`${docs}${nodes.camelCase(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
   });
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getAccountTypeFragment2(account) {
-  const typeParam = `TAccount${(0, import_nodes18.pascalCase)(account.name)}`;
+  const typeParam = `TAccount${nodes.pascalCase(account.name)}`;
   const address = use("type Address", "solanaAddresses");
   const signer = use("type TransactionSigner", "solanaSigners");
   const pda = use("type ProgramDerivedAddress", "solanaAddresses");
@@ -1394,15 +1475,15 @@ function getAccountTypeFragment2(account) {
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
       void 0,
-      (0, import_visitors_core15.pipe)(
+      visitorsCore.pipe(
         fragment`${nameApi.dataArgsType(customData.importAs)}`,
         (f) => mergeFragmentImports(f, [scope.dataArgsManifest.looseType.imports]),
-        (f) => (0, import_renderers_core7.mapFragmentContent)(f, (c) => `${c} & `)
+        (f) => renderersCore.mapFragmentContent(f, (c) => `${c} & `)
       )
     ];
   }
@@ -1416,7 +1497,7 @@ function getDataArgumentsFragments(scope) {
 }
 function getExtraArgumentsFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
@@ -1428,18 +1509,18 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => (0, import_nodes18.isNode)(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => nodes.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 fragment`${(0, import_nodes18.camelCase)(renamedName)}${optionalSign}: ${argsType}["${(0, import_nodes18.camelCase)(arg.name)}"];`;
+  return fragment`${nodes.camelCase(renamedName)}${optionalSign}: ${argsType}["${nodes.camelCase(arg.name)}"];`;
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if ((0, import_nodes18.isNode)(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if (nodes.isNode(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
-    const allArguments = (0, import_nodes18.getAllInstructionArguments)(instructionNode);
+    const allArguments = nodes.getAllInstructionArguments(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
     if (argumentExists) return [];
     const isSigner = remainingAccountsNode.isSigner ?? false;
@@ -1450,20 +1531,16 @@ function getRemainingAccountsFragment(instructionNode) {
       if (isSigner === "either") return fragment`${signerFragment} | ${addressFragment}`;
       return isSigner ? signerFragment : addressFragment;
     })();
-    return fragment`${(0, import_nodes18.camelCase)(name)}${optionalSign}: Array<${typeFragment}>;`;
+    return fragment`${nodes.camelCase(name)}${optionalSign}: Array<${typeFragment}>;`;
   });
   if (fragments.length === 0) return;
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
-
-// src/fragments/instructionRemainingAccounts.ts
-var import_nodes19 = require("@codama/nodes");
-var import_visitors_core16 = require("@codama/visitors-core");
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = (0, import_visitors_core16.getLastNodeFromPath)(scope.instructionPath);
+  const { remainingAccounts } = visitorsCore.getLastNodeFromPath(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((a) => getRemainingAccountsFragment2(a, scope));
   if (fragments.length === 0) return;
-  return (0, import_visitors_core16.pipe)(
+  return visitorsCore.pipe(
     mergeFragments(
       fragments,
       (c) => `// Remaining accounts.
@@ -1474,10 +1551,10 @@ const remainingAccounts: AccountMeta[] = ${c.length === 1 ? c[0] : `[...${c.join
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if ((0, import_nodes19.isNode)(remainingAccounts.value, "argumentValueNode")) {
+    if (nodes.isNode(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if ((0, import_nodes19.isNode)(remainingAccounts.value, "resolverValueNode")) {
+    if (nodes.isNode(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1486,9 +1563,9 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(scope.instructionPath);
-  (0, import_nodes19.assertIsNode)(remainingAccounts.value, "argumentValueNode");
-  const argumentName = (0, import_nodes19.camelCase)(remainingAccounts.value.name);
+  const instructionNode = visitorsCore.getLastNodeFromPath(scope.instructionPath);
+  nodes.assertIsNode(remainingAccounts.value, "argumentValueNode");
+  const argumentName = nodes.camelCase(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1497,7 +1574,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const signerRole = isWritable ? fragment`${accountRole}.WRITABLE_SIGNER` : fragment`${accountRole}.READONLY_SIGNER`;
   const role = isSigner === true ? signerRole : nonSignerRole;
   const argumentArray = isOptional ? `(args.${argumentName} ?? [])` : `args.${argumentName}`;
-  const allArguments = (0, import_nodes19.getAllInstructionArguments)(instructionNode);
+  const allArguments = nodes.getAllInstructionArguments(instructionNode);
   const argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
     return fragment`${argumentArray}.map((address) => ({ address, role: ${role} }))`;
@@ -1508,7 +1585,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   return fragment`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`;
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
-  (0, import_nodes19.assertIsNode)(remainingAccounts.value, "resolverValueNode");
+  nodes.assertIsNode(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1516,7 +1593,7 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
     scope.nameApi.resolverFunction(remainingAccounts.value.name),
     scope.getImportFrom(remainingAccounts.value)
   );
-  return (0, import_visitors_core16.pipe)(
+  return visitorsCore.pipe(
     fragment`${awaitKeyword}${functionName}(resolverScope)`,
     (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
   );
@@ -1525,13 +1602,13 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
 // src/fragments/instructionFunction.ts
 function getInstructionFunctionFragment(scope) {
   const { useAsync, instructionPath, resolvedInputs, renamedArgs, asyncResolvers, nameApi, customInstructionData } = scope;
-  const instructionNode = (0, import_visitors_core17.getLastNodeFromPath)(instructionPath);
-  const programNode = (0, import_visitors_core17.findProgramNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) return;
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const instructionDependencies = getInstructionDependencies(instructionNode, asyncResolvers, useAsync);
-  const argDependencies = instructionDependencies.filter((0, import_nodes20.isNodeFilter)("argumentValueNode")).map((node) => node.name);
+  const argDependencies = instructionDependencies.filter(nodes.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);
@@ -1544,7 +1621,7 @@ function getInstructionFunctionFragment(scope) {
   const hasExtraArgs = (instructionNode.extraArguments ?? []).filter(
     (field) => argIsNotOmitted(field) && (argIsDependent(field) || argHasDefaultValue(field))
   ).length > 0;
-  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => (0, import_nodes20.isNode)(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => nodes.isNode(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const programAddressConstant = use(nameApi.programAddressConstant(programNode.name), "generatedPrograms");
@@ -1563,7 +1640,7 @@ function getInstructionFunctionFragment(scope) {
   const typeParams = getTypeParamsFragment(instructionNode, programAddressConstant);
   const returnType = getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync);
   const inputType = getInstructionInputTypeFragment(scope);
-  const inputArg = (0, import_renderers_core8.mapFragmentContent)(getInputTypeCallFragment(scope), (c) => hasInput ? `input: ${c}, ` : "");
+  const inputArg = renderersCore.mapFragmentContent(getInputTypeCallFragment(scope), (c) => hasInput ? `input: ${c}, ` : "");
   const functionBody = mergeFragments(
     [
       getProgramAddressInitializationFragment(programAddressConstant),
@@ -1595,7 +1672,7 @@ function getAccountsInitializationFragment(instructionNode) {
   if (instructionNode.accounts.length === 0) return;
   const accounts = mergeFragments(
     instructionNode.accounts.map((account) => {
-      const name = (0, import_nodes20.camelCase)(account.name);
+      const name = nodes.camelCase(account.name);
       const isWritable = account.isWritable ? "true" : "false";
       return fragment`${name}: { value: input.${name} ?? null, isWritable: ${isWritable} }`;
     }),
@@ -1630,7 +1707,7 @@ function getReturnStatementFragment(scope) {
   const hasLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted" && instructionNode.accounts.some((account) => account.isOptional);
   const getAccountMeta = hasAccounts ? fragment`const getAccountMeta = ${use("getAccountMetaFactory", "shared")}(programAddress, '${optionalAccountStrategy}');` : "";
   const accountItems = [
-    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${(0, import_nodes20.camelCase)(account.name)})`),
+    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${nodes.camelCase(account.name)})`),
     ...hasRemainingAccounts ? ["...remainingAccounts"] : []
   ].join(", ");
   let accounts;
@@ -1651,14 +1728,14 @@ function getReturnStatementFragment(scope) {
   } else if (hasData) {
     data = fragment`data: ${encoderFunctionFragment}.encode({})`;
   }
-  const instructionAttributes = (0, import_visitors_core17.pipe)(
+  const instructionAttributes = visitorsCore.pipe(
     [accounts, hasByteDeltas ? fragment`byteDelta` : void 0, data, fragment`programAddress`],
     (fs) => mergeFragments(fs, (cs) => cs.join(", "))
   );
   return fragment`${getAccountMeta}\nreturn Object.freeze({ ${instructionAttributes} } as ${scope.syncReturnTypeFragment});`;
 }
 function getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync) {
-  return (0, import_visitors_core17.pipe)(
+  return visitorsCore.pipe(
     instructionTypeFragment,
     (f) => hasByteDeltas ? fragment`${f} & ${use("type InstructionWithByteDelta", "shared")}` : f,
     (f) => useAsync ? fragment`Promise<${f}>` : f
@@ -1667,7 +1744,7 @@ function getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync)
 function getTypeParamsFragment(instructionNode, programAddressConstant) {
   return mergeFragments(
     [
-      ...instructionNode.accounts.map((account) => fragment`TAccount${(0, import_nodes20.pascalCase)(account.name)} extends string`),
+      ...instructionNode.accounts.map((account) => fragment`TAccount${nodes.pascalCase(account.name)} extends string`),
       fragment`TProgramAddress extends ${use("type Address", "solanaAddresses")} = typeof ${programAddressConstant}`
     ],
     (cs) => `<${cs.join(", ")}>`
@@ -1675,48 +1752,39 @@ function getTypeParamsFragment(instructionNode, programAddressConstant) {
 }
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core17.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = fragment`TAccount${(0, import_nodes20.pascalCase)(account.name)}`;
-    const camelName = (0, import_nodes20.camelCase)(account.name);
+    const typeParam = fragment`TAccount${nodes.pascalCase(account.name)}`;
+    const camelName = nodes.camelCase(account.name);
     if (account.isSigner === "either") {
       const signerRole = use(
         account.isWritable ? "type WritableSignerAccount" : "type ReadonlySignerAccount",
         "solanaInstructions"
       );
-      return (0, import_visitors_core17.pipe)(
+      return visitorsCore.pipe(
         fragment`typeof input["${camelName}"] extends TransactionSigner<${typeParam}> ? ${signerRole}<${typeParam}> & AccountSignerMeta<${typeParam}> : ${typeParam}`,
         (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta", "type TransactionSigner"])
       );
     }
     return typeParam;
   });
-  return (0, import_visitors_core17.pipe)(
+  return visitorsCore.pipe(
     mergeFragments([fragment`TProgramAddress`, ...accountTypeParamsFragments], (c) => c.join(", ")),
-    (f) => (0, import_renderers_core8.mapFragmentContent)(f, (c) => `${instructionTypeName}<${c}>`)
+    (f) => renderersCore.mapFragmentContent(f, (c) => `${instructionTypeName}<${c}>`)
   );
 }
 function getInputTypeCallFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core17.getLastNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
   const inputTypeName = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   if (instructionNode.accounts.length === 0) return fragment`${inputTypeName}`;
-  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes20.pascalCase)(account.name)}`).join(", ");
+  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${nodes.pascalCase(account.name)}`).join(", ");
   return fragment`${inputTypeName}<${accountTypeParams}>`;
 }
-
-// src/fragments/instructionPage.ts
-var import_errors2 = require("@codama/errors");
-var import_nodes23 = require("@codama/nodes");
-var import_visitors_core20 = require("@codama/visitors-core");
-
-// src/fragments/instructionParseFunction.ts
-var import_nodes21 = require("@codama/nodes");
-var import_visitors_core18 = require("@codama/visitors-core");
 function getInstructionParseFunctionFragment(scope) {
-  const instructionNode = (0, import_visitors_core18.getLastNodeFromPath)(scope.instructionPath);
-  const programNode = (0, import_visitors_core18.findProgramNodeFromPath)(scope.instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(scope.instructionPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(scope.instructionPath);
   const programAddressConstant = use(scope.nameApi.programAddressConstant(programNode.name), "generatedPrograms");
   const childScope = { ...scope, instructionNode, programAddressConstant };
   return mergeFragments([getTypeFragment2(childScope), getFunctionFragment(childScope)], (cs) => cs.join("\n\n"));
@@ -1737,7 +1805,7 @@ function getTypeFragment2(scope) {
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map((account, i) => {
       const docs = getDocblockFragment(account.docs ?? [], true);
-      const name = (0, import_nodes21.camelCase)(account.name);
+      const name = nodes.camelCase(account.name);
       return fragment`${docs}${name}${account.isOptional ? "?" : ""}: TAccountMetas[${i}]${account.isOptional ? " | undefined" : ""};`;
     }),
     (cs) => hasAccounts ? `
@@ -1771,7 +1839,7 @@ function getFunctionFragment(scope) {
     [
       fragment`${use("type Instruction", "solanaInstructions")}<TProgram>`,
       hasAccounts ? fragment`${use("type InstructionWithAccounts", "solanaInstructions")}<TAccountMetas>` : void 0,
-      hasData ? (0, import_visitors_core18.pipe)(
+      hasData ? visitorsCore.pipe(
         fragment`InstructionWithData<ReadonlyUint8Array>`,
         (f) => addFragmentImports(f, "solanaInstructions", ["type InstructionWithData"]),
         (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
@@ -1809,7 +1877,7 @@ const getNextOptionalAccount = () => {
   }
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map(
-      (account) => account.isOptional ? fragment`${(0, import_nodes21.camelCase)(account.name)}: getNextOptionalAccount()` : fragment`${(0, import_nodes21.camelCase)(account.name)}: getNextAccount()`
+      (account) => account.isOptional ? fragment`${nodes.camelCase(account.name)}: getNextOptionalAccount()` : fragment`${nodes.camelCase(account.name)}: getNextAccount()`
     ),
     (cs) => hasAccounts ? `, accounts: { ${cs.join(", ")} }` : ""
   );
@@ -1819,15 +1887,10 @@ const getNextOptionalAccount = () => {
   return { programAddress: instruction.programAddress${accounts}${data} };
 }`;
 }
-
-// src/fragments/instructionType.ts
-var import_nodes22 = require("@codama/nodes");
-var import_renderers_core9 = require("@codama/renderers-core");
-var import_visitors_core19 = require("@codama/visitors-core");
 function getInstructionTypeFragment2(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = (0, import_visitors_core19.getLastNodeFromPath)(instructionPath);
-  const programNode = (0, import_visitors_core19.findProgramNodeFromPath)(instructionPath);
+  const instructionNode = visitorsCore.getLastNodeFromPath(instructionPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
@@ -1837,7 +1900,6 @@ function getInstructionTypeFragment2(scope) {
     instructionNode.accounts.map(
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
-        allowAccountMeta: true,
         instructionAccountPath: [...instructionPath, account]
       })
     ),
@@ -1847,8 +1909,8 @@ function getInstructionTypeFragment2(scope) {
   const usesLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted";
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
-      (account) => (0, import_renderers_core9.mapFragmentContent)(getInstructionAccountMetaFragment(account), (c) => {
-        const typeParam = `TAccount${(0, import_nodes22.pascalCase)(account.name)}`;
+      (account) => renderersCore.mapFragmentContent(getInstructionAccountMetaFragment(account), (c) => {
+        const typeParam = `TAccount${nodes.pascalCase(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
         const type = `${typeParam} extends string ? ${c} : ${typeParam}`;
         if (!isLegacyOptional) return type;
@@ -1865,17 +1927,17 @@ ${use("type Instruction", "solanaInstructions")}<TProgram>${data}${accounts};`;
 
 // src/fragments/instructionPage.ts
 function getInstructionPageFragment(scope) {
-  const node = (0, import_visitors_core20.getLastNodeFromPath)(scope.instructionPath);
-  if (!(0, import_visitors_core20.findProgramNodeFromPath)(scope.instructionPath)) {
+  const node = visitorsCore.getLastNodeFromPath(scope.instructionPath);
+  if (!visitorsCore.findProgramNodeFromPath(scope.instructionPath)) {
     throw new Error("Instruction must be visited inside a program.");
   }
   const childScope = {
     ...scope,
-    dataArgsManifest: (0, import_visitors_core20.visit)(node, scope.typeManifestVisitor),
-    extraArgsManifest: (0, import_visitors_core20.visit)(
-      (0, import_nodes23.definedTypeNode)({
+    dataArgsManifest: visitorsCore.visit(node, scope.typeManifestVisitor),
+    extraArgsManifest: visitorsCore.visit(
+      nodes.definedTypeNode({
         name: scope.nameApi.instructionExtraType(node.name),
-        type: (0, import_nodes23.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
+        type: nodes.structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? [])
       }),
       scope.typeManifestVisitor
     ),
@@ -1911,17 +1973,13 @@ 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();
-  (0, import_errors2.logWarn)(
+  errors.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) => [(0, import_nodes23.camelCase)(name), (0, import_nodes23.camelCase)(`${name}Arg`)]));
+  return new Map(duplicates.map((name) => [nodes.camelCase(name), nodes.camelCase(`${name}Arg`)]));
 }
-
-// src/fragments/pdaFunction.ts
-var import_nodes24 = require("@codama/nodes");
-var import_visitors_core21 = require("@codama/visitors-core");
 function getPdaFunctionFragment(scope) {
-  const pdaNode = (0, import_visitors_core21.getLastNodeFromPath)(scope.pdaPath);
+  const pdaNode = visitorsCore.getLastNodeFromPath(scope.pdaPath);
   const seeds = parsePdaSeedNodes(pdaNode.seeds, scope);
   return mergeFragments(
     [getSeedInputTypeFragment(seeds, scope), getFunctionFragment2(seeds, scope)],
@@ -1929,9 +1987,9 @@ function getPdaFunctionFragment(scope) {
   );
 }
 function getSeedInputTypeFragment(seeds, scope) {
-  const variableSeeds = seeds.filter((0, import_nodes24.isNodeFilter)("variablePdaSeedNode"));
+  const variableSeeds = seeds.filter(nodes.isNodeFilter("variablePdaSeedNode"));
   if (variableSeeds.length === 0) return;
-  const pdaNode = (0, import_visitors_core21.getLastNodeFromPath)(scope.pdaPath);
+  const pdaNode = visitorsCore.getLastNodeFromPath(scope.pdaPath);
   const seedTypeName = scope.nameApi.pdaSeedsType(pdaNode.name);
   const seedAttributes = mergeFragments(
     variableSeeds.map((seed) => seed.inputAttribute),
@@ -1940,15 +1998,15 @@ function getSeedInputTypeFragment(seeds, scope) {
   return fragment`export type ${seedTypeName} = {\n${seedAttributes}\n};`;
 }
 function getFunctionFragment2(seeds, scope) {
-  const pdaNode = (0, import_visitors_core21.getLastNodeFromPath)(scope.pdaPath);
-  const programNode = (0, import_visitors_core21.findProgramNodeFromPath)(scope.pdaPath);
+  const pdaNode = visitorsCore.getLastNodeFromPath(scope.pdaPath);
+  const programNode = visitorsCore.findProgramNodeFromPath(scope.pdaPath);
   const addressType = use("type Address", "solanaAddresses");
   const pdaType = use("type ProgramDerivedAddress", "solanaAddresses");
   const getPdaFunction = use("getProgramDerivedAddress", "solanaAddresses");
   const seedTypeName = scope.nameApi.pdaSeedsType(pdaNode.name);
   const findPdaFunction = scope.nameApi.pdaFindFunction(pdaNode.name);
   const docs = getDocblockFragment(pdaNode.docs ?? [], true);
-  const hasVariableSeeds = seeds.filter((0, import_nodes24.isNodeFilter)("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = seeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length > 0;
   const seedArgument = hasVariableSeeds ? `seeds: ${seedTypeName}, ` : "";
   const programAddress = pdaNode.programId ?? programNode.publicKey;
   const encodedSeeds = mergeFragments(
@@ -1962,39 +2020,31 @@ function getFunctionFragment2(seeds, scope) {
 }
 function parsePdaSeedNodes(seeds, scope) {
   return seeds.map((seed) => {
-    if ((0, import_nodes24.isNode)(seed, "variablePdaSeedNode")) {
-      const name = (0, import_nodes24.camelCase)(seed.name);
+    if (nodes.isNode(seed, "variablePdaSeedNode")) {
+      const name = nodes.camelCase(seed.name);
       const docs = getDocblockFragment(seed.docs ?? [], true);
-      const { encoder: encoder2, looseType } = (0, import_visitors_core21.visit)(seed.type, scope.typeManifestVisitor);
+      const { encoder: encoder2, looseType } = visitorsCore.visit(seed.type, scope.typeManifestVisitor);
       return {
         ...seed,
         encodedValue: fragment`${encoder2}.encode(seeds.${name})`,
         inputAttribute: fragment`${docs}${name}: ${looseType};`
       };
     }
-    if ((0, import_nodes24.isNode)(seed.value, "programIdValueNode")) {
+    if (nodes.isNode(seed.value, "programIdValueNode")) {
       const addressEncoder = use("getAddressEncoder", "solanaAddresses");
       return { ...seed, encodedValue: fragment`${addressEncoder}().encode(programAddress)` };
     }
-    const { encoder } = (0, import_visitors_core21.visit)(seed.type, scope.typeManifestVisitor);
-    const { value } = (0, import_visitors_core21.visit)(seed.value, scope.typeManifestVisitor);
+    const { encoder } = visitorsCore.visit(seed.type, scope.typeManifestVisitor);
+    const { value } = visitorsCore.visit(seed.value, scope.typeManifestVisitor);
     return { ...seed, encodedValue: fragment`${encoder}.encode(${value})` };
   });
 }
-
-// src/fragments/pdaPage.ts
-var import_visitors_core22 = require("@codama/visitors-core");
 function getPdaPageFragment(scope) {
-  if (!(0, import_visitors_core22.findProgramNodeFromPath)(scope.pdaPath)) {
+  if (!visitorsCore.findProgramNodeFromPath(scope.pdaPath)) {
     throw new Error("PDA must be visited inside a program.");
   }
   return getPdaFunctionFragment(scope);
 }
-
-// src/fragments/programAccounts.ts
-var import_nodes25 = require("@codama/nodes");
-var import_renderers_core10 = require("@codama/renderers-core");
-var import_visitors_core23 = require("@codama/visitors-core");
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return;
   return mergeFragments(
@@ -2019,7 +2069,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
   if (!hasAccountDiscriminators) return;
   const programAccountsEnum = nameApi.programAccountsEnum(programNode.name);
   const programAccountsIdentifierFunction = nameApi.programAccountsIdentifierFunction(programNode.name);
-  return (0, import_visitors_core23.pipe)(
+  return visitorsCore.pipe(
     mergeFragments(
       accountsWithDiscriminators.map((account) => {
         const variant = nameApi.programAccountsEnumVariant(account.name);
@@ -2028,12 +2078,12 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
           dataName: "data",
           discriminators: account.discriminators ?? [],
           ifTrue: `return ${programAccountsEnum}.${variant};`,
-          struct: (0, import_nodes25.resolveNestedTypeNode)(account.data)
+          struct: nodes.resolveNestedTypeNode(account.data)
         });
       }),
       (c) => c.join("\n")
     ),
-    (f) => (0, import_renderers_core10.mapFragmentContent)(
+    (f) => renderersCore.mapFragmentContent(
       f,
       (discriminators) => `export function ${programAccountsIdentifierFunction}(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programAccountsEnum} {
 const data = 'data' in account ? account.data : account;
@@ -2044,25 +2094,17 @@ throw new Error("The provided account could not be identified as a ${programNode
     (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
   );
 }
-
-// src/fragments/programConstant.ts
-var import_visitors_core24 = require("@codama/visitors-core");
 function getProgramConstantFragment(scope) {
   const { programNode, nameApi } = scope;
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  return (0, import_visitors_core24.pipe)(
+  return visitorsCore.pipe(
     fragment`export const ${programAddressConstant} = '${programNode.publicKey}' as Address<'${programNode.publicKey}'>;`,
     (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
   );
 }
-
-// src/fragments/programInstructions.ts
-var import_nodes26 = require("@codama/nodes");
-var import_renderers_core11 = require("@codama/renderers-core");
-var import_visitors_core25 = require("@codama/visitors-core");
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return;
-  const allInstructions = (0, import_nodes26.getAllInstructionsWithSubs)(scope.programNode, {
+  const allInstructions = nodes.getAllInstructionsWithSubs(scope.programNode, {
     leavesOnly: !scope.renderParentInstructions,
     subInstructionsFirst: true
   });
@@ -2101,14 +2143,14 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: (0, import_nodes26.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
+        struct: nodes.structTypeNodeFromInstructionArgumentNodes(instruction.arguments)
       });
     }),
     (c) => c.join("\n")
   );
-  return (0, import_visitors_core25.pipe)(
+  return visitorsCore.pipe(
     discriminatorsFragment,
-    (f) => (0, import_renderers_core11.mapFragmentContent)(
+    (f) => renderersCore.mapFragmentContent(
       f,
       (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
 const data = 'data' in instruction ? instruction.data : instruction;
@@ -2168,9 +2210,6 @@ function getRootIndexPageFragment(scope) {
     (cs) => cs.join("\n")
   );
 }
-
-// src/fragments/sharedPage.ts
-var import_visitors_core26 = require("@codama/visitors-core");
 function getSharedPageFragment() {
   const sharedPage = fragment`/**
  * Asserts that the given value is not null or undefined.
@@ -2271,7 +2310,7 @@ export function getAccountMetaFactory(
 export function isTransactionSigner<TAddress extends string = string>(value: Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress>): value is TransactionSigner<TAddress> {
   return !!value && typeof value === 'object' && 'address' in value && kitIsTransactionSigner(value);
 }`;
-  return (0, import_visitors_core26.pipe)(
+  return visitorsCore.pipe(
     sharedPage,
     (f) => addFragmentImports(f, "solanaAddresses", [
       "type Address",
@@ -2286,12 +2325,9 @@ export function isTransactionSigner<TAddress extends string = string>(value: Add
     ])
   );
 }
-
-// src/fragments/typeDiscriminatedUnionHelpers.ts
-var import_nodes27 = require("@codama/nodes");
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = (0, import_nodes27.isNode)(typeNode, "enumTypeNode") && (0, import_nodes27.isDataEnum)(typeNode);
+  const isDiscriminatedUnion = nodes.isNode(typeNode, "enumTypeNode") && nodes.isDataEnum(typeNode);
   if (!isDiscriminatedUnion) return;
   const functionName = nameApi.discriminatedUnionFunction(name);
   const isDiscriminatedUnionFunctionName = nameApi.isDiscriminatedUnionFunction(name);
@@ -2303,10 +2339,10 @@ function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const variantSignatures = mergeFragments(
     typeNode.variants.map((variant) => {
       const variantName = nameApi.discriminatedUnionVariant(variant.name);
-      if ((0, import_nodes27.isNode)(variant, "enumStructVariantTypeNode")) {
+      if (nodes.isNode(variant, "enumStructVariantTypeNode")) {
         return fragment`export function ${functionName}(kind: '${variantName}', data: ${getVariantContentType}<${looseName}, '${discriminatorName}', '${variantName}'>): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
       }
-      if ((0, import_nodes27.isNode)(variant, "enumTupleVariantTypeNode")) {
+      if (nodes.isNode(variant, "enumTupleVariantTypeNode")) {
         return fragment`export function ${functionName}(kind: '${variantName}', data: ${getVariantContentType}<${looseName}, '${discriminatorName}', '${variantName}'>['fields']): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
       }
       return fragment`export function ${functionName}(kind: '${variantName}'): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
@@ -2324,13 +2360,10 @@ export function ${isDiscriminatedUnionFunctionName}<K extends ${strictName}['${d
 };
 `;
 }
-
-// src/fragments/typePage.ts
-var import_visitors_core27 = require("@codama/visitors-core");
 function getTypePageFragment(scope) {
   const node = scope.node;
-  const manifest = (0, import_visitors_core27.visit)(node, scope.typeManifestVisitor);
-  return (0, import_visitors_core27.pipe)(
+  const manifest = visitorsCore.visit(node, scope.typeManifestVisitor);
+  return visitorsCore.pipe(
     mergeFragments(
       [
         getTypeWithCodecFragment({ ...scope, manifest, name: node.name, node: node.type, typeDocs: node.docs }),
@@ -2347,42 +2380,37 @@ function getTypePageFragment(scope) {
     ])
   );
 }
-
-// src/visitors/getTypeManifestVisitor.ts
-var import_nodes28 = require("@codama/nodes");
-var import_renderers_core12 = require("@codama/renderers-core");
-var import_visitors_core28 = require("@codama/visitors-core");
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
-  const stack = input.stack ?? new import_visitors_core28.NodeStack();
+  const stack = input.stack ?? new visitorsCore.NodeStack();
   let parentName = null;
-  return (0, import_visitors_core28.pipe)(
-    (0, import_visitors_core28.staticVisitor)(() => typeManifest(), {
+  return visitorsCore.pipe(
+    visitorsCore.staticVisitor(() => typeManifest(), {
       keys: [
-        ...import_nodes28.REGISTERED_TYPE_NODE_KINDS,
-        ...import_nodes28.REGISTERED_VALUE_NODE_KINDS,
+        ...nodes.REGISTERED_TYPE_NODE_KINDS,
+        ...nodes.REGISTERED_VALUE_NODE_KINDS,
         "definedTypeLinkNode",
         "definedTypeNode",
         "accountNode",
         "instructionNode"
       ]
     }),
-    (visitor) => (0, import_visitors_core28.extendVisitor)(visitor, {
+    (visitor) => visitorsCore.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 ? (0, import_visitors_core28.visit)(link, self) : (0, import_visitors_core28.visit)(account.data, self);
+        const manifest = link ? visitorsCore.visit(link, self) : visitorsCore.visit(account.data, self);
         parentName = null;
         return manifest;
       },
       visitAmountType(amountType, { self }) {
-        return (0, import_visitors_core28.visit)(amountType.number, self);
+        return visitorsCore.visit(amountType.number, self);
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = (0, import_visitors_core28.visit)(arrayType.item, self);
+        const childManifest = visitorsCore.visit(arrayType.item, self);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
         const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
         const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
@@ -2396,16 +2424,16 @@ function getTypeManifestVisitor(input) {
       },
       visitArrayValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => (0, import_visitors_core28.visit)(v, self)),
+          node.items.map((v) => visitorsCore.visit(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitBooleanType(booleanType, { self }) {
         let sizeEncoder = fragment``;
         let sizeDecoder = fragment``;
-        const resolvedSize = (0, import_nodes28.resolveNestedTypeNode)(booleanType.size);
+        const resolvedSize = nodes.resolveNestedTypeNode(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
-          const size = (0, import_visitors_core28.visit)(booleanType.size, self);
+          const size = visitorsCore.visit(booleanType.size, self);
           sizeEncoder = fragment`{ size: ${size.encoder} }`;
           sizeDecoder = fragment`{ size: ${size.decoder} }`;
         }
@@ -2433,22 +2461,22 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ value: fragment`new Uint8Array([${Array.from(bytes).join(", ")}])` });
       },
       visitConstantValue(node, { self }) {
-        if ((0, import_nodes28.isNode)(node.type, "bytesTypeNode") && (0, import_nodes28.isNode)(node.value, "bytesValueNode")) {
-          return (0, import_visitors_core28.visit)(node.value, self);
+        if (nodes.isNode(node.type, "bytesTypeNode") && nodes.isNode(node.value, "bytesValueNode")) {
+          return visitorsCore.visit(node.value, self);
         }
         return typeManifest({
-          value: fragment`${(0, import_visitors_core28.visit)(node.type, self).encoder}.encode(${(0, import_visitors_core28.visit)(node.value, self).value})`
+          value: fragment`${visitorsCore.visit(node.type, self).encoder}.encode(${visitorsCore.visit(node.value, self).value})`
         });
       },
       visitDateTimeType(dateTimeType, { self }) {
-        return (0, import_visitors_core28.visit)(dateTimeType.number, self);
+        return visitorsCore.visit(dateTimeType.number, self);
       },
       visitDefinedType(definedType, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(definedType.name),
           strict: nameApi.dataType(definedType.name)
         };
-        const manifest = (0, import_visitors_core28.visit)(definedType.type, self);
+        const manifest = visitorsCore.visit(definedType.type, self);
         parentName = null;
         return manifest;
       },
@@ -2466,7 +2494,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes28.camelCase)(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator(nodes.camelCase(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return typeManifest({
@@ -2479,54 +2507,54 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes28.camelCase)(currentParentName?.strict ?? "")
+          nodes.camelCase(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         parentName = null;
-        const structManifest = (0, import_visitors_core28.visit)(enumStructVariantType.struct, self);
+        const structManifest = visitorsCore.visit(enumStructVariantType.struct, self);
         parentName = currentParentName;
         return typeManifest({
           ...structManifest,
           decoder: fragment`['${name}', ${structManifest.decoder}]`,
           encoder: fragment`['${name}', ${structManifest.encoder}]`,
-          looseType: (0, import_visitors_core28.pipe)(
+          looseType: visitorsCore.pipe(
             structManifest.looseType,
-            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => renderersCore.mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           ),
-          strictType: (0, import_visitors_core28.pipe)(
+          strictType: visitorsCore.pipe(
             structManifest.strictType,
-            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => renderersCore.mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           )
         });
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes28.camelCase)(currentParentName?.strict ?? "")
+          nodes.camelCase(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
-        const struct = (0, import_nodes28.structTypeNode)([
-          (0, import_nodes28.structFieldTypeNode)({
+        const struct = nodes.structTypeNode([
+          nodes.structFieldTypeNode({
             name: "fields",
             type: enumTupleVariantType.tuple
           })
         ]);
         parentName = null;
-        const structManifest = (0, import_visitors_core28.visit)(struct, self);
+        const structManifest = visitorsCore.visit(struct, self);
         parentName = currentParentName;
         return typeManifest({
           ...structManifest,
           decoder: fragment`['${name}', ${structManifest.decoder}]`,
           encoder: fragment`['${name}', ${structManifest.encoder}]`,
-          looseType: (0, import_visitors_core28.pipe)(
+          looseType: visitorsCore.pipe(
             structManifest.looseType,
-            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => renderersCore.mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           ),
-          strictType: (0, import_visitors_core28.pipe)(
+          strictType: visitorsCore.pipe(
             structManifest.strictType,
-            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => renderersCore.mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           )
         });
       },
@@ -2534,16 +2562,16 @@ function getTypeManifestVisitor(input) {
         const currentParentName = parentName;
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = (0, import_nodes28.resolveNestedTypeNode)(enumType.size);
+        const enumSize = nodes.resolveNestedTypeNode(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
-          const sizeManifest = (0, import_visitors_core28.visit)(enumType.size, self);
+          const sizeManifest = visitorsCore.visit(enumType.size, self);
           encoderOptions.push(fragment`size: ${sizeManifest.encoder}`);
           decoderOptions.push(fragment`size: ${sizeManifest.decoder}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          (0, import_nodes28.camelCase)(currentParentName?.strict ?? "")
+          nodes.camelCase(currentParentName?.strict ?? "")
         );
-        if (!(0, import_nodes28.isScalarEnum)(enumType) && discriminator !== "__kind") {
+        if (!nodes.isScalarEnum(enumType) && discriminator !== "__kind") {
           encoderOptions.push(fragment`discriminator: '${discriminator}'`);
           decoderOptions.push(fragment`discriminator: '${discriminator}'`);
         }
@@ -2555,7 +2583,7 @@ function getTypeManifestVisitor(input) {
           decoderOptions,
           (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
         );
-        if ((0, import_nodes28.isScalarEnum)(enumType)) {
+        if (nodes.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."
@@ -2571,7 +2599,7 @@ function getTypeManifestVisitor(input) {
           });
         }
         const mergedManifest = mergeTypeManifests(
-          enumType.variants.map((variant) => (0, import_visitors_core28.visit)(variant, self)),
+          enumType.variants.map((variant) => visitorsCore.visit(variant, self)),
           {
             mergeCodecs: (renders) => renders.join(", "),
             mergeTypes: (renders) => renders.join(" | ")
@@ -2589,14 +2617,14 @@ 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 && (0, import_nodes28.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes28.isScalarEnum)(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && nodes.isNode(enumNode, "enumTypeNode") ? nodes.isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
           return typeManifest({
             ...manifest,
-            value: (0, import_visitors_core28.pipe)(
+            value: visitorsCore.pipe(
               manifest.value,
-              (f) => (0, import_renderers_core12.setFragmentContent)(f, `${enumName}.${variantName2}`),
+              (f) => renderersCore.setFragmentContent(f, `${enumName}.${variantName2}`),
               (f) => addFragmentImports(f, importFrom, [enumName])
             )
           });
@@ -2605,24 +2633,24 @@ function getTypeManifestVisitor(input) {
         if (!node.value) {
           return typeManifest({
             ...manifest,
-            value: (0, import_visitors_core28.pipe)(
+            value: visitorsCore.pipe(
               manifest.value,
-              (f) => (0, import_renderers_core12.setFragmentContent)(f, `${enumFunction}('${variantName}')`),
+              (f) => renderersCore.setFragmentContent(f, `${enumFunction}('${variantName}')`),
               (f) => addFragmentImports(f, importFrom, [enumFunction])
             )
           });
         }
         return typeManifest({
           ...manifest,
-          value: (0, import_visitors_core28.pipe)(
-            (0, import_visitors_core28.visit)(node.value, self).value,
-            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `${enumFunction}('${variantName}', ${c})`),
+          value: visitorsCore.pipe(
+            visitorsCore.visit(node.value, self).value,
+            (f) => renderersCore.mapFragmentContent(f, (c) => `${enumFunction}('${variantName}', ${c})`),
             (f) => addFragmentImports(f, importFrom, [enumFunction])
           )
         });
       },
       visitFixedSizeType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
+        const manifest = visitorsCore.visit(node.type, self);
         return typeManifest({
           ...manifest,
           decoder: fragment`${use("fixDecoderSize", "solanaCodecsCore")}(${manifest.decoder}, ${node.size})`,
@@ -2630,13 +2658,13 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitHiddenPrefixType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
-        const prefixes = node.prefix.map((c) => (0, import_visitors_core28.visit)(c, self).value);
-        const prefixEncoders = (0, import_visitors_core28.pipe)(
+        const manifest = visitorsCore.visit(node.type, self);
+        const prefixes = node.prefix.map((c) => visitorsCore.visit(c, self).value);
+        const prefixEncoders = visitorsCore.pipe(
           mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantEncoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
         );
-        const prefixDecoders = (0, import_visitors_core28.pipe)(
+        const prefixDecoders = visitorsCore.pipe(
           mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
         );
@@ -2647,13 +2675,13 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitHiddenSuffixType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
-        const suffixes = node.suffix.map((c) => (0, import_visitors_core28.visit)(c, self).value);
-        const suffixEncoders = (0, import_visitors_core28.pipe)(
+        const manifest = visitorsCore.visit(node.type, self);
+        const suffixes = node.suffix.map((c) => visitorsCore.visit(c, self).value);
+        const suffixEncoders = visitorsCore.pipe(
           mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantEncoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
         );
-        const suffixDecoders = (0, import_visitors_core28.pipe)(
+        const suffixDecoders = visitorsCore.pipe(
           mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
         );
@@ -2670,19 +2698,19 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = (0, import_nodes28.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
-        const manifest = link ? (0, import_visitors_core28.visit)(link, self) : (0, import_visitors_core28.visit)(struct, self);
+        const struct = nodes.structTypeNodeFromInstructionArgumentNodes(instruction.arguments);
+        const manifest = link ? visitorsCore.visit(link, self) : visitorsCore.visit(struct, self);
         parentName = null;
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeTypeManifests([(0, import_visitors_core28.visit)(node.key, self), (0, import_visitors_core28.visit)(node.value, self)], {
+        return mergeTypeManifests([visitorsCore.visit(node.key, self), visitorsCore.visit(node.value, self)], {
           mergeValues: (renders) => `[${renders.join(", ")}]`
         });
       },
       visitMapType(mapType, { self }) {
-        const key = (0, import_visitors_core28.visit)(mapType.key, self);
-        const value = (0, import_visitors_core28.visit)(mapType.value, self);
+        const key = visitorsCore.visit(mapType.key, self);
+        const value = visitorsCore.visit(mapType.value, self);
         const mergedManifest = mergeTypeManifests([key, value], {
           mergeCodecs: ([k, v]) => `${k}, ${v}`,
           mergeTypes: ([k, v]) => `Map<${k}, ${v}>`
@@ -2697,7 +2725,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitMapValue(node, { self }) {
-        const entryFragments = node.entries.map((entry) => (0, import_visitors_core28.visit)(entry, self));
+        const entryFragments = node.entries.map((entry) => visitorsCore.visit(entry, self));
         return mergeTypeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
@@ -2723,12 +2751,12 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ value: fragment`${JSON.stringify(node.number)}` });
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = (0, import_visitors_core28.visit)(optionType.item, self);
+        const childManifest = visitorsCore.visit(optionType.item, self);
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = (0, import_nodes28.resolveNestedTypeNode)(optionType.prefix);
+        const optionPrefix = nodes.resolveNestedTypeNode(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = (0, import_visitors_core28.visit)(optionType.prefix, self);
+          const prefixManifest = visitorsCore.visit(optionType.prefix, self);
           encoderOptions.push(fragment`prefix: ${prefixManifest.encoder}`);
           decoderOptions.push(fragment`prefix: ${prefixManifest.decoder}`);
         }
@@ -2753,7 +2781,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitPostOffsetType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
+        const manifest = visitorsCore.visit(node.type, self);
         if (node.strategy === "padded") {
           return typeManifest({
             ...manifest,
@@ -2779,7 +2807,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitPreOffsetType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
+        const manifest = visitorsCore.visit(node.type, self);
         if (node.strategy === "padded") {
           return typeManifest({
             ...manifest,
@@ -2816,7 +2844,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = (0, import_visitors_core28.visit)(node.item, self);
+        const childManifest = visitorsCore.visit(node.item, self);
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
         const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
@@ -2830,8 +2858,8 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSentinelType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
-        const sentinel = (0, import_visitors_core28.visit)(node.sentinel, self).value;
+        const manifest = visitorsCore.visit(node.type, self);
+        const sentinel = visitorsCore.visit(node.sentinel, self).value;
         return typeManifest({
           ...manifest,
           decoder: fragment`${use("addDecoderSentinel", "solanaCodecsCore")}(${manifest.decoder}, ${sentinel})`,
@@ -2839,7 +2867,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSetType(setType, { self }) {
-        const childManifest = (0, import_visitors_core28.visit)(setType.item, self);
+        const childManifest = visitorsCore.visit(setType.item, self);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
         const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
         const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
@@ -2853,13 +2881,13 @@ function getTypeManifestVisitor(input) {
       },
       visitSetValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => (0, import_visitors_core28.visit)(v, self)),
+          node.items.map((v) => visitorsCore.visit(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
       },
       visitSizePrefixType(node, { self }) {
-        const manifest = (0, import_visitors_core28.visit)(node.type, self);
-        const prefix = (0, import_visitors_core28.visit)(node.prefix, self);
+        const manifest = visitorsCore.visit(node.type, self);
+        const prefix = visitorsCore.visit(node.prefix, self);
         return typeManifest({
           ...manifest,
           decoder: fragment`${use("addDecoderSizePrefix", "solanaCodecsCore")}(${manifest.decoder}, ${prefix.decoder})`,
@@ -2867,7 +2895,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSolAmountType({ number }, { self }) {
-        const numberManifest = (0, import_visitors_core28.visit)(number, self);
+        const numberManifest = visitorsCore.visit(number, self);
         return typeManifest({
           ...numberManifest,
           decoder: fragment`${use("getLamportsDecoder", "solanaRpcTypes")}(${numberManifest.decoder})`,
@@ -2877,7 +2905,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSomeValue(node, { self }) {
-        const innerValue = (0, import_visitors_core28.visit)(node.value, self).value;
+        const innerValue = visitorsCore.visit(node.value, self).value;
         return typeManifest({
           value: fragment`${use("some", "solanaOptions")}(${innerValue})`
         });
@@ -2910,8 +2938,8 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = (0, import_nodes28.camelCase)(structFieldType.name);
-        const originalChildManifest = (0, import_visitors_core28.visit)(structFieldType.type, self);
+        const name = nodes.camelCase(structFieldType.name);
+        const originalChildManifest = visitorsCore.visit(structFieldType.type, self);
         let docs = getDocblockFragment(structFieldType.docs ?? [], true);
         docs = docs ? fragment`\n${docs}` : docs;
         const childManifest = typeManifest({
@@ -2933,16 +2961,16 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ ...childManifest, looseType: fragment`` });
       },
       visitStructFieldValue(node, { self }) {
-        const innerValue = (0, import_visitors_core28.visit)(node.value, self).value;
+        const innerValue = visitorsCore.visit(node.value, self).value;
         return typeManifest({
           value: fragment`${node.name}: ${innerValue}`
         });
       },
       visitStructType(structType, { self }) {
         const optionalFields = structType.fields.filter((f) => !!f.defaultValue);
-        const mergedManifest = (0, import_visitors_core28.pipe)(
+        const mergedManifest = visitorsCore.pipe(
           mergeTypeManifests(
-            structType.fields.map((field) => (0, import_visitors_core28.visit)(field, self)),
+            structType.fields.map((field) => visitorsCore.visit(field, self)),
             {
               mergeCodecs: (renders) => `([${renders.join(", ")}])`,
               mergeTypes: (renders) => `{ ${renders.join("")} }`
@@ -2958,20 +2986,20 @@ function getTypeManifestVisitor(input) {
           return mergedManifest;
         }
         const parentPath = stack.getPath();
-        const instructionNode = (0, import_visitors_core28.findLastNodeFromPath)(parentPath, "instructionNode");
-        const accountNode = (0, import_visitors_core28.findLastNodeFromPath)(parentPath, "accountNode");
+        const instructionNode = visitorsCore.findLastNodeFromPath(parentPath, "instructionNode");
+        const accountNode = visitorsCore.findLastNodeFromPath(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
-        const fieldDiscriminators = discriminators.filter((0, import_nodes28.isNodeFilter)("fieldDiscriminatorNode"));
+        const fieldDiscriminators = discriminators.filter(nodes.isNodeFilter("fieldDiscriminatorNode"));
         const defaultValues = mergeFragments(
           optionalFields.map((f) => {
-            const key = (0, import_nodes28.camelCase)(f.name);
+            const key = nodes.camelCase(f.name);
             if (fieldDiscriminators.some((d) => d.name === f.name)) {
-              const constantName = nameApi.constant((0, import_nodes28.camelCase)(`${discriminatorPrefix}_${f.name}`));
+              const constantName = nameApi.constant(nodes.camelCase(`${discriminatorPrefix}_${f.name}`));
               return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${constantName}` : fragment`${key}: value.${key} ?? ${constantName}`;
             }
             const defaultValue = f.defaultValue;
-            const value = (0, import_visitors_core28.visit)(defaultValue, self).value;
+            const value = visitorsCore.visit(defaultValue, self).value;
             return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${value}` : fragment`${key}: value.${key} ?? ${value}`;
           }),
           (cs) => cs.join(", ")
@@ -2983,12 +3011,12 @@ function getTypeManifestVisitor(input) {
       },
       visitStructValue(node, { self }) {
         return mergeTypeManifests(
-          node.fields.map((field) => (0, import_visitors_core28.visit)(field, self)),
+          node.fields.map((field) => visitorsCore.visit(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => (0, import_visitors_core28.visit)(item, self));
+        const items = tupleType.items.map((item) => visitorsCore.visit(item, self));
         const mergedManifest = mergeTypeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
@@ -3001,16 +3029,16 @@ function getTypeManifestVisitor(input) {
       },
       visitTupleValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => (0, import_visitors_core28.visit)(v, self)),
+          node.items.map((v) => visitorsCore.visit(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = (0, import_visitors_core28.visit)(node.item, self);
+        const childManifest = visitorsCore.visit(node.item, self);
         const encoderOptions = [fragment`prefix: null`];
         const decoderOptions = [fragment`prefix: null`];
         if (node.zeroValue) {
-          const zeroValueManifest = (0, import_visitors_core28.visit)(node.zeroValue, self);
+          const zeroValueManifest = visitorsCore.visit(node.zeroValue, self);
           encoderOptions.push(fragment`noneValue: ${zeroValueManifest.value}`);
           decoderOptions.push(fragment`noneValue: ${zeroValueManifest.value}`);
         } else {
@@ -3034,56 +3062,57 @@ function getTypeManifestVisitor(input) {
         });
       }
     }),
-    (visitor) => (0, import_visitors_core28.recordNodeStackVisitor)(visitor, stack)
+    (visitor) => visitorsCore.recordNodeStackVisitor(visitor, stack)
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if ((0, import_nodes28.isNode)(count, "fixedCountNode")) {
+  if (nodes.isNode(count, "fixedCountNode")) {
     return {
       decoder: fragment`size: ${count.value}`,
       encoder: fragment`size: ${count.value}`
     };
   }
-  if ((0, import_nodes28.isNode)(count, "remainderCountNode")) {
+  if (nodes.isNode(count, "remainderCountNode")) {
     return {
       decoder: fragment`size: 'remainder'`,
       encoder: fragment`size: 'remainder'`
     };
   }
-  const prefix = (0, import_nodes28.resolveNestedTypeNode)(count.prefix);
+  const prefix = nodes.resolveNestedTypeNode(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: void 0, encoder: void 0 };
   }
-  const prefixManifest = (0, import_visitors_core28.visit)(count.prefix, visitor);
+  const prefixManifest = visitorsCore.visit(count.prefix, visitor);
   return {
-    decoder: (0, import_visitors_core28.pipe)(prefixManifest.decoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `size: ${c}`)),
-    encoder: (0, import_visitors_core28.pipe)(prefixManifest.encoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `size: ${c}`))
+    decoder: visitorsCore.pipe(prefixManifest.decoder, (f) => renderersCore.mapFragmentContent(f, (c) => `size: ${c}`)),
+    encoder: visitorsCore.pipe(prefixManifest.encoder, (f) => renderersCore.mapFragmentContent(f, (c) => `size: ${c}`))
   };
 }
 
 // src/visitors/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
-  const linkables = new import_visitors_core29.LinkableDictionary();
-  const stack = new import_visitors_core29.NodeStack();
+  const linkables = new visitorsCore.LinkableDictionary();
+  const stack = new visitorsCore.NodeStack();
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const renderScopeWithTypeManifestVisitor = {
-    asyncResolvers: (options.asyncResolvers ?? []).map(import_nodes29.camelCase),
+    asyncResolvers: (options.asyncResolvers ?? []).map(nodes.camelCase),
     customAccountData,
     customInstructionData,
     dependencyMap: options.dependencyMap ?? {},
+    dependencyVersions: options.dependencyVersions ?? {},
     getImportFrom: getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData),
     linkables,
     nameApi: getNameApi({ ...DEFAULT_NAME_TRANSFORMERS, ...options.nameTransformers }),
-    nonScalarEnums: (options.nonScalarEnums ?? []).map(import_nodes29.camelCase),
+    nonScalarEnums: (options.nonScalarEnums ?? []).map(nodes.camelCase),
     renderParentInstructions: options.renderParentInstructions ?? false,
     useGranularImports: options.useGranularImports ?? false
   };
   const typeManifestVisitor = getTypeManifestVisitor({ ...renderScopeWithTypeManifestVisitor, stack });
   const renderScope = { ...renderScopeWithTypeManifestVisitor, typeManifestVisitor };
-  const internalNodes = (options.internalNodes ?? []).map(import_nodes29.camelCase);
-  const resolvedInstructionInputVisitor = (0, import_visitors_core29.getResolvedInstructionInputsVisitor)();
-  const byteSizeVisitor = (0, import_visitors_core29.getByteSizeVisitor)(linkables, { stack });
+  const internalNodes = (options.internalNodes ?? []).map(nodes.camelCase);
+  const resolvedInstructionInputVisitor = visitorsCore.getResolvedInstructionInputsVisitor();
+  const byteSizeVisitor = visitorsCore.getByteSizeVisitor(linkables, { stack });
   const asPage = (fragment2, dependencyMap = {}) => {
     if (!fragment2) return void 0;
     return getPageFragment(fragment2, {
@@ -3091,47 +3120,47 @@ function getRenderMapVisitor(options = {}) {
       dependencyMap: { ...renderScope.dependencyMap, ...dependencyMap }
     });
   };
-  return (0, import_visitors_core29.pipe)(
-    (0, import_visitors_core29.staticVisitor)(() => (0, import_renderers_core13.createRenderMap)(), {
+  return visitorsCore.pipe(
+    visitorsCore.staticVisitor(() => renderersCore.createRenderMap(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
-    (v) => (0, import_visitors_core29.extendVisitor)(v, {
+    (v) => visitorsCore.extendVisitor(v, {
       visitAccount(node) {
-        return (0, import_renderers_core13.createRenderMap)(
-          `accounts/${(0, import_nodes29.camelCase)(node.name)}.ts`,
+        return renderersCore.createRenderMap(
+          `accounts/${nodes.camelCase(node.name)}.ts`,
           asPage(
             getAccountPageFragment({
               ...renderScope,
               accountPath: stack.getPath("accountNode"),
-              size: (0, import_visitors_core29.visit)(node, byteSizeVisitor)
+              size: visitorsCore.visit(node, byteSizeVisitor)
             })
           )
         );
       },
       visitDefinedType(node) {
-        return (0, import_renderers_core13.createRenderMap)(
-          `types/${(0, import_nodes29.camelCase)(node.name)}.ts`,
-          asPage(getTypePageFragment({ ...renderScope, node, size: (0, import_visitors_core29.visit)(node, byteSizeVisitor) }), {
+        return renderersCore.createRenderMap(
+          `types/${nodes.camelCase(node.name)}.ts`,
+          asPage(getTypePageFragment({ ...renderScope, node, size: visitorsCore.visit(node, byteSizeVisitor) }), {
             generatedTypes: "."
           })
         );
       },
       visitInstruction(node) {
-        return (0, import_renderers_core13.createRenderMap)(
-          `instructions/${(0, import_nodes29.camelCase)(node.name)}.ts`,
+        return renderersCore.createRenderMap(
+          `instructions/${nodes.camelCase(node.name)}.ts`,
           asPage(
             getInstructionPageFragment({
               ...renderScope,
               instructionPath: stack.getPath("instructionNode"),
-              resolvedInputs: (0, import_visitors_core29.visit)(node, resolvedInstructionInputVisitor),
-              size: (0, import_visitors_core29.visit)(node, byteSizeVisitor)
+              resolvedInputs: visitorsCore.visit(node, resolvedInstructionInputVisitor),
+              size: visitorsCore.visit(node, byteSizeVisitor)
             })
           )
         );
       },
       visitPda(node) {
-        return (0, import_renderers_core13.createRenderMap)(
-          `pdas/${(0, import_nodes29.camelCase)(node.name)}.ts`,
+        return renderersCore.createRenderMap(
+          `pdas/${nodes.camelCase(node.name)}.ts`,
           asPage(getPdaPageFragment({ ...renderScope, pdaPath: stack.getPath("pdaNode") }))
         );
       },
@@ -3141,41 +3170,40 @@ function getRenderMapVisitor(options = {}) {
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
         ];
         const scope = { ...renderScope, programNode: node };
-        return (0, import_renderers_core13.mergeRenderMaps)([
-          (0, import_renderers_core13.createRenderMap)({
-            [`programs/${(0, import_nodes29.camelCase)(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
-            [`errors/${(0, import_nodes29.camelCase)(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
+        return renderersCore.mergeRenderMaps([
+          renderersCore.createRenderMap({
+            [`programs/${nodes.camelCase(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
+            [`errors/${nodes.camelCase(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
           }),
-          ...node.pdas.map((p) => (0, import_visitors_core29.visit)(p, self)),
-          ...node.accounts.map((a) => (0, import_visitors_core29.visit)(a, self)),
-          ...node.definedTypes.map((t) => (0, import_visitors_core29.visit)(t, self)),
-          ...customDataDefinedType.map((t) => (0, import_visitors_core29.visit)(t, self)),
-          ...(0, import_nodes29.getAllInstructionsWithSubs)(node, { leavesOnly: !renderScope.renderParentInstructions }).map(
-            (i) => (0, import_visitors_core29.visit)(i, self)
+          ...node.pdas.map((p) => visitorsCore.visit(p, self)),
+          ...node.accounts.map((a) => visitorsCore.visit(a, self)),
+          ...node.definedTypes.map((t) => visitorsCore.visit(t, self)),
+          ...customDataDefinedType.map((t) => visitorsCore.visit(t, self)),
+          ...nodes.getAllInstructionsWithSubs(node, { leavesOnly: !renderScope.renderParentInstructions }).map(
+            (i) => visitorsCore.visit(i, self)
           )
         ]);
       },
       visitRoot(node, { self }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
-        const programsToExport = (0, import_nodes29.getAllPrograms)(node).filter(isNotInternal);
+        const programsToExport = nodes.getAllPrograms(node).filter(isNotInternal);
         const programsWithErrorsToExport = programsToExport.filter((p) => p.errors.length > 0);
-        const pdasToExport = (0, import_nodes29.getAllPdas)(node);
-        const accountsToExport = (0, import_nodes29.getAllAccounts)(node).filter(isNotInternal);
-        const instructionsToExport = (0, import_nodes29.getAllInstructionsWithSubs)(node, {
+        const pdasToExport = nodes.getAllPdas(node);
+        const accountsToExport = nodes.getAllAccounts(node).filter(isNotInternal);
+        const instructionsToExport = nodes.getAllInstructionsWithSubs(node, {
           leavesOnly: !renderScope.renderParentInstructions
         }).filter(isNotInternal);
-        const definedTypesToExport = (0, import_nodes29.getAllDefinedTypes)(node).filter(isNotInternal);
+        const definedTypesToExport = nodes.getAllDefinedTypes(node).filter(isNotInternal);
         const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const scope = {
-          ...renderScope,
           accountsToExport,
           definedTypesToExport,
           instructionsToExport,
           pdasToExport,
           programsToExport
         };
-        return (0, import_renderers_core13.mergeRenderMaps)([
-          (0, import_renderers_core13.createRenderMap)({
+        return renderersCore.mergeRenderMaps([
+          renderersCore.createRenderMap({
             ["accounts/index.ts"]: asPage(getIndexPageFragment(accountsToExport)),
             ["errors/index.ts"]: asPage(getIndexPageFragment(programsWithErrorsToExport)),
             ["index.ts"]: asPage(getRootIndexPageFragment(scope)),
@@ -3185,43 +3213,40 @@ function getRenderMapVisitor(options = {}) {
             ["shared/index.ts"]: hasAnythingToExport ? asPage(getSharedPageFragment()) : void 0,
             ["types/index.ts"]: asPage(getIndexPageFragment(definedTypesToExport))
           }),
-          ...(0, import_nodes29.getAllPrograms)(node).map((p) => (0, import_visitors_core29.visit)(p, self))
+          ...nodes.getAllPrograms(node).map((p) => visitorsCore.visit(p, self))
         ]);
       }
     }),
-    (v) => (0, import_visitors_core29.recordNodeStackVisitor)(v, stack),
-    (v) => (0, import_visitors_core29.recordLinkablesOnFirstVisitVisitor)(v, linkables)
+    (v) => visitorsCore.recordNodeStackVisitor(v, stack),
+    (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
-
-// src/visitors/renderVisitor.ts
-var import_renderers_core14 = require("@codama/renderers-core");
-var import_visitors_core30 = 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, typeScriptPlugin],
-  printWidth: 80,
-  semi: true,
-  singleQuote: true,
-  tabWidth: 2,
-  trailingComma: "es5",
-  useTabs: false
-};
 function renderVisitor(path, options = {}) {
-  return (0, import_visitors_core30.rootNodeVisitor)(async (root) => {
+  return visitorsCore.rootNodeVisitor(async (root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
-      (0, import_renderers_core14.deleteDirectory)(path);
-    }
-    let renderMap = (0, import_visitors_core30.visit)(root, getRenderMapVisitor(options));
-    if (options.formatCode ?? true) {
-      const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      renderMap = await (0, import_renderers_core14.mapRenderMapContentAsync)(renderMap, (code) => (0, import_standalone.format)(code, prettierOptions));
+      renderersCore.deleteDirectory(path);
     }
-    (0, import_renderers_core14.writeRenderMap)(renderMap, path);
+    let renderMap = visitorsCore.visit(root, getRenderMapVisitor(options));
+    renderMap = await formatCode(renderMap, options);
+    syncPackageJson(renderMap, options);
+    renderersCore.writeRenderMap(renderMap, path);
   });
 }
+
+exports.DEFAULT_NAME_TRANSFORMERS = DEFAULT_NAME_TRANSFORMERS;
+exports.addToImportMap = addToImportMap;
+exports.createImportMap = createImportMap;
+exports.default = renderVisitor;
+exports.getExternalDependencies = getExternalDependencies;
+exports.getNameApi = getNameApi;
+exports.getRenderMapVisitor = getRenderMapVisitor;
+exports.getTypeManifestVisitor = getTypeManifestVisitor;
+exports.importMapToString = importMapToString;
+exports.mergeImportMaps = mergeImportMaps;
+exports.mergeTypeManifests = mergeTypeManifests;
+exports.parseImportInput = parseImportInput;
+exports.removeFromImportMap = removeFromImportMap;
+exports.renderVisitor = renderVisitor;
+exports.typeManifest = typeManifest;
+//# sourceMappingURL=index.browser.cjs.map
 //# sourceMappingURL=index.browser.cjs.map