@codama/renderers-js 1.5.1 → 1.5.3

package/dist/index.node.mjs

@@ -1,3 +1,13 @@
+import { camelCase, pascalCase, snakeCase, titleCase, kebabCase, capitalize, REGISTERED_TYPE_NODE_KINDS, REGISTERED_VALUE_NODE_KINDS, isNodeFilter, resolveNestedTypeNode, structTypeNodeFromInstructionArgumentNodes, isNode, isScalarEnum, structTypeNode, structFieldTypeNode, getAllPrograms, getAllPdas, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, definedTypeLinkNode, definedTypeNode, isDataEnum, accountValueNode, argumentValueNode, parseOptionalAccountStrategy, VALUE_NODES, getAllInstructionArguments, constantDiscriminatorNode, constantValueNodeFromBytes, constantValueNode, assertIsNode } from '@codama/nodes';
+import { setFragmentContent, mapFragmentContent, createRenderMap, mergeRenderMaps, deleteDirectory, writeRenderMap, createFragmentTemplate, mapRenderMapContentAsync, joinPath, fileExists, readJson, writeFile } from '@codama/renderers-core';
+import { NodeStack, pipe, staticVisitor, extendVisitor, visit, findLastNodeFromPath, recordNodeStackVisitor, LinkableDictionary, getResolvedInstructionInputsVisitor, getByteSizeVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, findProgramNodeFromPath, getLastNodeFromPath, findInstructionNodeFromPath, deduplicateInstructionDependencies } from '@codama/visitors-core';
+import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder, getBase64Decoder } from '@solana/codecs-strings';
+import { format, resolveConfig } from 'prettier';
+import * as estreePlugin from 'prettier/plugins/estree';
+import * as typeScriptPlugin from 'prettier/plugins/typescript';
+import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND, logWarn, CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS } from '@codama/errors';
+import { subset, minVersion, lt } from 'semver';
+
 // src/utils/importMap.ts
 var DEFAULT_EXTERNAL_MODULE_MAP = {
   solanaAccounts: "@solana/kit",
@@ -100,6 +110,10 @@ function importMapToString(importMap, dependencyMap = {}, useGranularImports = f
     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,
@@ -117,9 +131,6 @@ function importInfoToString({ importedIdentifier, isType, usedIdentifier }) {
   const alias = importedIdentifier !== usedIdentifier ? ` as ${usedIdentifier}` : "";
   return `${isType ? "type " : ""}${importedIdentifier}${alias}`;
 }
-
-// src/utils/nameTransformers.ts
-import { camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase } from "@codama/nodes";
 function getNameApi(transformers) {
   const helpers = {
     camelCase,
@@ -181,9 +192,6 @@ var DEFAULT_NAME_TRANSFORMERS = {
   programIsErrorFunction: (name) => `is${pascalCase(name)}Error`,
   resolverFunction: (name) => `${camelCase(name)}`
 };
-
-// src/utils/fragment.ts
-import { createFragmentTemplate } from "@codama/renderers-core";
 function createFragment(content) {
   return Object.freeze({ content, features: /* @__PURE__ */ new Set(), imports: createImportMap() });
 }
@@ -263,40 +271,6 @@ function mergeTypeManifests(manifests, options = {}) {
     value: merge((m) => m.value, mergeValues)
   });
 }
-
-// src/visitors/getRenderMapVisitor.ts
-import {
-  camelCase as camelCase15,
-  getAllAccounts,
-  getAllDefinedTypes,
-  getAllInstructionsWithSubs as getAllInstructionsWithSubs2,
-  getAllPdas,
-  getAllPrograms
-} from "@codama/nodes";
-import { createRenderMap, mergeRenderMaps } from "@codama/renderers-core";
-import {
-  extendVisitor as extendVisitor2,
-  getByteSizeVisitor,
-  getResolvedInstructionInputsVisitor,
-  LinkableDictionary as LinkableDictionary3,
-  NodeStack as NodeStack2,
-  pipe as pipe16,
-  recordLinkablesOnFirstVisitVisitor,
-  recordNodeStackVisitor as recordNodeStackVisitor2,
-  staticVisitor as staticVisitor2,
-  visit as visit9
-} from "@codama/visitors-core";
-
-// src/fragments/accountFetchHelpers.ts
-import { getLastNodeFromPath, pipe } from "@codama/visitors-core";
-
-// src/utils/async.ts
-import {
-  accountValueNode,
-  argumentValueNode,
-  isNode
-} from "@codama/nodes";
-import { deduplicateInstructionDependencies } from "@codama/visitors-core";
 function hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers) {
   const hasByteDeltasAsync = (instructionNode.byteDeltas ?? []).some(
     ({ value }) => isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
@@ -366,9 +340,6 @@ function getInstructionDependencies(input, asyncResolvers, useAsync) {
   }
   return [];
 }
-
-// src/utils/codecs.ts
-import { getBase16Encoder, getBase58Encoder, getBase64Encoder, getUtf8Encoder } from "@solana/codecs-strings";
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
@@ -382,25 +353,16 @@ function getBytesFromBytesValueNode(node) {
       return getBase64Encoder().encode(node.data);
   }
 }
-
-// src/utils/customData.ts
-import {
-  camelCase as camelCase2,
-  definedTypeLinkNode,
-  definedTypeNode,
-  isNode as isNode2,
-  structTypeNodeFromInstructionArgumentNodes
-} from "@codama/nodes";
 var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
   customDataOptions.map((o) => {
     const options = typeof o === "string" ? { name: o } : o;
-    const importAs = camelCase2(options.importAs ?? `${options.name}${defaultSuffix}`);
+    const importAs = camelCase(options.importAs ?? `${options.name}${defaultSuffix}`);
     const importFrom = options.importFrom ?? "hooked";
     return [
-      camelCase2(options.name),
+      camelCase(options.name),
       {
         extract: options.extract ?? false,
-        extractAs: options.extractAs ? camelCase2(options.extractAs) : importAs,
+        extractAs: options.extractAs ? camelCase(options.extractAs) : importAs,
         importAs,
         importFrom,
         linkNode: definedTypeLinkNode(importAs)
@@ -411,7 +373,7 @@ var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
 var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.flatMap((node) => {
   const options = parsedCustomDataOptions.get(node.name);
   if (!options || !options.extract) return [];
-  if (isNode2(node, "accountNode")) {
+  if (isNode(node, "accountNode")) {
     return [definedTypeNode({ name: options.extractAs, type: { ...node.data } })];
   }
   return [
@@ -421,9 +383,31 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
     })
   ];
 });
-
-// src/utils/linkOverrides.ts
-import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
+var DEFAULT_PRETTIER_OPTIONS = {
+  arrowParens: "always",
+  parser: "typescript",
+  plugins: [estreePlugin, typeScriptPlugin],
+  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 mapRenderMapContentAsync(renderMap, (code) => format(code, prettierOptions));
+}
+async function resolvePrettierOptions(packageFolder) {
+  if (!packageFolder) return null;
+  return await resolveConfig(packageFolder);
+}
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
   const customDataOverrides = Object.fromEntries(
     [...customAccountData.values(), ...customInstructionData.values()].map(({ importFrom, importAs }) => [
@@ -470,6 +454,172 @@ 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) {
+      logWarn("Cannot sync package.json. Please provide the 'packageFolder' option.");
+    }
+    return;
+  }
+  const packageJsonPath = joinPath(packageFolder, "package.json");
+  const usedDependencies = getUsedDependencyVersions(
+    renderMap,
+    options.dependencyMap ?? {},
+    options.dependencyVersions ?? {},
+    options.useGranularImports ?? false
+  );
+  if (!shouldSyncPackageJson) {
+    if (fileExists(packageJsonPath)) {
+      checkExistingPackageJson(readJson(packageJsonPath), usedDependencies);
+    }
+    return;
+  }
+  if (fileExists(packageJsonPath)) {
+    const packageJson = updateExistingPackageJson(readJson(packageJsonPath), usedDependencies);
+    writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  } else {
+    const packageJson = createNewPackageJson(usedDependencies);
+    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("");
+  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 CodamaError(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 (subset(currentRange, requiredRange)) {
+      return false;
+    }
+    const minRequiredVersion = minVersion(requiredRange);
+    const minCurrentVersion = minVersion(currentRange);
+    if (!minCurrentVersion || !minRequiredVersion) {
+      throw new Error("Could not determine minimum versions.");
+    }
+    if (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) {
@@ -543,17 +693,9 @@ export async function ${fetchAllMaybeFunction}(
     ])
   );
 }
-
-// src/fragments/accountPage.ts
-import { resolveNestedTypeNode as resolveNestedTypeNode2 } from "@codama/nodes";
-import { findProgramNodeFromPath, getLastNodeFromPath as getLastNodeFromPath5, visit as visit2 } from "@codama/visitors-core";
-
-// src/fragments/accountPdaHelpers.ts
-import { isNodeFilter } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath2, pipe as pipe2 } from "@codama/visitors-core";
 function getAccountPdaHelpersFragment(scope) {
   const { accountPath, nameApi, linkables, customAccountData, typeManifest: typeManifest2 } = scope;
-  const accountNode = getLastNodeFromPath2(accountPath);
+  const accountNode = 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);
@@ -564,7 +706,7 @@ function getAccountPdaHelpersFragment(scope) {
   const fetchFromSeedsFunction = nameApi.accountFetchFromSeedsFunction(accountNode.name);
   const fetchMaybeFromSeedsFunction = nameApi.accountFetchMaybeFromSeedsFunction(accountNode.name);
   const fetchMaybeFunction = nameApi.accountFetchMaybeFunction(accountNode.name);
-  return pipe2(
+  return pipe(
     fragment`export async function ${fetchFromSeedsFunction}(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   ${hasVariableSeeds ? `seeds: ${pdaSeedsType},` : ""}
@@ -594,12 +736,9 @@ export async function ${fetchMaybeFromSeedsFunction}(
     ])
   );
 }
-
-// src/fragments/accountSizeHelpers.ts
-import { getLastNodeFromPath as getLastNodeFromPath3 } from "@codama/visitors-core";
 function getAccountSizeHelpersFragment(scope) {
   const { accountPath, nameApi } = scope;
-  const accountNode = getLastNodeFromPath3(accountPath);
+  const accountNode = getLastNodeFromPath(accountPath);
   if (accountNode.size == null) return;
   const getSizeFunction = nameApi.accountGetSizeFunction(accountNode.name);
   return fragment`export function ${getSizeFunction}(): number {
@@ -607,10 +746,6 @@ function getAccountSizeHelpersFragment(scope) {
 }`;
 }
 
-// src/fragments/accountType.ts
-import { resolveNestedTypeNode } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath4 } from "@codama/visitors-core";
-
 // src/fragments/type.ts
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
@@ -624,9 +759,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
-import { isDataEnum, isNode as isNode3 } from "@codama/nodes";
 function getTypeDecoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const decoderFunction = nameApi.decoderFunction(name);
@@ -636,15 +768,12 @@ function getTypeDecoderFragment(scope) {
     typeof scope.size === "number" ? "type FixedSizeDecoder" : "type Decoder",
     "solanaCodecsCore"
   );
-  const useTypeCast = isNode3(node, "enumTypeNode") && isDataEnum(node) && typeof scope.size === "number";
+  const useTypeCast = isNode(node, "enumTypeNode") && 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
-import { isDataEnum as isDataEnum2, isNode as isNode4 } from "@codama/nodes";
 function getTypeEncoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const encoderFunction = nameApi.encoderFunction(name);
@@ -654,7 +783,7 @@ function getTypeEncoderFragment(scope) {
     typeof scope.size === "number" ? "type FixedSizeEncoder" : "type Encoder",
     "solanaCodecsCore"
   );
-  const useTypeCast = isNode4(node, "enumTypeNode") && isDataEnum2(node) && typeof scope.size === "number";
+  const useTypeCast = isNode(node, "enumTypeNode") && 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};
@@ -694,7 +823,7 @@ function getTypeWithCodecFragment(scope) {
 // src/fragments/accountType.ts
 function getAccountTypeFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = getLastNodeFromPath4(accountPath);
+  const accountNode = getLastNodeFromPath(accountPath);
   if (customAccountData.has(accountNode.name)) return;
   return getTypeWithCodecFragment({
     codecDocs: [`Gets the codec for {@link ${nameApi.dataType(accountNode.name)}} account data.`],
@@ -708,15 +837,6 @@ function getAccountTypeFragment(scope) {
     typeDocs: accountNode.docs
   });
 }
-
-// src/fragments/discriminatorConstants.ts
-import {
-  camelCase as camelCase3,
-  isNode as isNode5,
-  isNodeFilter as isNodeFilter2,
-  VALUE_NODES
-} from "@codama/nodes";
-import { visit } from "@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"));
@@ -733,9 +853,9 @@ function getDiscriminatorConstantFragment(discriminatorNode, scope) {
 }
 function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
-  const index = discriminatorNodes.filter(isNodeFilter2("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const index = discriminatorNodes.filter(isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = camelCase3(`${prefix}_discriminator${suffix}`);
+  const name = camelCase(`${prefix}_discriminator${suffix}`);
   const encoder = visit(discriminatorNode.constant.type, typeManifestVisitor).encoder;
   const value = visit(discriminatorNode.constant.value, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
@@ -743,10 +863,10 @@ function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
 function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { fields, prefix, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !isNode5(field.defaultValue, VALUE_NODES)) {
+  if (!field || !field.defaultValue || !isNode(field.defaultValue, VALUE_NODES)) {
     return null;
   }
-  const name = camelCase3(`${prefix}_${discriminatorNode.name}`);
+  const name = camelCase(`${prefix}_${discriminatorNode.name}`);
   const encoder = visit(field.type, typeManifestVisitor).encoder;
   const value = visit(field.defaultValue, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
@@ -760,12 +880,12 @@ function getConstantFragment(scope) {
 
 // src/fragments/accountPage.ts
 function getAccountPageFragment(scope) {
-  const node = getLastNodeFromPath5(scope.accountPath);
+  const node = getLastNodeFromPath(scope.accountPath);
   if (!findProgramNodeFromPath(scope.accountPath)) {
     throw new Error("Account must be visited inside a program.");
   }
-  const typeManifest2 = visit2(node, scope.typeManifestVisitor);
-  const fields = resolveNestedTypeNode2(node.data).fields;
+  const typeManifest2 = visit(node, scope.typeManifestVisitor);
+  const fields = resolveNestedTypeNode(node.data).fields;
   return mergeFragments(
     [
       getDiscriminatorConstantsFragment({
@@ -782,29 +902,17 @@ function getAccountPageFragment(scope) {
     (cs) => cs.join("\n\n")
   );
 }
-
-// src/fragments/discriminatorCondition.ts
-import {
-  constantDiscriminatorNode,
-  constantValueNode,
-  constantValueNodeFromBytes,
-  isNode as isNode6,
-  isNodeFilter as isNodeFilter3
-} from "@codama/nodes";
-import { mapFragmentContent } from "@codama/renderers-core";
-import { pipe as pipe3, visit as visit3 } from "@codama/visitors-core";
-import { getBase64Decoder } from "@solana/codecs-strings";
 function getDiscriminatorConditionFragment(scope) {
-  return pipe3(
+  return pipe(
     mergeFragments(
       scope.discriminators.flatMap((discriminator) => {
-        if (isNode6(discriminator, "sizeDiscriminatorNode")) {
+        if (isNode(discriminator, "sizeDiscriminatorNode")) {
           return [getSizeConditionFragment(discriminator, scope)];
         }
-        if (isNode6(discriminator, "constantDiscriminatorNode")) {
+        if (isNode(discriminator, "constantDiscriminatorNode")) {
           return [getByteConditionFragment(discriminator, scope)];
         }
-        if (isNode6(discriminator, "fieldDiscriminatorNode")) {
+        if (isNode(discriminator, "fieldDiscriminatorNode")) {
           return [getFieldConditionFragment(discriminator, scope)];
         }
         return [];
@@ -820,7 +928,7 @@ function getSizeConditionFragment(discriminator, scope) {
 }
 function getByteConditionFragment(discriminator, scope) {
   const { dataName, typeManifestVisitor } = scope;
-  const constant = visit3(discriminator.constant, typeManifestVisitor).value;
+  const constant = visit(discriminator.constant, typeManifestVisitor).value;
   return fragment`${use("containsBytes", "solanaCodecsCore")}(${dataName}, ${constant}, ${discriminator.offset})`;
 }
 function getFieldConditionFragment(discriminator, scope) {
@@ -830,7 +938,7 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if (isNode6(field.type, "arrayTypeNode") && isNode6(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode6(field.type.count, "fixedCountNode") && isNode6(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter3("numberValueNode"))) {
+  if (isNode(field.type, "arrayTypeNode") && isNode(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode(field.type.count, "fixedCountNode") && isNode(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter("numberValueNode"))) {
     const base64Bytes = getBase64Decoder().decode(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
@@ -920,19 +1028,13 @@ function getIsErrorFunctionFragment(scope) {
   return ${use("isProgramError", "solanaPrograms")}<TProgramErrorCode>(error, transactionMessage, ${programAddressConstant}, code);
 }`;
 }
-
-// src/fragments/indexPage.ts
-import { camelCase as camelCase4 } from "@codama/nodes";
 function getIndexPageFragment(items) {
   if (items.length === 0) return;
-  const names = items.map((item) => camelCase4(item.name)).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
+  const names = items.map((item) => camelCase(item.name)).sort((a, b) => a.localeCompare(b)).map((name) => getExportAllFragment(`./${name}`));
   return mergeFragments(names, (cs) => cs.join("\n"));
 }
-
-// src/fragments/instructionAccountMeta.ts
-import { pascalCase as pascalCase2 } from "@codama/nodes";
 function getInstructionAccountMetaFragment(instructionAccountNode) {
-  const typeParam = `TAccount${pascalCase2(instructionAccountNode.name)}`;
+  const typeParam = `TAccount${pascalCase(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
     return fragment`${use("type WritableSignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
@@ -944,21 +1046,13 @@ function getInstructionAccountMetaFragment(instructionAccountNode) {
   }
   return fragment`${use("type ReadonlyAccount", "solanaInstructions")}<${typeParam}>`;
 }
-
-// src/fragments/instructionAccountTypeParam.ts
-import { pascalCase as pascalCase3 } from "@codama/nodes";
-import {
-  findInstructionNodeFromPath,
-  findProgramNodeFromPath as findProgramNodeFromPath2,
-  getLastNodeFromPath as getLastNodeFromPath6
-} from "@codama/visitors-core";
 function getInstructionAccountTypeParamFragment(scope) {
-  const { instructionAccountPath, allowAccountMeta, linkables } = scope;
-  const instructionAccountNode = getLastNodeFromPath6(instructionAccountPath);
+  const { instructionAccountPath, linkables } = scope;
+  const instructionAccountNode = getLastNodeFromPath(instructionAccountPath);
   const instructionNode = findInstructionNodeFromPath(instructionAccountPath);
-  const programNode = findProgramNodeFromPath2(instructionAccountPath);
-  const typeParam = `TAccount${pascalCase3(instructionAccountNode.name)}`;
-  const accountMeta = allowAccountMeta ? fragment` | ${use("type AccountMeta", "solanaInstructions")}<string>` : void 0;
+  const programNode = findProgramNodeFromPath(instructionAccountPath);
+  const typeParam = `TAccount${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`;
   }
@@ -978,13 +1072,8 @@ function getDefaultAddress(defaultValue, programId, linkables) {
       return "string";
   }
 }
-
-// src/fragments/instructionByteDelta.ts
-import { assertIsNode, camelCase as camelCase5, isNode as isNode7 } from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent2 } from "@codama/renderers-core";
-import { getLastNodeFromPath as getLastNodeFromPath7, pipe as pipe4 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = getLastNodeFromPath7(scope.instructionPath);
+  const { byteDeltas } = getLastNodeFromPath(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((c) => getByteDeltaFragment(c, scope));
   if (fragments.length === 0) return;
   return mergeFragments(
@@ -995,16 +1084,16 @@ const byteDelta: number = [${c.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   let bytesFragment = (() => {
-    if (isNode7(byteDelta.value, "numberValueNode")) {
+    if (isNode(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if (isNode7(byteDelta.value, "argumentValueNode")) {
+    if (isNode(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if (isNode7(byteDelta.value, "accountLinkNode")) {
+    if (isNode(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if (isNode7(byteDelta.value, "resolverValueNode")) {
+    if (isNode(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -1014,7 +1103,7 @@ function getByteDeltaFragment(byteDelta, scope) {
     bytesFragment = fragment`${bytesFragment} + ${use("BASE_ACCOUNT_SIZE", "solanaAccounts")}`;
   }
   if (byteDelta.subtract) {
-    bytesFragment = pipe4(bytesFragment, (f) => mapFragmentContent2(f, (c) => `- (${c})`));
+    bytesFragment = pipe(bytesFragment, (f) => mapFragmentContent(f, (c) => `- (${c})`));
   }
   return [bytesFragment];
 }
@@ -1024,7 +1113,7 @@ function getNumberValueNodeFragment(byteDelta) {
 }
 function getArgumentValueNodeFragment(byteDelta) {
   assertIsNode(byteDelta.value, "argumentValueNode");
-  const argumentName = camelCase5(byteDelta.value.name);
+  const argumentName = camelCase(byteDelta.value.name);
   return fragment`Number(args.${argumentName})`;
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
@@ -1044,59 +1133,32 @@ function getResolverValueNodeFragment(byteDelta, scope) {
     scope.nameApi.resolverFunction(byteDelta.value.name),
     scope.getImportFrom(byteDelta.value)
   );
-  return pipe4(
+  return pipe(
     fragment`${awaitKeyword}${functionName}(resolverScope)`,
     (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
   );
 }
-
-// src/fragments/instructionData.ts
-import { structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes2 } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath8 } from "@codama/visitors-core";
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath8(instructionPath);
+  const instructionNode = 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: structTypeNodeFromInstructionArgumentNodes2(instructionNode.arguments),
+    node: structTypeNodeFromInstructionArgumentNodes(instructionNode.arguments),
     size: scope.size
   });
 }
-
-// src/fragments/instructionExtraArgs.ts
-import { mapFragmentContent as mapFragmentContent3 } from "@codama/renderers-core";
-import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
 function getInstructionExtraArgsFragment(scope) {
   const { instructionPath, extraArgsManifest, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath9(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) return;
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const looseName = nameApi.dataArgsType(instructionExtraName);
-  return mapFragmentContent3(extraArgsManifest.looseType, (c) => `export type ${looseName} = ${c};`);
+  return mapFragmentContent(extraArgsManifest.looseType, (c) => `export type ${looseName} = ${c};`);
 }
-
-// src/fragments/instructionFunction.ts
-import { camelCase as camelCase10, isNode as isNode12, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent7 } from "@codama/renderers-core";
-import {
-  findProgramNodeFromPath as findProgramNodeFromPath3,
-  getLastNodeFromPath as getLastNodeFromPath13,
-  pipe as pipe8
-} from "@codama/visitors-core";
-
-// src/fragments/instructionInputResolved.ts
-import { camelCase as camelCase7, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent5 } from "@codama/renderers-core";
-import { getLastNodeFromPath as getLastNodeFromPath10 } from "@codama/visitors-core";
-
-// src/fragments/instructionInputDefault.ts
-import { camelCase as camelCase6, isNode as isNode8 } from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent4, setFragmentContent } from "@codama/renderers-core";
-import { pipe as pipe5, visit as visit4 } from "@codama/visitors-core";
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
   if (!input.defaultValue) {
@@ -1107,8 +1169,8 @@ function getInstructionInputDefaultFragment(scope) {
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
-    const inputName = camelCase6(input.name);
-    if (input.kind === "instructionAccountNode" && isNode8(defaultValue, "resolverValueNode")) {
+    const inputName = camelCase(input.name);
+    if (input.kind === "instructionAccountNode" && isNode(defaultValue, "resolverValueNode")) {
       return fragment`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`;
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -1126,7 +1188,7 @@ function getInstructionInputDefaultFragment(scope) {
   const addressType = use("type Address", "solanaAddresses");
   switch (defaultValue.kind) {
     case "accountValueNode":
-      const name = camelCase6(defaultValue.name);
+      const name = camelCase(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
         return defaultFragment(fragment`${expectTransactionSigner}(accounts.${name}.value).address`);
       }
@@ -1136,13 +1198,13 @@ function getInstructionInputDefaultFragment(scope) {
       return defaultFragment(fragment`${expectAddress}(accounts.${name}.value)`);
     case "pdaValueNode":
       let pdaProgramValue;
-      if (isNode8(defaultValue.programId, "accountValueNode")) {
-        pdaProgramValue = fragment`${expectAddress}(accounts.${camelCase6(defaultValue.programId.name)}.value)`;
+      if (isNode(defaultValue.programId, "accountValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(accounts.${camelCase(defaultValue.programId.name)}.value)`;
       }
-      if (isNode8(defaultValue.programId, "argumentValueNode")) {
-        pdaProgramValue = fragment`${expectAddress}(args.${camelCase6(defaultValue.programId.name)})`;
+      if (isNode(defaultValue.programId, "argumentValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(args.${camelCase(defaultValue.programId.name)})`;
       }
-      if (isNode8(defaultValue.pda, "pdaNode")) {
+      if (isNode(defaultValue.pda, "pdaNode")) {
         let pdaProgram = fragment`programAddress`;
         if (pdaProgramValue) {
           pdaProgram = pdaProgramValue;
@@ -1150,29 +1212,29 @@ function getInstructionInputDefaultFragment(scope) {
           pdaProgram = fragment`'${defaultValue.pda.programId}' as ${addressType}<'${defaultValue.pda.programId}'>`;
         }
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
-          if (isNode8(seed, "constantPdaSeedNode") && isNode8(seed.value, "programIdValueNode")) {
+          if (isNode(seed, "constantPdaSeedNode") && isNode(seed.value, "programIdValueNode")) {
             return [fragment`${use("getAddressEncoder", "solanaAddresses")}().encode(${pdaProgram})`];
           }
-          if (isNode8(seed, "constantPdaSeedNode") && !isNode8(seed.value, "programIdValueNode")) {
-            const typeManifest2 = visit4(seed.type, typeManifestVisitor);
-            const valueManifest2 = visit4(seed.value, typeManifestVisitor);
+          if (isNode(seed, "constantPdaSeedNode") && !isNode(seed.value, "programIdValueNode")) {
+            const typeManifest2 = visit(seed.type, typeManifestVisitor);
+            const valueManifest2 = visit(seed.value, typeManifestVisitor);
             return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
-          if (isNode8(seed, "variablePdaSeedNode")) {
-            const typeManifest2 = visit4(seed.type, typeManifestVisitor);
+          if (isNode(seed, "variablePdaSeedNode")) {
+            const typeManifest2 = visit(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if (isNode8(valueSeed, "accountValueNode")) {
+            if (isNode(valueSeed, "accountValueNode")) {
               return [
-                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${camelCase6(valueSeed.name)}.value))`
+                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${camelCase(valueSeed.name)}.value))`
               ];
             }
-            if (isNode8(valueSeed, "argumentValueNode")) {
+            if (isNode(valueSeed, "argumentValueNode")) {
               return [
-                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${camelCase6(valueSeed.name)}))`
+                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${camelCase(valueSeed.name)}))`
               ];
             }
-            const valueManifest2 = visit4(valueSeed, typeManifestVisitor);
+            const valueManifest2 = visit(valueSeed, typeManifestVisitor);
             return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
           return [];
@@ -1187,20 +1249,20 @@ function getInstructionInputDefaultFragment(scope) {
       const pdaFunction = use(nameApi.pdaFindFunction(defaultValue.pda.name), getImportFrom(defaultValue.pda));
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
-        if (isNode8(seed.value, "accountValueNode")) {
-          return fragment`${seed.name}: ${expectAddress}(accounts.${camelCase6(seed.value.name)}.value)`;
+        if (isNode(seed.value, "accountValueNode")) {
+          return fragment`${seed.name}: ${expectAddress}(accounts.${camelCase(seed.value.name)}.value)`;
         }
-        if (isNode8(seed.value, "argumentValueNode")) {
-          return fragment`${seed.name}: ${expectSome}(args.${camelCase6(seed.value.name)})`;
+        if (isNode(seed.value, "argumentValueNode")) {
+          return fragment`${seed.name}: ${expectSome}(args.${camelCase(seed.value.name)})`;
         }
-        return pipe5(
-          visit4(seed.value, typeManifestVisitor).value,
-          (f) => mapFragmentContent4(f, (c) => `${seed.name}: ${c}`)
+        return pipe(
+          visit(seed.value, typeManifestVisitor).value,
+          (f) => mapFragmentContent(f, (c) => `${seed.name}: ${c}`)
         );
       });
-      const pdaSeedsFragment = pipe5(
+      const pdaSeedsFragment = pipe(
         mergeFragments(pdaSeeds, (renders) => renders.join(", ")),
-        (f) => mapFragmentContent4(f, (c) => `{ ${c} }`)
+        (f) => mapFragmentContent(f, (c) => `{ ${c} }`)
       );
       if (pdaSeeds.length > 0) {
         pdaArgs.push(pdaSeedsFragment);
@@ -1226,14 +1288,14 @@ function getInstructionInputDefaultFragment(scope) {
       return fragment``;
     case "accountBumpValueNode":
       return defaultFragment(
-        fragment`${expectProgramDerivedAddress}(accounts.${camelCase6(defaultValue.name)}.value)[1]`
+        fragment`${expectProgramDerivedAddress}(accounts.${camelCase(defaultValue.name)}.value)[1]`
       );
     case "argumentValueNode":
-      return defaultFragment(fragment`${expectSome}(args.${camelCase6(defaultValue.name)})`);
+      return defaultFragment(fragment`${expectSome}(args.${camelCase(defaultValue.name)})`);
     case "resolverValueNode":
       const resolverFunction = use(nameApi.resolverFunction(defaultValue.name), getImportFrom(defaultValue));
       const resolverAwait = useAsync && asyncResolvers.includes(defaultValue.name) ? "await " : "";
-      return pipe5(
+      return pipe(
         defaultFragment(fragment`${resolverAwait}${resolverFunction}(resolverScope)`),
         (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
       );
@@ -1258,10 +1320,10 @@ function getInstructionInputDefaultFragment(scope) {
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if (isNode8(defaultValue.condition, "resolverValueNode")) {
+      if (isNode(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
         const module = getImportFrom(defaultValue.condition);
-        conditionalFragment = pipe5(
+        conditionalFragment = pipe(
           conditionalFragment,
           (f) => addFragmentImports(f, module, [conditionalResolverFunction]),
           (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
@@ -1270,9 +1332,9 @@ function getInstructionInputDefaultFragment(scope) {
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
-        const comparedInputName = isNode8(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase6(defaultValue.condition.name)}.value` : `args.${camelCase6(defaultValue.condition.name)}`;
+        const comparedInputName = isNode(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase(defaultValue.condition.name)}.value` : `args.${camelCase(defaultValue.condition.name)}`;
         if (defaultValue.value) {
-          const comparedValue = visit4(defaultValue.value, typeManifestVisitor).value;
+          const comparedValue = visit(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
           const operator = negatedCondition ? "!==" : "===";
           condition = `${comparedInputName} ${operator} ${comparedValue.content}`;
@@ -1297,7 +1359,7 @@ ${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
 }`
       );
     default:
-      const valueManifest = visit4(defaultValue, typeManifestVisitor).value;
+      const valueManifest = visit(defaultValue, typeManifestVisitor).value;
       return defaultFragment(valueManifest);
   }
 }
@@ -1312,7 +1374,7 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
-  const instructionNode = getLastNodeFromPath10(scope.instructionPath);
+  const instructionNode = getLastNodeFromPath(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
@@ -1320,11 +1382,11 @@ function getInstructionInputResolvedFragment(scope) {
       optionalAccountStrategy: parseOptionalAccountStrategy(instructionNode.optionalAccountStrategy)
     });
     if (!inputFragment.content) return [];
-    const camelName = camelCase7(input.name);
+    const camelName = camelCase(input.name);
     return [
-      mapFragmentContent5(
+      mapFragmentContent(
         inputFragment,
-        (c) => isNode9(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (c) => isNode(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${c}
 }` : `if (!accounts.${camelName}.value) {
 ${c}
@@ -1337,27 +1399,14 @@ ${c}
   }
   return mergeFragments([fragment`// Resolve default values.`, ...resolvedInputFragments], (c) => c.join("\n"));
 }
-
-// src/fragments/instructionInputType.ts
-import {
-  camelCase as camelCase8,
-  getAllInstructionArguments,
-  isNode as isNode10,
-  pascalCase as pascalCase4
-} from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent6 } from "@codama/renderers-core";
-import {
-  getLastNodeFromPath as getLastNodeFromPath11,
-  pipe as pipe6
-} from "@codama/visitors-core";
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath11(instructionPath);
+  const instructionNode = 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${pascalCase4(account.name)} extends string = string`).join(", ");
+    accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase(account.name)} extends string = string`).join(", ");
     accountTypeParams = `<${accountTypeParams}>`;
   }
   const typeBodyFragment = mergeFragments(
@@ -1375,20 +1424,20 @@ function getInstructionInputTypeFragment(scope) {
 }
 function getAccountsFragment(scope) {
   const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
-  const instructionNode = getLastNodeFromPath11(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode10(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const docs = getDocblockFragment(account.docs ?? [], true);
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return fragment`${docs}${camelCase8(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
+    return fragment`${docs}${camelCase(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
   });
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getAccountTypeFragment2(account) {
-  const typeParam = `TAccount${pascalCase4(account.name)}`;
+  const typeParam = `TAccount${pascalCase(account.name)}`;
   const address = use("type Address", "solanaAddresses");
   const signer = use("type TransactionSigner", "solanaSigners");
   const pda = use("type ProgramDerivedAddress", "solanaAddresses");
@@ -1400,15 +1449,15 @@ function getAccountTypeFragment2(account) {
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath11(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
       void 0,
-      pipe6(
+      pipe(
         fragment`${nameApi.dataArgsType(customData.importAs)}`,
         (f) => mergeFragmentImports(f, [scope.dataArgsManifest.looseType.imports]),
-        (f) => mapFragmentContent6(f, (c) => `${c} & `)
+        (f) => mapFragmentContent(f, (c) => `${c} & `)
       )
     ];
   }
@@ -1422,7 +1471,7 @@ function getDataArgumentsFragments(scope) {
 }
 function getExtraArgumentsFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath11(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
@@ -1434,16 +1483,16 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => isNode10(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => 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`${camelCase8(renamedName)}${optionalSign}: ${argsType}["${camelCase8(arg.name)}"];`;
+  return fragment`${camelCase(renamedName)}${optionalSign}: ${argsType}["${camelCase(arg.name)}"];`;
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if (isNode10(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if (isNode(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
     const allArguments = getAllInstructionArguments(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
@@ -1456,25 +1505,16 @@ function getRemainingAccountsFragment(instructionNode) {
       if (isSigner === "either") return fragment`${signerFragment} | ${addressFragment}`;
       return isSigner ? signerFragment : addressFragment;
     })();
-    return fragment`${camelCase8(name)}${optionalSign}: Array<${typeFragment}>;`;
+    return fragment`${camelCase(name)}${optionalSign}: Array<${typeFragment}>;`;
   });
   if (fragments.length === 0) return;
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
-
-// src/fragments/instructionRemainingAccounts.ts
-import {
-  assertIsNode as assertIsNode2,
-  camelCase as camelCase9,
-  getAllInstructionArguments as getAllInstructionArguments2,
-  isNode as isNode11
-} from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath12, pipe as pipe7 } from "@codama/visitors-core";
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = getLastNodeFromPath12(scope.instructionPath);
+  const { remainingAccounts } = getLastNodeFromPath(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((a) => getRemainingAccountsFragment2(a, scope));
   if (fragments.length === 0) return;
-  return pipe7(
+  return pipe(
     mergeFragments(
       fragments,
       (c) => `// Remaining accounts.
@@ -1485,10 +1525,10 @@ const remainingAccounts: AccountMeta[] = ${c.length === 1 ? c[0] : `[...${c.join
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if (isNode11(remainingAccounts.value, "argumentValueNode")) {
+    if (isNode(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if (isNode11(remainingAccounts.value, "resolverValueNode")) {
+    if (isNode(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1497,9 +1537,9 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const instructionNode = getLastNodeFromPath12(scope.instructionPath);
-  assertIsNode2(remainingAccounts.value, "argumentValueNode");
-  const argumentName = camelCase9(remainingAccounts.value.name);
+  const instructionNode = getLastNodeFromPath(scope.instructionPath);
+  assertIsNode(remainingAccounts.value, "argumentValueNode");
+  const argumentName = camelCase(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
@@ -1508,7 +1548,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 = getAllInstructionArguments2(instructionNode);
+  const allArguments = getAllInstructionArguments(instructionNode);
   const argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
     return fragment`${argumentArray}.map((address) => ({ address, role: ${role} }))`;
@@ -1519,7 +1559,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   return fragment`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`;
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
-  assertIsNode2(remainingAccounts.value, "resolverValueNode");
+  assertIsNode(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
@@ -1527,7 +1567,7 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
     scope.nameApi.resolverFunction(remainingAccounts.value.name),
     scope.getImportFrom(remainingAccounts.value)
   );
-  return pipe7(
+  return pipe(
     fragment`${awaitKeyword}${functionName}(resolverScope)`,
     (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
   );
@@ -1536,13 +1576,13 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
 // src/fragments/instructionFunction.ts
 function getInstructionFunctionFragment(scope) {
   const { useAsync, instructionPath, resolvedInputs, renamedArgs, asyncResolvers, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath13(instructionPath);
-  const programNode = findProgramNodeFromPath3(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
+  const programNode = 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(isNodeFilter4("argumentValueNode")).map((node) => node.name);
+  const argDependencies = instructionDependencies.filter(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);
@@ -1555,7 +1595,7 @@ function getInstructionFunctionFragment(scope) {
   const hasExtraArgs = (instructionNode.extraArguments ?? []).filter(
     (field) => argIsNotOmitted(field) && (argIsDependent(field) || argHasDefaultValue(field))
   ).length > 0;
-  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode12(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const programAddressConstant = use(nameApi.programAddressConstant(programNode.name), "generatedPrograms");
@@ -1574,7 +1614,7 @@ function getInstructionFunctionFragment(scope) {
   const typeParams = getTypeParamsFragment(instructionNode, programAddressConstant);
   const returnType = getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync);
   const inputType = getInstructionInputTypeFragment(scope);
-  const inputArg = mapFragmentContent7(getInputTypeCallFragment(scope), (c) => hasInput ? `input: ${c}, ` : "");
+  const inputArg = mapFragmentContent(getInputTypeCallFragment(scope), (c) => hasInput ? `input: ${c}, ` : "");
   const functionBody = mergeFragments(
     [
       getProgramAddressInitializationFragment(programAddressConstant),
@@ -1606,7 +1646,7 @@ function getAccountsInitializationFragment(instructionNode) {
   if (instructionNode.accounts.length === 0) return;
   const accounts = mergeFragments(
     instructionNode.accounts.map((account) => {
-      const name = camelCase10(account.name);
+      const name = camelCase(account.name);
       const isWritable = account.isWritable ? "true" : "false";
       return fragment`${name}: { value: input.${name} ?? null, isWritable: ${isWritable} }`;
     }),
@@ -1641,7 +1681,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.${camelCase10(account.name)})`),
+    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${camelCase(account.name)})`),
     ...hasRemainingAccounts ? ["...remainingAccounts"] : []
   ].join(", ");
   let accounts;
@@ -1662,14 +1702,14 @@ function getReturnStatementFragment(scope) {
   } else if (hasData) {
     data = fragment`data: ${encoderFunctionFragment}.encode({})`;
   }
-  const instructionAttributes = pipe8(
+  const instructionAttributes = 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 pipe8(
+  return pipe(
     instructionTypeFragment,
     (f) => hasByteDeltas ? fragment`${f} & ${use("type InstructionWithByteDelta", "shared")}` : f,
     (f) => useAsync ? fragment`Promise<${f}>` : f
@@ -1678,7 +1718,7 @@ function getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync)
 function getTypeParamsFragment(instructionNode, programAddressConstant) {
   return mergeFragments(
     [
-      ...instructionNode.accounts.map((account) => fragment`TAccount${pascalCase5(account.name)} extends string`),
+      ...instructionNode.accounts.map((account) => fragment`TAccount${pascalCase(account.name)} extends string`),
       fragment`TProgramAddress extends ${use("type Address", "solanaAddresses")} = typeof ${programAddressConstant}`
     ],
     (cs) => `<${cs.join(", ")}>`
@@ -1686,52 +1726,39 @@ function getTypeParamsFragment(instructionNode, programAddressConstant) {
 }
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath13(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = fragment`TAccount${pascalCase5(account.name)}`;
-    const camelName = camelCase10(account.name);
+    const typeParam = fragment`TAccount${pascalCase(account.name)}`;
+    const camelName = camelCase(account.name);
     if (account.isSigner === "either") {
       const signerRole = use(
         account.isWritable ? "type WritableSignerAccount" : "type ReadonlySignerAccount",
         "solanaInstructions"
       );
-      return pipe8(
+      return pipe(
         fragment`typeof input["${camelName}"] extends TransactionSigner<${typeParam}> ? ${signerRole}<${typeParam}> & AccountSignerMeta<${typeParam}> : ${typeParam}`,
         (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta", "type TransactionSigner"])
       );
     }
     return typeParam;
   });
-  return pipe8(
+  return pipe(
     mergeFragments([fragment`TProgramAddress`, ...accountTypeParamsFragments], (c) => c.join(", ")),
-    (f) => mapFragmentContent7(f, (c) => `${instructionTypeName}<${c}>`)
+    (f) => mapFragmentContent(f, (c) => `${instructionTypeName}<${c}>`)
   );
 }
 function getInputTypeCallFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath13(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
   const inputTypeName = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   if (instructionNode.accounts.length === 0) return fragment`${inputTypeName}`;
-  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase5(account.name)}`).join(", ");
+  const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase(account.name)}`).join(", ");
   return fragment`${inputTypeName}<${accountTypeParams}>`;
 }
-
-// src/fragments/instructionPage.ts
-import { logWarn } from "@codama/errors";
-import { camelCase as camelCase12, definedTypeNode as definedTypeNode2, structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3 } from "@codama/nodes";
-import {
-  findProgramNodeFromPath as findProgramNodeFromPath6,
-  getLastNodeFromPath as getLastNodeFromPath16,
-  visit as visit5
-} from "@codama/visitors-core";
-
-// src/fragments/instructionParseFunction.ts
-import { camelCase as camelCase11 } from "@codama/nodes";
-import { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath14, pipe as pipe9 } from "@codama/visitors-core";
 function getInstructionParseFunctionFragment(scope) {
-  const instructionNode = getLastNodeFromPath14(scope.instructionPath);
-  const programNode = findProgramNodeFromPath4(scope.instructionPath);
+  const instructionNode = getLastNodeFromPath(scope.instructionPath);
+  const programNode = 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"));
@@ -1752,7 +1779,7 @@ function getTypeFragment2(scope) {
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map((account, i) => {
       const docs = getDocblockFragment(account.docs ?? [], true);
-      const name = camelCase11(account.name);
+      const name = camelCase(account.name);
       return fragment`${docs}${name}${account.isOptional ? "?" : ""}: TAccountMetas[${i}]${account.isOptional ? " | undefined" : ""};`;
     }),
     (cs) => hasAccounts ? `
@@ -1786,7 +1813,7 @@ function getFunctionFragment(scope) {
     [
       fragment`${use("type Instruction", "solanaInstructions")}<TProgram>`,
       hasAccounts ? fragment`${use("type InstructionWithAccounts", "solanaInstructions")}<TAccountMetas>` : void 0,
-      hasData ? pipe9(
+      hasData ? pipe(
         fragment`InstructionWithData<ReadonlyUint8Array>`,
         (f) => addFragmentImports(f, "solanaInstructions", ["type InstructionWithData"]),
         (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
@@ -1824,7 +1851,7 @@ const getNextOptionalAccount = () => {
   }
   const accounts = mergeFragments(
     scope.instructionNode.accounts.map(
-      (account) => account.isOptional ? fragment`${camelCase11(account.name)}: getNextOptionalAccount()` : fragment`${camelCase11(account.name)}: getNextAccount()`
+      (account) => account.isOptional ? fragment`${camelCase(account.name)}: getNextOptionalAccount()` : fragment`${camelCase(account.name)}: getNextAccount()`
     ),
     (cs) => hasAccounts ? `, accounts: { ${cs.join(", ")} }` : ""
   );
@@ -1834,15 +1861,10 @@ const getNextOptionalAccount = () => {
   return { programAddress: instruction.programAddress${accounts}${data} };
 }`;
 }
-
-// src/fragments/instructionType.ts
-import { pascalCase as pascalCase6 } from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent8 } from "@codama/renderers-core";
-import { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath15 } from "@codama/visitors-core";
 function getInstructionTypeFragment2(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath15(instructionPath);
-  const programNode = findProgramNodeFromPath5(instructionPath);
+  const instructionNode = getLastNodeFromPath(instructionPath);
+  const programNode = findProgramNodeFromPath(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
@@ -1852,7 +1874,6 @@ function getInstructionTypeFragment2(scope) {
     instructionNode.accounts.map(
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
-        allowAccountMeta: true,
         instructionAccountPath: [...instructionPath, account]
       })
     ),
@@ -1862,8 +1883,8 @@ function getInstructionTypeFragment2(scope) {
   const usesLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted";
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
-      (account) => mapFragmentContent8(getInstructionAccountMetaFragment(account), (c) => {
-        const typeParam = `TAccount${pascalCase6(account.name)}`;
+      (account) => mapFragmentContent(getInstructionAccountMetaFragment(account), (c) => {
+        const typeParam = `TAccount${pascalCase(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
         const type = `${typeParam} extends string ? ${c} : ${typeParam}`;
         if (!isLegacyOptional) return type;
@@ -1880,17 +1901,17 @@ ${use("type Instruction", "solanaInstructions")}<TProgram>${data}${accounts};`;
 
 // src/fragments/instructionPage.ts
 function getInstructionPageFragment(scope) {
-  const node = getLastNodeFromPath16(scope.instructionPath);
-  if (!findProgramNodeFromPath6(scope.instructionPath)) {
+  const node = getLastNodeFromPath(scope.instructionPath);
+  if (!findProgramNodeFromPath(scope.instructionPath)) {
     throw new Error("Instruction must be visited inside a program.");
   }
   const childScope = {
     ...scope,
-    dataArgsManifest: visit5(node, scope.typeManifestVisitor),
-    extraArgsManifest: visit5(
-      definedTypeNode2({
+    dataArgsManifest: visit(node, scope.typeManifestVisitor),
+    extraArgsManifest: visit(
+      definedTypeNode({
         name: scope.nameApi.instructionExtraType(node.name),
-        type: structTypeNodeFromInstructionArgumentNodes3(node.extraArguments ?? [])
+        type: structTypeNodeFromInstructionArgumentNodes(node.extraArguments ?? [])
       }),
       scope.typeManifestVisitor
     ),
@@ -1929,14 +1950,10 @@ function getRenamedArgsMap(instruction) {
   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) => [camelCase12(name), camelCase12(`${name}Arg`)]));
+  return new Map(duplicates.map((name) => [camelCase(name), camelCase(`${name}Arg`)]));
 }
-
-// src/fragments/pdaFunction.ts
-import { camelCase as camelCase13, isNode as isNode13, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
-import { findProgramNodeFromPath as findProgramNodeFromPath7, getLastNodeFromPath as getLastNodeFromPath17, visit as visit6 } from "@codama/visitors-core";
 function getPdaFunctionFragment(scope) {
-  const pdaNode = getLastNodeFromPath17(scope.pdaPath);
+  const pdaNode = getLastNodeFromPath(scope.pdaPath);
   const seeds = parsePdaSeedNodes(pdaNode.seeds, scope);
   return mergeFragments(
     [getSeedInputTypeFragment(seeds, scope), getFunctionFragment2(seeds, scope)],
@@ -1944,9 +1961,9 @@ function getPdaFunctionFragment(scope) {
   );
 }
 function getSeedInputTypeFragment(seeds, scope) {
-  const variableSeeds = seeds.filter(isNodeFilter5("variablePdaSeedNode"));
+  const variableSeeds = seeds.filter(isNodeFilter("variablePdaSeedNode"));
   if (variableSeeds.length === 0) return;
-  const pdaNode = getLastNodeFromPath17(scope.pdaPath);
+  const pdaNode = getLastNodeFromPath(scope.pdaPath);
   const seedTypeName = scope.nameApi.pdaSeedsType(pdaNode.name);
   const seedAttributes = mergeFragments(
     variableSeeds.map((seed) => seed.inputAttribute),
@@ -1955,15 +1972,15 @@ function getSeedInputTypeFragment(seeds, scope) {
   return fragment`export type ${seedTypeName} = {\n${seedAttributes}\n};`;
 }
 function getFunctionFragment2(seeds, scope) {
-  const pdaNode = getLastNodeFromPath17(scope.pdaPath);
-  const programNode = findProgramNodeFromPath7(scope.pdaPath);
+  const pdaNode = getLastNodeFromPath(scope.pdaPath);
+  const programNode = 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(isNodeFilter5("variablePdaSeedNode")).length > 0;
+  const hasVariableSeeds = seeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
   const seedArgument = hasVariableSeeds ? `seeds: ${seedTypeName}, ` : "";
   const programAddress = pdaNode.programId ?? programNode.publicKey;
   const encodedSeeds = mergeFragments(
@@ -1977,39 +1994,31 @@ function getFunctionFragment2(seeds, scope) {
 }
 function parsePdaSeedNodes(seeds, scope) {
   return seeds.map((seed) => {
-    if (isNode13(seed, "variablePdaSeedNode")) {
-      const name = camelCase13(seed.name);
+    if (isNode(seed, "variablePdaSeedNode")) {
+      const name = camelCase(seed.name);
       const docs = getDocblockFragment(seed.docs ?? [], true);
-      const { encoder: encoder2, looseType } = visit6(seed.type, scope.typeManifestVisitor);
+      const { encoder: encoder2, looseType } = visit(seed.type, scope.typeManifestVisitor);
       return {
         ...seed,
         encodedValue: fragment`${encoder2}.encode(seeds.${name})`,
         inputAttribute: fragment`${docs}${name}: ${looseType};`
       };
     }
-    if (isNode13(seed.value, "programIdValueNode")) {
+    if (isNode(seed.value, "programIdValueNode")) {
       const addressEncoder = use("getAddressEncoder", "solanaAddresses");
       return { ...seed, encodedValue: fragment`${addressEncoder}().encode(programAddress)` };
     }
-    const { encoder } = visit6(seed.type, scope.typeManifestVisitor);
-    const { value } = visit6(seed.value, scope.typeManifestVisitor);
+    const { encoder } = visit(seed.type, scope.typeManifestVisitor);
+    const { value } = visit(seed.value, scope.typeManifestVisitor);
     return { ...seed, encodedValue: fragment`${encoder}.encode(${value})` };
   });
 }
-
-// src/fragments/pdaPage.ts
-import { findProgramNodeFromPath as findProgramNodeFromPath8 } from "@codama/visitors-core";
 function getPdaPageFragment(scope) {
-  if (!findProgramNodeFromPath8(scope.pdaPath)) {
+  if (!findProgramNodeFromPath(scope.pdaPath)) {
     throw new Error("PDA must be visited inside a program.");
   }
   return getPdaFunctionFragment(scope);
 }
-
-// src/fragments/programAccounts.ts
-import { resolveNestedTypeNode as resolveNestedTypeNode3 } from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent9 } from "@codama/renderers-core";
-import { pipe as pipe10 } from "@codama/visitors-core";
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return;
   return mergeFragments(
@@ -2034,7 +2043,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
   if (!hasAccountDiscriminators) return;
   const programAccountsEnum = nameApi.programAccountsEnum(programNode.name);
   const programAccountsIdentifierFunction = nameApi.programAccountsIdentifierFunction(programNode.name);
-  return pipe10(
+  return pipe(
     mergeFragments(
       accountsWithDiscriminators.map((account) => {
         const variant = nameApi.programAccountsEnumVariant(account.name);
@@ -2043,12 +2052,12 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
           dataName: "data",
           discriminators: account.discriminators ?? [],
           ifTrue: `return ${programAccountsEnum}.${variant};`,
-          struct: resolveNestedTypeNode3(account.data)
+          struct: resolveNestedTypeNode(account.data)
         });
       }),
       (c) => c.join("\n")
     ),
-    (f) => mapFragmentContent9(
+    (f) => mapFragmentContent(
       f,
       (discriminators) => `export function ${programAccountsIdentifierFunction}(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programAccountsEnum} {
 const data = 'data' in account ? account.data : account;
@@ -2059,25 +2068,14 @@ throw new Error("The provided account could not be identified as a ${programNode
     (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
   );
 }
-
-// src/fragments/programConstant.ts
-import { pipe as pipe11 } from "@codama/visitors-core";
 function getProgramConstantFragment(scope) {
   const { programNode, nameApi } = scope;
   const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  return pipe11(
+  return pipe(
     fragment`export const ${programAddressConstant} = '${programNode.publicKey}' as Address<'${programNode.publicKey}'>;`,
     (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
   );
 }
-
-// src/fragments/programInstructions.ts
-import {
-  getAllInstructionsWithSubs,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
-} from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent10 } from "@codama/renderers-core";
-import { pipe as pipe12 } from "@codama/visitors-core";
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return;
   const allInstructions = getAllInstructionsWithSubs(scope.programNode, {
@@ -2119,14 +2117,14 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: structTypeNodeFromInstructionArgumentNodes4(instruction.arguments)
+        struct: structTypeNodeFromInstructionArgumentNodes(instruction.arguments)
       });
     }),
     (c) => c.join("\n")
   );
-  return pipe12(
+  return pipe(
     discriminatorsFragment,
-    (f) => mapFragmentContent10(
+    (f) => mapFragmentContent(
       f,
       (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
 const data = 'data' in instruction ? instruction.data : instruction;
@@ -2186,9 +2184,6 @@ function getRootIndexPageFragment(scope) {
     (cs) => cs.join("\n")
   );
 }
-
-// src/fragments/sharedPage.ts
-import { pipe as pipe13 } from "@codama/visitors-core";
 function getSharedPageFragment() {
   const sharedPage = fragment`/**
  * Asserts that the given value is not null or undefined.
@@ -2289,7 +2284,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 pipe13(
+  return pipe(
     sharedPage,
     (f) => addFragmentImports(f, "solanaAddresses", [
       "type Address",
@@ -2304,12 +2299,9 @@ export function isTransactionSigner<TAddress extends string = string>(value: Add
     ])
   );
 }
-
-// src/fragments/typeDiscriminatedUnionHelpers.ts
-import { isDataEnum as isDataEnum3, isNode as isNode14 } from "@codama/nodes";
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = isNode14(typeNode, "enumTypeNode") && isDataEnum3(typeNode);
+  const isDiscriminatedUnion = isNode(typeNode, "enumTypeNode") && isDataEnum(typeNode);
   if (!isDiscriminatedUnion) return;
   const functionName = nameApi.discriminatedUnionFunction(name);
   const isDiscriminatedUnionFunctionName = nameApi.isDiscriminatedUnionFunction(name);
@@ -2321,10 +2313,10 @@ function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const variantSignatures = mergeFragments(
     typeNode.variants.map((variant) => {
       const variantName = nameApi.discriminatedUnionVariant(variant.name);
-      if (isNode14(variant, "enumStructVariantTypeNode")) {
+      if (isNode(variant, "enumStructVariantTypeNode")) {
         return fragment`export function ${functionName}(kind: '${variantName}', data: ${getVariantContentType}<${looseName}, '${discriminatorName}', '${variantName}'>): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
       }
-      if (isNode14(variant, "enumTupleVariantTypeNode")) {
+      if (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}'>;`;
@@ -2342,13 +2334,10 @@ export function ${isDiscriminatedUnionFunctionName}<K extends ${strictName}['${d
 };
 `;
 }
-
-// src/fragments/typePage.ts
-import { pipe as pipe14, visit as visit7 } from "@codama/visitors-core";
 function getTypePageFragment(scope) {
   const node = scope.node;
-  const manifest = visit7(node, scope.typeManifestVisitor);
-  return pipe14(
+  const manifest = visit(node, scope.typeManifestVisitor);
+  return pipe(
     mergeFragments(
       [
         getTypeWithCodecFragment({ ...scope, manifest, name: node.name, node: node.type, typeDocs: node.docs }),
@@ -2365,35 +2354,11 @@ function getTypePageFragment(scope) {
     ])
   );
 }
-
-// src/visitors/getTypeManifestVisitor.ts
-import {
-  camelCase as camelCase14,
-  isNode as isNode15,
-  isNodeFilter as isNodeFilter6,
-  isScalarEnum,
-  REGISTERED_TYPE_NODE_KINDS,
-  REGISTERED_VALUE_NODE_KINDS,
-  resolveNestedTypeNode as resolveNestedTypeNode4,
-  structFieldTypeNode,
-  structTypeNode,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes5
-} from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent11, setFragmentContent as setFragmentContent2 } from "@codama/renderers-core";
-import {
-  extendVisitor,
-  findLastNodeFromPath,
-  NodeStack,
-  pipe as pipe15,
-  recordNodeStackVisitor,
-  staticVisitor,
-  visit as visit8
-} from "@codama/visitors-core";
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
   const stack = input.stack ?? new NodeStack();
   let parentName = null;
-  return pipe15(
+  return pipe(
     staticVisitor(() => typeManifest(), {
       keys: [
         ...REGISTERED_TYPE_NODE_KINDS,
@@ -2411,15 +2376,15 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(account.name)
         };
         const link = customAccountData.get(account.name)?.linkNode;
-        const manifest = link ? visit8(link, self) : visit8(account.data, self);
+        const manifest = link ? visit(link, self) : visit(account.data, self);
         parentName = null;
         return manifest;
       },
       visitAmountType(amountType, { self }) {
-        return visit8(amountType.number, self);
+        return visit(amountType.number, self);
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = visit8(arrayType.item, self);
+        const childManifest = visit(arrayType.item, self);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
         const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
         const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
@@ -2433,16 +2398,16 @@ function getTypeManifestVisitor(input) {
       },
       visitArrayValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => visit8(v, self)),
+          node.items.map((v) => visit(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitBooleanType(booleanType, { self }) {
         let sizeEncoder = fragment``;
         let sizeDecoder = fragment``;
-        const resolvedSize = resolveNestedTypeNode4(booleanType.size);
+        const resolvedSize = resolveNestedTypeNode(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
-          const size = visit8(booleanType.size, self);
+          const size = visit(booleanType.size, self);
           sizeEncoder = fragment`{ size: ${size.encoder} }`;
           sizeDecoder = fragment`{ size: ${size.decoder} }`;
         }
@@ -2470,22 +2435,22 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ value: fragment`new Uint8Array([${Array.from(bytes).join(", ")}])` });
       },
       visitConstantValue(node, { self }) {
-        if (isNode15(node.type, "bytesTypeNode") && isNode15(node.value, "bytesValueNode")) {
-          return visit8(node.value, self);
+        if (isNode(node.type, "bytesTypeNode") && isNode(node.value, "bytesValueNode")) {
+          return visit(node.value, self);
         }
         return typeManifest({
-          value: fragment`${visit8(node.type, self).encoder}.encode(${visit8(node.value, self).value})`
+          value: fragment`${visit(node.type, self).encoder}.encode(${visit(node.value, self).value})`
         });
       },
       visitDateTimeType(dateTimeType, { self }) {
-        return visit8(dateTimeType.number, self);
+        return visit(dateTimeType.number, self);
       },
       visitDefinedType(definedType, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(definedType.name),
           strict: nameApi.dataType(definedType.name)
         };
-        const manifest = visit8(definedType.type, self);
+        const manifest = visit(definedType.type, self);
         parentName = null;
         return manifest;
       },
@@ -2503,7 +2468,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase14(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return typeManifest({
@@ -2516,31 +2481,31 @@ function getTypeManifestVisitor(input) {
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase14(currentParentName?.strict ?? "")
+          camelCase(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         parentName = null;
-        const structManifest = visit8(enumStructVariantType.struct, self);
+        const structManifest = visit(enumStructVariantType.struct, self);
         parentName = currentParentName;
         return typeManifest({
           ...structManifest,
           decoder: fragment`['${name}', ${structManifest.decoder}]`,
           encoder: fragment`['${name}', ${structManifest.encoder}]`,
-          looseType: pipe15(
+          looseType: pipe(
             structManifest.looseType,
-            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           ),
-          strictType: pipe15(
+          strictType: pipe(
             structManifest.strictType,
-            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           )
         });
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase14(currentParentName?.strict ?? "")
+          camelCase(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -2551,19 +2516,19 @@ function getTypeManifestVisitor(input) {
           })
         ]);
         parentName = null;
-        const structManifest = visit8(struct, self);
+        const structManifest = visit(struct, self);
         parentName = currentParentName;
         return typeManifest({
           ...structManifest,
           decoder: fragment`['${name}', ${structManifest.decoder}]`,
           encoder: fragment`['${name}', ${structManifest.encoder}]`,
-          looseType: pipe15(
+          looseType: pipe(
             structManifest.looseType,
-            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           ),
-          strictType: pipe15(
+          strictType: pipe(
             structManifest.strictType,
-            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+            (f) => mapFragmentContent(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           )
         });
       },
@@ -2571,14 +2536,14 @@ function getTypeManifestVisitor(input) {
         const currentParentName = parentName;
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = resolveNestedTypeNode4(enumType.size);
+        const enumSize = resolveNestedTypeNode(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
-          const sizeManifest = visit8(enumType.size, self);
+          const sizeManifest = visit(enumType.size, self);
           encoderOptions.push(fragment`size: ${sizeManifest.encoder}`);
           decoderOptions.push(fragment`size: ${sizeManifest.decoder}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase14(currentParentName?.strict ?? "")
+          camelCase(currentParentName?.strict ?? "")
         );
         if (!isScalarEnum(enumType) && discriminator !== "__kind") {
           encoderOptions.push(fragment`discriminator: '${discriminator}'`);
@@ -2608,7 +2573,7 @@ function getTypeManifestVisitor(input) {
           });
         }
         const mergedManifest = mergeTypeManifests(
-          enumType.variants.map((variant) => visit8(variant, self)),
+          enumType.variants.map((variant) => visit(variant, self)),
           {
             mergeCodecs: (renders) => renders.join(", "),
             mergeTypes: (renders) => renders.join(" | ")
@@ -2626,14 +2591,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 && isNode15(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && isNode(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
           return typeManifest({
             ...manifest,
-            value: pipe15(
+            value: pipe(
               manifest.value,
-              (f) => setFragmentContent2(f, `${enumName}.${variantName2}`),
+              (f) => setFragmentContent(f, `${enumName}.${variantName2}`),
               (f) => addFragmentImports(f, importFrom, [enumName])
             )
           });
@@ -2642,24 +2607,24 @@ function getTypeManifestVisitor(input) {
         if (!node.value) {
           return typeManifest({
             ...manifest,
-            value: pipe15(
+            value: pipe(
               manifest.value,
-              (f) => setFragmentContent2(f, `${enumFunction}('${variantName}')`),
+              (f) => setFragmentContent(f, `${enumFunction}('${variantName}')`),
               (f) => addFragmentImports(f, importFrom, [enumFunction])
             )
           });
         }
         return typeManifest({
           ...manifest,
-          value: pipe15(
-            visit8(node.value, self).value,
-            (f) => mapFragmentContent11(f, (c) => `${enumFunction}('${variantName}', ${c})`),
+          value: pipe(
+            visit(node.value, self).value,
+            (f) => mapFragmentContent(f, (c) => `${enumFunction}('${variantName}', ${c})`),
             (f) => addFragmentImports(f, importFrom, [enumFunction])
           )
         });
       },
       visitFixedSizeType(node, { self }) {
-        const manifest = visit8(node.type, self);
+        const manifest = visit(node.type, self);
         return typeManifest({
           ...manifest,
           decoder: fragment`${use("fixDecoderSize", "solanaCodecsCore")}(${manifest.decoder}, ${node.size})`,
@@ -2667,13 +2632,13 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitHiddenPrefixType(node, { self }) {
-        const manifest = visit8(node.type, self);
-        const prefixes = node.prefix.map((c) => visit8(c, self).value);
-        const prefixEncoders = pipe15(
+        const manifest = visit(node.type, self);
+        const prefixes = node.prefix.map((c) => visit(c, self).value);
+        const prefixEncoders = pipe(
           mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantEncoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
         );
-        const prefixDecoders = pipe15(
+        const prefixDecoders = pipe(
           mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
         );
@@ -2684,13 +2649,13 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitHiddenSuffixType(node, { self }) {
-        const manifest = visit8(node.type, self);
-        const suffixes = node.suffix.map((c) => visit8(c, self).value);
-        const suffixEncoders = pipe15(
+        const manifest = visit(node.type, self);
+        const suffixes = node.suffix.map((c) => visit(c, self).value);
+        const suffixEncoders = pipe(
           mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantEncoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
         );
-        const suffixDecoders = pipe15(
+        const suffixDecoders = pipe(
           mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
         );
@@ -2707,19 +2672,19 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = structTypeNodeFromInstructionArgumentNodes5(instruction.arguments);
-        const manifest = link ? visit8(link, self) : visit8(struct, self);
+        const struct = structTypeNodeFromInstructionArgumentNodes(instruction.arguments);
+        const manifest = link ? visit(link, self) : visit(struct, self);
         parentName = null;
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeTypeManifests([visit8(node.key, self), visit8(node.value, self)], {
+        return mergeTypeManifests([visit(node.key, self), visit(node.value, self)], {
           mergeValues: (renders) => `[${renders.join(", ")}]`
         });
       },
       visitMapType(mapType, { self }) {
-        const key = visit8(mapType.key, self);
-        const value = visit8(mapType.value, self);
+        const key = visit(mapType.key, self);
+        const value = visit(mapType.value, self);
         const mergedManifest = mergeTypeManifests([key, value], {
           mergeCodecs: ([k, v]) => `${k}, ${v}`,
           mergeTypes: ([k, v]) => `Map<${k}, ${v}>`
@@ -2734,7 +2699,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitMapValue(node, { self }) {
-        const entryFragments = node.entries.map((entry) => visit8(entry, self));
+        const entryFragments = node.entries.map((entry) => visit(entry, self));
         return mergeTypeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
@@ -2760,12 +2725,12 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ value: fragment`${JSON.stringify(node.number)}` });
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visit8(optionType.item, self);
+        const childManifest = visit(optionType.item, self);
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = resolveNestedTypeNode4(optionType.prefix);
+        const optionPrefix = resolveNestedTypeNode(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = visit8(optionType.prefix, self);
+          const prefixManifest = visit(optionType.prefix, self);
           encoderOptions.push(fragment`prefix: ${prefixManifest.encoder}`);
           decoderOptions.push(fragment`prefix: ${prefixManifest.decoder}`);
         }
@@ -2790,7 +2755,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitPostOffsetType(node, { self }) {
-        const manifest = visit8(node.type, self);
+        const manifest = visit(node.type, self);
         if (node.strategy === "padded") {
           return typeManifest({
             ...manifest,
@@ -2816,7 +2781,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitPreOffsetType(node, { self }) {
-        const manifest = visit8(node.type, self);
+        const manifest = visit(node.type, self);
         if (node.strategy === "padded") {
           return typeManifest({
             ...manifest,
@@ -2853,7 +2818,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = visit8(node.item, self);
+        const childManifest = visit(node.item, self);
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
         const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
@@ -2867,8 +2832,8 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSentinelType(node, { self }) {
-        const manifest = visit8(node.type, self);
-        const sentinel = visit8(node.sentinel, self).value;
+        const manifest = visit(node.type, self);
+        const sentinel = visit(node.sentinel, self).value;
         return typeManifest({
           ...manifest,
           decoder: fragment`${use("addDecoderSentinel", "solanaCodecsCore")}(${manifest.decoder}, ${sentinel})`,
@@ -2876,7 +2841,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSetType(setType, { self }) {
-        const childManifest = visit8(setType.item, self);
+        const childManifest = visit(setType.item, self);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
         const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
         const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
@@ -2890,13 +2855,13 @@ function getTypeManifestVisitor(input) {
       },
       visitSetValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => visit8(v, self)),
+          node.items.map((v) => visit(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
       },
       visitSizePrefixType(node, { self }) {
-        const manifest = visit8(node.type, self);
-        const prefix = visit8(node.prefix, self);
+        const manifest = visit(node.type, self);
+        const prefix = visit(node.prefix, self);
         return typeManifest({
           ...manifest,
           decoder: fragment`${use("addDecoderSizePrefix", "solanaCodecsCore")}(${manifest.decoder}, ${prefix.decoder})`,
@@ -2904,7 +2869,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSolAmountType({ number }, { self }) {
-        const numberManifest = visit8(number, self);
+        const numberManifest = visit(number, self);
         return typeManifest({
           ...numberManifest,
           decoder: fragment`${use("getLamportsDecoder", "solanaRpcTypes")}(${numberManifest.decoder})`,
@@ -2914,7 +2879,7 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitSomeValue(node, { self }) {
-        const innerValue = visit8(node.value, self).value;
+        const innerValue = visit(node.value, self).value;
         return typeManifest({
           value: fragment`${use("some", "solanaOptions")}(${innerValue})`
         });
@@ -2947,8 +2912,8 @@ function getTypeManifestVisitor(input) {
         });
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = camelCase14(structFieldType.name);
-        const originalChildManifest = visit8(structFieldType.type, self);
+        const name = camelCase(structFieldType.name);
+        const originalChildManifest = visit(structFieldType.type, self);
         let docs = getDocblockFragment(structFieldType.docs ?? [], true);
         docs = docs ? fragment`\n${docs}` : docs;
         const childManifest = typeManifest({
@@ -2970,16 +2935,16 @@ function getTypeManifestVisitor(input) {
         return typeManifest({ ...childManifest, looseType: fragment`` });
       },
       visitStructFieldValue(node, { self }) {
-        const innerValue = visit8(node.value, self).value;
+        const innerValue = 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 = pipe15(
+        const mergedManifest = pipe(
           mergeTypeManifests(
-            structType.fields.map((field) => visit8(field, self)),
+            structType.fields.map((field) => visit(field, self)),
             {
               mergeCodecs: (renders) => `([${renders.join(", ")}])`,
               mergeTypes: (renders) => `{ ${renders.join("")} }`
@@ -2999,16 +2964,16 @@ function getTypeManifestVisitor(input) {
         const accountNode = findLastNodeFromPath(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
-        const fieldDiscriminators = discriminators.filter(isNodeFilter6("fieldDiscriminatorNode"));
+        const fieldDiscriminators = discriminators.filter(isNodeFilter("fieldDiscriminatorNode"));
         const defaultValues = mergeFragments(
           optionalFields.map((f) => {
-            const key = camelCase14(f.name);
+            const key = camelCase(f.name);
             if (fieldDiscriminators.some((d) => d.name === f.name)) {
-              const constantName = nameApi.constant(camelCase14(`${discriminatorPrefix}_${f.name}`));
+              const constantName = nameApi.constant(camelCase(`${discriminatorPrefix}_${f.name}`));
               return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${constantName}` : fragment`${key}: value.${key} ?? ${constantName}`;
             }
             const defaultValue = f.defaultValue;
-            const value = visit8(defaultValue, self).value;
+            const value = visit(defaultValue, self).value;
             return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${value}` : fragment`${key}: value.${key} ?? ${value}`;
           }),
           (cs) => cs.join(", ")
@@ -3020,12 +2985,12 @@ function getTypeManifestVisitor(input) {
       },
       visitStructValue(node, { self }) {
         return mergeTypeManifests(
-          node.fields.map((field) => visit8(field, self)),
+          node.fields.map((field) => visit(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visit8(item, self));
+        const items = tupleType.items.map((item) => visit(item, self));
         const mergedManifest = mergeTypeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
@@ -3038,16 +3003,16 @@ function getTypeManifestVisitor(input) {
       },
       visitTupleValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => visit8(v, self)),
+          node.items.map((v) => visit(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = visit8(node.item, self);
+        const childManifest = visit(node.item, self);
         const encoderOptions = [fragment`prefix: null`];
         const decoderOptions = [fragment`prefix: null`];
         if (node.zeroValue) {
-          const zeroValueManifest = visit8(node.zeroValue, self);
+          const zeroValueManifest = visit(node.zeroValue, self);
           encoderOptions.push(fragment`noneValue: ${zeroValueManifest.value}`);
           decoderOptions.push(fragment`noneValue: ${zeroValueManifest.value}`);
         } else {
@@ -3075,50 +3040,51 @@ function getTypeManifestVisitor(input) {
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if (isNode15(count, "fixedCountNode")) {
+  if (isNode(count, "fixedCountNode")) {
     return {
       decoder: fragment`size: ${count.value}`,
       encoder: fragment`size: ${count.value}`
     };
   }
-  if (isNode15(count, "remainderCountNode")) {
+  if (isNode(count, "remainderCountNode")) {
     return {
       decoder: fragment`size: 'remainder'`,
       encoder: fragment`size: 'remainder'`
     };
   }
-  const prefix = resolveNestedTypeNode4(count.prefix);
+  const prefix = resolveNestedTypeNode(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: void 0, encoder: void 0 };
   }
-  const prefixManifest = visit8(count.prefix, visitor);
+  const prefixManifest = visit(count.prefix, visitor);
   return {
-    decoder: pipe15(prefixManifest.decoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`)),
-    encoder: pipe15(prefixManifest.encoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`))
+    decoder: pipe(prefixManifest.decoder, (f) => mapFragmentContent(f, (c) => `size: ${c}`)),
+    encoder: pipe(prefixManifest.encoder, (f) => mapFragmentContent(f, (c) => `size: ${c}`))
   };
 }
 
 // src/visitors/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
-  const linkables = new LinkableDictionary3();
-  const stack = new NodeStack2();
+  const linkables = new LinkableDictionary();
+  const stack = new NodeStack();
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
   const renderScopeWithTypeManifestVisitor = {
-    asyncResolvers: (options.asyncResolvers ?? []).map(camelCase15),
+    asyncResolvers: (options.asyncResolvers ?? []).map(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(camelCase15),
+    nonScalarEnums: (options.nonScalarEnums ?? []).map(camelCase),
     renderParentInstructions: options.renderParentInstructions ?? false,
     useGranularImports: options.useGranularImports ?? false
   };
   const typeManifestVisitor = getTypeManifestVisitor({ ...renderScopeWithTypeManifestVisitor, stack });
   const renderScope = { ...renderScopeWithTypeManifestVisitor, typeManifestVisitor };
-  const internalNodes = (options.internalNodes ?? []).map(camelCase15);
+  const internalNodes = (options.internalNodes ?? []).map(camelCase);
   const resolvedInstructionInputVisitor = getResolvedInstructionInputsVisitor();
   const byteSizeVisitor = getByteSizeVisitor(linkables, { stack });
   const asPage = (fragment2, dependencyMap = {}) => {
@@ -3128,47 +3094,47 @@ function getRenderMapVisitor(options = {}) {
       dependencyMap: { ...renderScope.dependencyMap, ...dependencyMap }
     });
   };
-  return pipe16(
-    staticVisitor2(() => createRenderMap(), {
+  return pipe(
+    staticVisitor(() => createRenderMap(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
-    (v) => extendVisitor2(v, {
+    (v) => extendVisitor(v, {
       visitAccount(node) {
         return createRenderMap(
-          `accounts/${camelCase15(node.name)}.ts`,
+          `accounts/${camelCase(node.name)}.ts`,
           asPage(
             getAccountPageFragment({
               ...renderScope,
               accountPath: stack.getPath("accountNode"),
-              size: visit9(node, byteSizeVisitor)
+              size: visit(node, byteSizeVisitor)
             })
           )
         );
       },
       visitDefinedType(node) {
         return createRenderMap(
-          `types/${camelCase15(node.name)}.ts`,
-          asPage(getTypePageFragment({ ...renderScope, node, size: visit9(node, byteSizeVisitor) }), {
+          `types/${camelCase(node.name)}.ts`,
+          asPage(getTypePageFragment({ ...renderScope, node, size: visit(node, byteSizeVisitor) }), {
             generatedTypes: "."
           })
         );
       },
       visitInstruction(node) {
         return createRenderMap(
-          `instructions/${camelCase15(node.name)}.ts`,
+          `instructions/${camelCase(node.name)}.ts`,
           asPage(
             getInstructionPageFragment({
               ...renderScope,
               instructionPath: stack.getPath("instructionNode"),
-              resolvedInputs: visit9(node, resolvedInstructionInputVisitor),
-              size: visit9(node, byteSizeVisitor)
+              resolvedInputs: visit(node, resolvedInstructionInputVisitor),
+              size: visit(node, byteSizeVisitor)
             })
           )
         );
       },
       visitPda(node) {
         return createRenderMap(
-          `pdas/${camelCase15(node.name)}.ts`,
+          `pdas/${camelCase(node.name)}.ts`,
           asPage(getPdaPageFragment({ ...renderScope, pdaPath: stack.getPath("pdaNode") }))
         );
       },
@@ -3180,15 +3146,15 @@ function getRenderMapVisitor(options = {}) {
         const scope = { ...renderScope, programNode: node };
         return mergeRenderMaps([
           createRenderMap({
-            [`programs/${camelCase15(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
-            [`errors/${camelCase15(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
+            [`programs/${camelCase(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
+            [`errors/${camelCase(node.name)}.ts`]: node.errors.length > 0 ? asPage(getErrorPageFragment(scope)) : void 0
           }),
-          ...node.pdas.map((p) => visit9(p, self)),
-          ...node.accounts.map((a) => visit9(a, self)),
-          ...node.definedTypes.map((t) => visit9(t, self)),
-          ...customDataDefinedType.map((t) => visit9(t, self)),
-          ...getAllInstructionsWithSubs2(node, { leavesOnly: !renderScope.renderParentInstructions }).map(
-            (i) => visit9(i, self)
+          ...node.pdas.map((p) => visit(p, self)),
+          ...node.accounts.map((a) => visit(a, self)),
+          ...node.definedTypes.map((t) => visit(t, self)),
+          ...customDataDefinedType.map((t) => visit(t, self)),
+          ...getAllInstructionsWithSubs(node, { leavesOnly: !renderScope.renderParentInstructions }).map(
+            (i) => visit(i, self)
           )
         ]);
       },
@@ -3198,13 +3164,12 @@ function getRenderMapVisitor(options = {}) {
         const programsWithErrorsToExport = programsToExport.filter((p) => p.errors.length > 0);
         const pdasToExport = getAllPdas(node);
         const accountsToExport = getAllAccounts(node).filter(isNotInternal);
-        const instructionsToExport = getAllInstructionsWithSubs2(node, {
+        const instructionsToExport = getAllInstructionsWithSubs(node, {
           leavesOnly: !renderScope.renderParentInstructions
         }).filter(isNotInternal);
         const definedTypesToExport = getAllDefinedTypes(node).filter(isNotInternal);
         const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const scope = {
-          ...renderScope,
           accountsToExport,
           definedTypesToExport,
           instructionsToExport,
@@ -3222,59 +3187,26 @@ function getRenderMapVisitor(options = {}) {
             ["shared/index.ts"]: hasAnythingToExport ? asPage(getSharedPageFragment()) : void 0,
             ["types/index.ts"]: asPage(getIndexPageFragment(definedTypesToExport))
           }),
-          ...getAllPrograms(node).map((p) => visit9(p, self))
+          ...getAllPrograms(node).map((p) => visit(p, self))
         ]);
       }
     }),
-    (v) => recordNodeStackVisitor2(v, stack),
+    (v) => recordNodeStackVisitor(v, stack),
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
-
-// src/visitors/renderVisitor.ts
-import { deleteDirectory, mapRenderMapContentAsync, writeRenderMap } from "@codama/renderers-core";
-import { rootNodeVisitor, visit as visit10 } from "@codama/visitors-core";
-import * as estreePlugin from "prettier/plugins/estree";
-import * as typeScriptPlugin from "prettier/plugins/typescript";
-import { format } from "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 rootNodeVisitor(async (root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    let renderMap = visit10(root, getRenderMapVisitor(options));
-    if (options.formatCode ?? true) {
-      const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      renderMap = await mapRenderMapContentAsync(renderMap, (code) => format(code, prettierOptions));
-    }
+    let renderMap = visit(root, getRenderMapVisitor(options));
+    renderMap = await formatCode(renderMap, options);
+    syncPackageJson(renderMap, options);
     writeRenderMap(renderMap, path);
   });
 }
-export {
-  DEFAULT_NAME_TRANSFORMERS,
-  addToImportMap,
-  createImportMap,
-  renderVisitor as default,
-  getNameApi,
-  getRenderMapVisitor,
-  getTypeManifestVisitor,
-  importMapToString,
-  mergeImportMaps,
-  mergeTypeManifests,
-  parseImportInput,
-  removeFromImportMap,
-  renderVisitor,
-  typeManifest
-};
+
+export { DEFAULT_NAME_TRANSFORMERS, addToImportMap, createImportMap, renderVisitor as default, getExternalDependencies, getNameApi, getRenderMapVisitor, getTypeManifestVisitor, importMapToString, mergeImportMaps, mergeTypeManifests, parseImportInput, removeFromImportMap, renderVisitor, typeManifest };
+//# sourceMappingURL=index.node.mjs.map
 //# sourceMappingURL=index.node.mjs.map