@codama/renderers-js 1.3.5 → 1.4.1

package/dist/index.node.mjs

@@ -1,4 +1,4 @@
-// src/ImportMap.ts
+// src/utils/importMap.ts
 var DEFAULT_EXTERNAL_MODULE_MAP = {
   solanaAccounts: "@solana/kit",
   solanaAddresses: "@solana/kit",
@@ -40,97 +40,256 @@ var DEFAULT_INTERNAL_MODULE_MAP = {
   shared: "../shared",
   types: "../types"
 };
-var ImportMap = class {
-  _imports = /* @__PURE__ */ new Map();
-  _aliases = /* @__PURE__ */ new Map();
-  add(module, imports) {
-    const newImports = new Set(typeof imports === "string" ? [imports] : imports);
-    if (newImports.size === 0) return this;
-    const currentImports = this._imports.get(module) ?? /* @__PURE__ */ new Set();
-    newImports.forEach((i) => currentImports.add(i));
-    this._imports.set(module, currentImports);
-    return this;
-  }
-  remove(module, imports) {
-    const importsToRemove = new Set(typeof imports === "string" ? [imports] : imports);
-    if (importsToRemove.size === 0) return this;
-    const currentImports = this._imports.get(module) ?? /* @__PURE__ */ new Set();
-    importsToRemove.forEach((i) => currentImports.delete(i));
-    if (currentImports.size === 0) {
-      this._imports.delete(module);
-    } else {
-      this._imports.set(module, currentImports);
-    }
-    return this;
-  }
-  mergeWith(...others) {
-    others.forEach((rawOther) => {
-      const other = "imports" in rawOther ? rawOther.imports : rawOther;
-      other._imports.forEach((imports, module) => {
-        this.add(module, imports);
-      });
-      other._aliases.forEach((aliases, module) => {
-        Object.entries(aliases).forEach(([name, alias]) => {
-          this.addAlias(module, name, alias);
-        });
-      });
-    });
-    return this;
-  }
-  mergeWithManifest(manifest) {
-    return this.mergeWith(manifest.strictType, manifest.looseType, manifest.encoder, manifest.decoder);
-  }
-  addAlias(module, name, alias) {
-    const currentAliases = this._aliases.get(module) ?? {};
-    currentAliases[name] = alias;
-    this._aliases.set(module, currentAliases);
-    return this;
-  }
-  isEmpty() {
-    return this._imports.size === 0;
-  }
-  resolve(dependencies = {}, useGranularImports = false) {
-    const aliasedMap = new Map(
-      [...this._imports.entries()].map(([module, imports]) => {
-        const aliasMap = this._aliases.get(module) ?? {};
-        const joinedImports = [...imports].map((i) => aliasMap[i] ? `${i} as ${aliasMap[i]}` : i);
-        return [module, new Set(joinedImports)];
-      })
-    );
-    const dependencyMap = {
-      ...useGranularImports ? DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP : DEFAULT_EXTERNAL_MODULE_MAP,
-      ...DEFAULT_INTERNAL_MODULE_MAP,
-      ...dependencies
-    };
-    const resolvedMap = /* @__PURE__ */ new Map();
-    aliasedMap.forEach((imports, module) => {
-      const resolvedModule = dependencyMap[module] ?? module;
-      const currentImports = resolvedMap.get(resolvedModule) ?? /* @__PURE__ */ new Set();
-      imports.forEach((i) => currentImports.add(i));
-      resolvedMap.set(resolvedModule, currentImports);
-    });
-    return resolvedMap;
+function createImportMap() {
+  return Object.freeze(/* @__PURE__ */ new Map());
+}
+function parseImportInput(input) {
+  const matches = input.match(/^(type )?([^ ]+)(?: as (.+))?$/);
+  if (!matches) return Object.freeze({ importedIdentifier: input, isType: false, usedIdentifier: input });
+  const [_, isType, name, alias] = matches;
+  return Object.freeze({
+    importedIdentifier: name,
+    isType: !!isType,
+    usedIdentifier: alias ?? name
+  });
+}
+function addToImportMap(importMap, module, imports) {
+  const parsedImports = imports.map(parseImportInput).map((i) => [i.usedIdentifier, i]);
+  return mergeImportMaps([importMap, /* @__PURE__ */ new Map([[module, new Map(parsedImports)]])]);
+}
+function removeFromImportMap(importMap, module, usedIdentifiers) {
+  const newMap = new Map(importMap);
+  const newModuleMap = new Map(newMap.get(module));
+  usedIdentifiers.forEach((usedIdentifier) => {
+    newModuleMap.delete(usedIdentifier);
+  });
+  if (newModuleMap.size === 0) {
+    newMap.delete(module);
+  } else {
+    newMap.set(module, newModuleMap);
   }
-  toString(dependencies = {}, useGranularImports = false) {
-    return [...this.resolve(dependencies, useGranularImports).entries()].sort(([a], [b]) => {
-      const aIsRelative = a.startsWith(".");
-      const bIsRelative = b.startsWith(".");
-      if (aIsRelative && !bIsRelative) return 1;
-      if (!aIsRelative && bIsRelative) return -1;
-      return a.localeCompare(b);
-    }).map(([module, imports]) => {
-      const joinedImports = [...imports].sort().filter((i) => {
-        const name = i.split(" ");
-        if (name.length > 1) {
-          return !imports.has(name[1]);
+  return Object.freeze(newMap);
+}
+function mergeImportMaps(importMaps) {
+  if (importMaps.length === 0) return createImportMap();
+  if (importMaps.length === 1) return importMaps[0];
+  const mergedMap = new Map(importMaps[0]);
+  for (const map of importMaps.slice(1)) {
+    for (const [module, imports] of map) {
+      const mergedModuleMap = mergedMap.get(module) ?? /* @__PURE__ */ new Map();
+      for (const [usedIdentifier, importInfo] of imports) {
+        const existingImportInfo = mergedModuleMap.get(usedIdentifier);
+        const shouldOverwriteTypeOnly = existingImportInfo && existingImportInfo.importedIdentifier === importInfo.importedIdentifier && existingImportInfo.isType && !importInfo.isType;
+        if (!existingImportInfo || shouldOverwriteTypeOnly) {
+          mergedModuleMap.set(usedIdentifier, importInfo);
         }
-        return true;
-      }).join(", ");
-      return `import { ${joinedImports} } from '${module}';`;
-    }).join("\n");
+      }
+      mergedMap.set(module, mergedModuleMap);
+    }
   }
+  return Object.freeze(mergedMap);
+}
+function importMapToString(importMap, dependencyMap = {}, useGranularImports = false) {
+  const resolvedMap = resolveImportMapModules(importMap, dependencyMap, useGranularImports);
+  return [...resolvedMap.entries()].sort(([a], [b]) => {
+    const relative = Number(a.startsWith(".")) - Number(b.startsWith("."));
+    if (relative !== 0) return relative;
+    return a.localeCompare(b);
+  }).map(([module, imports]) => {
+    const innerImports = [...imports.values()].map(importInfoToString).sort((a, b) => a.localeCompare(b)).join(", ");
+    return `import { ${innerImports} } from '${module}';`;
+  }).join("\n");
+}
+function resolveImportMapModules(importMap, dependencyMap, useGranularImports) {
+  const dependencyMapWithDefaults = {
+    ...useGranularImports ? DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP : DEFAULT_EXTERNAL_MODULE_MAP,
+    ...DEFAULT_INTERNAL_MODULE_MAP,
+    ...dependencyMap
+  };
+  return mergeImportMaps(
+    [...importMap.entries()].map(([module, imports]) => {
+      const resolvedModule = dependencyMapWithDefaults[module] ?? module;
+      return /* @__PURE__ */ new Map([[resolvedModule, imports]]);
+    })
+  );
+}
+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,
+    capitalize,
+    kebabCase,
+    pascalCase,
+    snakeCase,
+    titleCase
+  };
+  return Object.fromEntries(
+    Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
+  );
+}
+var DEFAULT_NAME_TRANSFORMERS = {
+  accountDecodeFunction: (name) => `decode${pascalCase(name)}`,
+  accountFetchAllFunction: (name) => `fetchAll${pascalCase(name)}`,
+  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${pascalCase(name)}`,
+  accountFetchFromSeedsFunction: (name) => `fetch${pascalCase(name)}FromSeeds`,
+  accountFetchFunction: (name) => `fetch${pascalCase(name)}`,
+  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${pascalCase(name)}FromSeeds`,
+  accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase(name)}`,
+  accountGetSizeFunction: (name) => `get${pascalCase(name)}Size`,
+  codecFunction: (name) => `get${pascalCase(name)}Codec`,
+  constant: (name) => snakeCase(name).toUpperCase(),
+  constantFunction: (name) => `get${pascalCase(name)}Bytes`,
+  dataArgsType: (name) => `${pascalCase(name)}Args`,
+  dataType: (name) => `${pascalCase(name)}`,
+  decoderFunction: (name) => `get${pascalCase(name)}Decoder`,
+  discriminatedUnionDiscriminator: () => "__kind",
+  discriminatedUnionFunction: (name) => `${camelCase(name)}`,
+  discriminatedUnionVariant: (name) => `${pascalCase(name)}`,
+  encoderFunction: (name) => `get${pascalCase(name)}Encoder`,
+  enumVariant: (name) => `${pascalCase(name)}`,
+  instructionAsyncFunction: (name) => `get${pascalCase(name)}InstructionAsync`,
+  instructionAsyncInputType: (name) => `${pascalCase(name)}AsyncInput`,
+  instructionDataType: (name) => `${pascalCase(name)}InstructionData`,
+  instructionExtraType: (name) => `${pascalCase(name)}InstructionExtra`,
+  instructionParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
+  instructionParsedType: (name) => `Parsed${pascalCase(name)}Instruction`,
+  instructionSyncFunction: (name) => `get${pascalCase(name)}Instruction`,
+  instructionSyncInputType: (name) => `${pascalCase(name)}Input`,
+  instructionType: (name) => `${pascalCase(name)}Instruction`,
+  isDiscriminatedUnionFunction: (name) => `is${pascalCase(name)}`,
+  pdaFindFunction: (name) => `find${pascalCase(name)}Pda`,
+  pdaSeedsType: (name) => `${pascalCase(name)}Seeds`,
+  programAccountsEnum: (name) => `${pascalCase(name)}Account`,
+  programAccountsEnumVariant: (name) => `${pascalCase(name)}`,
+  programAccountsIdentifierFunction: (name) => `identify${pascalCase(name)}Account`,
+  programAddressConstant: (name) => `${snakeCase(name).toUpperCase()}_PROGRAM_ADDRESS`,
+  programErrorConstant: (name) => snakeCase(name).toUpperCase(),
+  programErrorConstantPrefix: (name) => `${snakeCase(name).toUpperCase()}_ERROR__`,
+  programErrorMessagesMap: (name) => `${camelCase(name)}ErrorMessages`,
+  programErrorUnion: (name) => `${pascalCase(name)}Error`,
+  programGetErrorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
+  programInstructionsEnum: (name) => `${pascalCase(name)}Instruction`,
+  programInstructionsEnumVariant: (name) => `${pascalCase(name)}`,
+  programInstructionsIdentifierFunction: (name) => `identify${pascalCase(name)}Instruction`,
+  programInstructionsParsedUnionType: (name) => `Parsed${pascalCase(name)}Instruction`,
+  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() });
+}
+function isFragment(value) {
+  return typeof value === "object" && value !== null && "content" in value;
+}
+function fragment(template, ...items) {
+  return createFragmentTemplate(template, items, isFragment, mergeFragments);
+}
+function mergeFragments(fragments, mergeContent) {
+  const filteredFragments = fragments.filter((f) => f !== void 0);
+  return Object.freeze({
+    content: mergeContent(filteredFragments.map((fragment2) => fragment2.content)),
+    features: new Set(filteredFragments.flatMap((f) => [...f.features])),
+    imports: mergeImportMaps(filteredFragments.map((f) => f.imports))
+  });
+}
+function use(importInput, module) {
+  const importInfo = parseImportInput(importInput);
+  return addFragmentImports(createFragment(importInfo.usedIdentifier), module, [importInput]);
+}
+function mergeFragmentImports(fragment2, importMaps) {
+  return Object.freeze({ ...fragment2, imports: mergeImportMaps([fragment2.imports, ...importMaps]) });
+}
+function addFragmentImports(fragment2, module, importInputs) {
+  return Object.freeze({ ...fragment2, imports: addToImportMap(fragment2.imports, module, importInputs) });
+}
+function removeFragmentImports(fragment2, module, usedIdentifiers) {
+  return Object.freeze({ ...fragment2, imports: removeFromImportMap(fragment2.imports, module, usedIdentifiers) });
+}
+function addFragmentFeatures(fragment2, features) {
+  return Object.freeze({ ...fragment2, features: /* @__PURE__ */ new Set([...fragment2.features, ...features]) });
+}
+function getExportAllFragment(module) {
+  return fragment`export * from '${module}';`;
+}
+function getDocblockFragment(lines, withLineJump = false) {
+  const lineJump = withLineJump ? "\n" : "";
+  if (lines.length === 0) return;
+  if (lines.length === 1) return fragment`/** ${lines[0]} */${lineJump}`;
+  const prefixedLines = lines.map((line) => line ? ` * ${line}` : " *");
+  return fragment`/**\n${prefixedLines.join("\n")}\n */${lineJump}`;
+}
+function getPageFragment(page, scope) {
+  const header = getDocblockFragment([
+    "This code was AUTOGENERATED using the Codama library.",
+    "Please DO NOT EDIT THIS FILE, instead use visitors",
+    "to add features, then rerun Codama to update it.",
+    "",
+    "@see https://github.com/codama-idl/codama"
+  ]);
+  const imports = page.imports.size === 0 ? void 0 : fragment`${importMapToString(page.imports, scope.dependencyMap, scope.useGranularImports)}`;
+  return mergeFragments([header, imports, page], (cs) => cs.join("\n\n"));
+}
+
+// src/utils/typeManifest.ts
+function typeManifest(input = {}) {
+  return Object.freeze({
+    decoder: fragment``,
+    encoder: fragment``,
+    isEnum: false,
+    looseType: fragment``,
+    strictType: fragment``,
+    value: fragment``,
+    ...input
+  });
+}
+function mergeTypeManifests(manifests, options = {}) {
+  const { mergeTypes, mergeCodecs, mergeValues } = options;
+  const merge = (fragmentFn, mergeFn) => mergeFn ? mergeFragments(manifests.map(fragmentFn), mergeFn) : fragment``;
+  return Object.freeze({
+    decoder: merge((m) => m.decoder, mergeCodecs),
+    encoder: merge((m) => m.encoder, mergeCodecs),
+    isEnum: false,
+    looseType: merge((m) => m.looseType, mergeTypes),
+    strictType: merge((m) => m.strictType, mergeTypes),
+    value: merge((m) => m.value, mergeValues)
+  });
+}
+
+// src/visitors/getRenderMapVisitor.ts
+import {
+  camelCase as camelCase14,
+  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,
@@ -226,7 +385,7 @@ function getBytesFromBytesValueNode(node) {
 
 // src/utils/customData.ts
 import {
-  camelCase,
+  camelCase as camelCase2,
   definedTypeLinkNode,
   definedTypeNode,
   isNode as isNode2,
@@ -235,13 +394,13 @@ import {
 var parseCustomDataOptions = (customDataOptions, defaultSuffix) => new Map(
   customDataOptions.map((o) => {
     const options = typeof o === "string" ? { name: o } : o;
-    const importAs = camelCase(options.importAs ?? `${options.name}${defaultSuffix}`);
+    const importAs = camelCase2(options.importAs ?? `${options.name}${defaultSuffix}`);
     const importFrom = options.importFrom ?? "hooked";
     return [
-      camelCase(options.name),
+      camelCase2(options.name),
       {
         extract: options.extract ?? false,
-        extractAs: options.extractAs ? camelCase(options.extractAs) : importAs,
+        extractAs: options.extractAs ? camelCase2(options.extractAs) : importAs,
         importAs,
         importFrom,
         linkNode: definedTypeLinkNode(importAs)
@@ -263,74 +422,6 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
   ];
 });
 
-// src/utils/fragment.ts
-import { joinPath } from "@codama/renderers-core";
-
-// src/utils/render.ts
-import { dirname as pathDirname, join } from "path";
-import { fileURLToPath } from "url";
-import { camelCase as camelCase2, kebabCase, pascalCase, snakeCase, titleCase } from "@codama/nodes";
-import nunjucks from "nunjucks";
-function jsDocblock(docs) {
-  if (docs.length <= 0) return "";
-  if (docs.length === 1) return `/** ${docs[0]} */
-`;
-  const lines = docs.map((doc) => ` * ${doc}`);
-  return `/**
-${lines.join("\n")}
- */
-`;
-}
-var render = (template, context, options) => {
-  const dirname = true ? pathDirname(fileURLToPath(import.meta.url)) : __dirname;
-  const templates = false ? join(dirname, "..", "..", "public", "templates") : join(dirname, "templates");
-  const env = nunjucks.configure(templates, { autoescape: false, trimBlocks: true, ...options });
-  env.addFilter("pascalCase", pascalCase);
-  env.addFilter("camelCase", camelCase2);
-  env.addFilter("snakeCase", snakeCase);
-  env.addFilter("kebabCase", kebabCase);
-  env.addFilter("titleCase", titleCase);
-  env.addFilter("jsDocblock", jsDocblock);
-  return env.render(template, context);
-};
-
-// src/utils/fragment.ts
-function fragment(content) {
-  return Object.freeze({
-    content,
-    features: /* @__PURE__ */ new Set(),
-    imports: new ImportMap()
-  });
-}
-function fragmentFromTemplate(fragmentFile, context, options) {
-  return fragment(render(joinPath("fragments", fragmentFile), context, options));
-}
-function mergeFragments(fragments, mergeContent) {
-  return Object.freeze({
-    content: mergeContent(fragments.map((fragment2) => fragment2.content)),
-    features: new Set(fragments.flatMap((f) => [...f.features])),
-    imports: new ImportMap().mergeWith(...fragments.map((f) => f.imports))
-  });
-}
-function mergeFragmentImports(fragment2, importMaps) {
-  return Object.freeze({
-    ...fragment2,
-    imports: new ImportMap().mergeWith(fragment2.imports, ...importMaps)
-  });
-}
-function addFragmentImports(fragment2, module, imports) {
-  return Object.freeze({
-    ...fragment2,
-    imports: new ImportMap().mergeWith(fragment2.imports).add(module, imports)
-  });
-}
-function addFragmentFeatures(fragment2, features) {
-  return Object.freeze({
-    ...fragment2,
-    features: /* @__PURE__ */ new Set([...fragment2.features, ...features])
-  });
-}
-
 // src/utils/linkOverrides.ts
 import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
@@ -380,79 +471,62 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
   };
 }
 
-// src/TypeManifest.ts
-function typeManifest(input = {}) {
-  return Object.freeze({
-    decoder: fragment(""),
-    encoder: fragment(""),
-    isEnum: false,
-    looseType: fragment(""),
-    strictType: fragment(""),
-    value: fragment(""),
-    ...input
-  });
-}
-function mergeTypeManifests(manifests, options = {}) {
-  const { mergeTypes, mergeCodecs, mergeValues } = options;
-  const merge = (fragmentFn, mergeFn) => mergeFn ? mergeFragments(manifests.map(fragmentFn), mergeFn) : fragment("");
-  return Object.freeze({
-    decoder: merge((m) => m.decoder, mergeCodecs),
-    encoder: merge((m) => m.encoder, mergeCodecs),
-    isEnum: false,
-    looseType: merge((m) => m.looseType, mergeTypes),
-    strictType: merge((m) => m.strictType, mergeTypes),
-    value: merge((m) => m.value, mergeValues)
-  });
-}
-
-// src/getRenderMapVisitor.ts
-import { join as join2 } from "path";
-import { logWarn } from "@codama/errors";
-import {
-  camelCase as camelCase12,
-  definedTypeNode as definedTypeNode2,
-  getAllAccounts,
-  getAllDefinedTypes,
-  getAllInstructionsWithSubs as getAllInstructionsWithSubs2,
-  getAllPdas,
-  getAllPrograms,
-  resolveNestedTypeNode as resolveNestedTypeNode4,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes5
-} from "@codama/nodes";
-import { addToRenderMap, mergeRenderMaps, renderMap } from "@codama/renderers-core";
-import {
-  extendVisitor as extendVisitor2,
-  findProgramNodeFromPath as findProgramNodeFromPath7,
-  getByteSizeVisitor,
-  getResolvedInstructionInputsVisitor,
-  LinkableDictionary as LinkableDictionary3,
-  NodeStack as NodeStack2,
-  pipe as pipe25,
-  recordLinkablesOnFirstVisitVisitor,
-  recordNodeStackVisitor as recordNodeStackVisitor2,
-  staticVisitor as staticVisitor2,
-  visit as visit6
-} from "@codama/visitors-core";
-
 // src/fragments/accountFetchHelpers.ts
-import { getLastNodeFromPath, pipe } from "@codama/visitors-core";
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
   const accountNode = getLastNodeFromPath(accountPath);
+  const decodeFunction = nameApi.accountDecodeFunction(accountNode.name);
+  const fetchAllFunction = nameApi.accountFetchAllFunction(accountNode.name);
+  const fetchAllMaybeFunction = nameApi.accountFetchAllMaybeFunction(accountNode.name);
+  const fetchFunction = nameApi.accountFetchFunction(accountNode.name);
+  const fetchMaybeFunction = nameApi.accountFetchMaybeFunction(accountNode.name);
   const hasCustomData = customAccountData.has(accountNode.name);
-  const accountTypeFragment = hasCustomData ? typeManifest2.strictType : fragment(nameApi.dataType(accountNode.name));
-  const decoderFunctionFragment = hasCustomData ? typeManifest2.decoder : fragment(`${nameApi.decoderFunction(accountNode.name)}()`);
+  const accountType = hasCustomData ? typeManifest2.strictType : nameApi.dataType(accountNode.name);
+  const decoderFunction = hasCustomData ? typeManifest2.decoder : `${nameApi.decoderFunction(accountNode.name)}()`;
   return pipe(
-    fragmentFromTemplate("accountFetchHelpers.njk", {
-      accountType: accountTypeFragment.content,
-      decodeFunction: nameApi.accountDecodeFunction(accountNode.name),
-      decoderFunction: decoderFunctionFragment.content,
-      fetchAllFunction: nameApi.accountFetchAllFunction(accountNode.name),
-      fetchAllMaybeFunction: nameApi.accountFetchAllMaybeFunction(accountNode.name),
-      fetchFunction: nameApi.accountFetchFunction(accountNode.name),
-      fetchMaybeFunction: nameApi.accountFetchMaybeFunction(accountNode.name)
-    }),
-    (f) => mergeFragmentImports(f, [accountTypeFragment.imports, decoderFunctionFragment.imports]),
+    fragment`export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<${accountType}, TAddress>;
+export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<${accountType}, TAddress>;
+export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<${accountType}, TAddress> | MaybeAccount<${accountType}, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, ${decoderFunction});
+}
+
+export async function ${fetchFunction}<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<${accountType}, TAddress>> {
+  const maybeAccount = await ${fetchMaybeFunction}(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function ${fetchMaybeFunction}<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<${accountType}, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return ${decodeFunction}(maybeAccount);
+}
+
+export async function ${fetchAllFunction}(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<${accountType}>[]> {
+  const maybeAccounts = await ${fetchAllMaybeFunction}(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function ${fetchAllMaybeFunction}(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<${accountType}>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => ${decodeFunction}(maybeAccount));
+}`,
     (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]),
     (f) => addFragmentImports(f, "solanaAccounts", [
       "type Account",
@@ -470,35 +544,46 @@ function getAccountFetchHelpersFragment(scope) {
   );
 }
 
+// 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 { findProgramNodeFromPath, getLastNodeFromPath as getLastNodeFromPath2, pipe as pipe2 } from "@codama/visitors-core";
+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 programNode = findProgramNodeFromPath(accountPath);
   const pdaNode = accountNode.pda ? linkables.get([...accountPath, accountNode.pda]) : void 0;
-  if (!pdaNode) {
-    return fragment("");
-  }
-  const accountTypeFragment = customAccountData.has(accountNode.name) ? typeManifest2.strictType : fragment(nameApi.dataType(accountNode.name));
+  if (!pdaNode) return;
+  const accountType = customAccountData.has(accountNode.name) ? typeManifest2.strictType : nameApi.dataType(accountNode.name);
   const importFrom = "generatedPdas";
   const pdaSeedsType = nameApi.pdaSeedsType(pdaNode.name);
   const findPdaFunction = nameApi.pdaFindFunction(pdaNode.name);
   const hasVariableSeeds = pdaNode.seeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
+  const fetchFromSeedsFunction = nameApi.accountFetchFromSeedsFunction(accountNode.name);
+  const fetchMaybeFromSeedsFunction = nameApi.accountFetchMaybeFromSeedsFunction(accountNode.name);
+  const fetchMaybeFunction = nameApi.accountFetchMaybeFunction(accountNode.name);
   return pipe2(
-    fragmentFromTemplate("accountPdaHelpers.njk", {
-      accountType: accountTypeFragment.content,
-      fetchFromSeedsFunction: nameApi.accountFetchFromSeedsFunction(accountNode.name),
-      fetchFunction: nameApi.accountFetchFunction(accountNode.name),
-      fetchMaybeFromSeedsFunction: nameApi.accountFetchMaybeFromSeedsFunction(accountNode.name),
-      fetchMaybeFunction: nameApi.accountFetchMaybeFunction(accountNode.name),
-      findPdaFunction,
-      hasVariableSeeds,
-      pdaSeedsType,
-      program: programNode
-    }),
-    (f) => mergeFragmentImports(f, [accountTypeFragment.imports]),
+    fragment`export async function ${fetchFromSeedsFunction}(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  ${hasVariableSeeds ? `seeds: ${pdaSeedsType},` : ""}
+  config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<Account<${accountType}>> {
+  const maybeAccount = await ${fetchMaybeFromSeedsFunction}(rpc, ${hasVariableSeeds ? "seeds, " : ""}config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function ${fetchMaybeFromSeedsFunction}(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  ${hasVariableSeeds ? `seeds: ${pdaSeedsType},` : ""}
+  config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<MaybeAccount<${accountType}>> {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await ${findPdaFunction}(${hasVariableSeeds ? "seeds, " : ""}{ programAddress });
+  return await ${fetchMaybeFunction}(rpc, address, fetchConfig);
+}`,
     (f) => addFragmentImports(f, importFrom, hasVariableSeeds ? [pdaSeedsType, findPdaFunction] : [findPdaFunction]),
     (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]),
     (f) => addFragmentImports(f, "solanaAccounts", [
@@ -515,13 +600,11 @@ import { getLastNodeFromPath as getLastNodeFromPath3 } from "@codama/visitors-co
 function getAccountSizeHelpersFragment(scope) {
   const { accountPath, nameApi } = scope;
   const accountNode = getLastNodeFromPath3(accountPath);
-  if (accountNode.size == null) {
-    return fragment("");
-  }
-  return fragmentFromTemplate("accountSizeHelpers.njk", {
-    account: accountNode,
-    getSizeFunction: nameApi.accountGetSizeFunction(accountNode.name)
-  });
+  if (accountNode.size == null) return;
+  const getSizeFunction = nameApi.accountGetSizeFunction(accountNode.name);
+  return fragment`export function ${getSizeFunction}(): number {
+  return ${accountNode.size};
+}`;
 }
 
 // src/fragments/accountType.ts
@@ -529,88 +612,72 @@ import { resolveNestedTypeNode } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath4 } from "@codama/visitors-core";
 
 // src/fragments/type.ts
-import { pipe as pipe3 } from "@codama/visitors-core";
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
-  return pipe3(
-    fragmentFromTemplate("type.njk", {
-      docs,
-      looseName: nameApi.dataArgsType(name),
-      manifest,
-      strictName: nameApi.dataType(name)
-    }),
-    (f) => !manifest.isEnum ? mergeFragmentImports(f, [manifest.strictType.imports, manifest.looseType.imports]) : f
-  );
+  const docblock = getDocblockFragment(docs, true);
+  const strictName = nameApi.dataType(name);
+  const looseName = nameApi.dataArgsType(name);
+  const aliasedLooseName = `export type ${looseName} = ${strictName};`;
+  if (manifest.isEnum) {
+    return fragment`${docblock}export enum ${strictName} ${manifest.strictType};\n\n${aliasedLooseName}`;
+  }
+  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/typeCodec.ts
-import { pipe as pipe6 } from "@codama/visitors-core";
-
 // src/fragments/typeDecoder.ts
 import { isDataEnum, isNode as isNode3 } from "@codama/nodes";
-import { pipe as pipe4 } from "@codama/visitors-core";
 function getTypeDecoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
-  const decoderType = typeof scope.size === "number" ? "FixedSizeDecoder" : "Decoder";
-  const useTypeCast = isNode3(node, "enumTypeNode") && isDataEnum(node) && typeof scope.size === "number";
-  return pipe4(
-    fragmentFromTemplate("typeDecoder.njk", {
-      decoderFunction: nameApi.decoderFunction(name),
-      decoderType,
-      docs,
-      looseName: nameApi.dataArgsType(name),
-      manifest,
-      strictName: nameApi.dataType(name),
-      useTypeCast
-    }),
-    (f) => mergeFragmentImports(f, [manifest.decoder.imports]),
-    (f) => addFragmentImports(f, "solanaCodecsCore", [`type ${decoderType}`])
+  const decoderFunction = nameApi.decoderFunction(name);
+  const strictName = nameApi.dataType(name);
+  const docblock = getDocblockFragment(docs, true);
+  const decoderType = use(
+    typeof scope.size === "number" ? "type FixedSizeDecoder" : "type Decoder",
+    "solanaCodecsCore"
   );
+  const useTypeCast = isNode3(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";
-import { pipe as pipe5 } from "@codama/visitors-core";
 function getTypeEncoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
-  const encoderType = typeof scope.size === "number" ? "FixedSizeEncoder" : "Encoder";
-  const useTypeCast = isNode4(node, "enumTypeNode") && isDataEnum2(node) && typeof scope.size === "number";
-  return pipe5(
-    fragmentFromTemplate("typeEncoder.njk", {
-      docs,
-      encoderFunction: nameApi.encoderFunction(name),
-      encoderType,
-      looseName: nameApi.dataArgsType(name),
-      manifest,
-      strictName: nameApi.dataType(name),
-      useTypeCast
-    }),
-    (f) => mergeFragmentImports(f, [manifest.encoder.imports]),
-    (f) => addFragmentImports(f, "solanaCodecsCore", [`type ${encoderType}`])
+  const encoderFunction = nameApi.encoderFunction(name);
+  const looseName = nameApi.dataArgsType(name);
+  const docblock = getDocblockFragment(docs, true);
+  const encoderType = use(
+    typeof scope.size === "number" ? "type FixedSizeEncoder" : "type Encoder",
+    "solanaCodecsCore"
   );
+  const useTypeCast = isNode4(node, "enumTypeNode") && isDataEnum2(node) && typeof scope.size === "number";
+  const typeCast = useTypeCast ? fragment` as ${encoderType}<${looseName}>` : "";
+  return fragment`${docblock}export function ${encoderFunction}(): ${encoderType}<${looseName}> {
+    return ${manifest.encoder}${typeCast};
+}`;
 }
 
 // src/fragments/typeCodec.ts
 function getTypeCodecFragment(scope) {
-  const { name, manifest, nameApi } = scope;
-  const codecType = typeof scope.size === "number" ? "FixedSizeCodec" : "Codec";
+  const { codecDocs = [], name, nameApi } = scope;
+  const codecFunction = nameApi.codecFunction(name);
+  const decoderFunction = nameApi.decoderFunction(name);
+  const encoderFunction = nameApi.encoderFunction(name);
+  const looseName = nameApi.dataArgsType(name);
+  const strictName = nameApi.dataType(name);
+  const docblock = getDocblockFragment(codecDocs, true);
+  const codecType = use(typeof scope.size === "number" ? "type FixedSizeCodec" : "type Codec", "solanaCodecsCore");
   return mergeFragments(
     [
       getTypeEncoderFragment({ ...scope, docs: scope.encoderDocs }),
       getTypeDecoderFragment({ ...scope, docs: scope.decoderDocs }),
-      pipe6(
-        fragmentFromTemplate("typeCodec.njk", {
-          codecFunction: nameApi.codecFunction(name),
-          codecType,
-          decoderFunction: nameApi.decoderFunction(name),
-          docs: scope.codecDocs,
-          encoderFunction: nameApi.encoderFunction(name),
-          looseName: nameApi.dataArgsType(name),
-          manifest,
-          strictName: nameApi.dataType(name)
-        }),
-        (f) => addFragmentImports(f, "solanaCodecsCore", [`type ${codecType}`, "combineCodec"])
-      )
+      fragment`${docblock}export function ${codecFunction}(): ${codecType}<${looseName}, ${strictName}> {
+    return ${use("combineCodec", "solanaCodecsCore")}(${encoderFunction}(), ${decoderFunction}());
+}`
     ],
     (renders) => renders.join("\n\n")
   );
@@ -628,9 +695,7 @@ function getTypeWithCodecFragment(scope) {
 function getAccountTypeFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
   const accountNode = getLastNodeFromPath4(accountPath);
-  if (customAccountData.has(accountNode.name)) {
-    return fragment("");
-  }
+  if (customAccountData.has(accountNode.name)) return;
   return getTypeWithCodecFragment({
     manifest: typeManifest2,
     name: accountNode.name,
@@ -640,49 +705,119 @@ function getAccountTypeFragment(scope) {
   });
 }
 
+// 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"));
+}
+function getDiscriminatorConstantFragment(discriminatorNode, scope) {
+  switch (discriminatorNode.kind) {
+    case "constantDiscriminatorNode":
+      return getConstantDiscriminatorConstantFragment(discriminatorNode, scope);
+    case "fieldDiscriminatorNode":
+      return getFieldDiscriminatorConstantFragment(discriminatorNode, scope);
+    default:
+      return null;
+  }
+}
+function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
+  const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
+  const index = discriminatorNodes.filter(isNodeFilter2("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const suffix = index <= 0 ? "" : `_${index + 1}`;
+  const name = camelCase3(`${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 });
+}
+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)) {
+    return null;
+  }
+  const name = camelCase3(`${prefix}_${discriminatorNode.name}`);
+  const encoder = visit(field.type, typeManifestVisitor).encoder;
+  const value = visit(field.defaultValue, typeManifestVisitor).value;
+  return getConstantFragment({ ...scope, encoder, name, value });
+}
+function getConstantFragment(scope) {
+  const { encoder, name, nameApi, value } = scope;
+  const constantName = nameApi.constant(name);
+  const constantFunction = nameApi.constantFunction(name);
+  return fragment`export const ${constantName} = ${value};\n\nexport function ${constantFunction}() { return ${encoder}.encode(${constantName}); }`;
+}
+
+// src/fragments/accountPage.ts
+function getAccountPageFragment(scope) {
+  const node = getLastNodeFromPath5(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;
+  return mergeFragments(
+    [
+      getDiscriminatorConstantsFragment({
+        ...scope,
+        discriminatorNodes: node.discriminators ?? [],
+        fields,
+        prefix: node.name
+      }),
+      getAccountTypeFragment({ ...scope, typeManifest: typeManifest2 }),
+      getAccountFetchHelpersFragment({ ...scope, typeManifest: typeManifest2 }),
+      getAccountSizeHelpersFragment(scope),
+      getAccountPdaHelpersFragment({ ...scope, typeManifest: typeManifest2 })
+    ],
+    (cs) => cs.join("\n\n")
+  );
+}
+
 // src/fragments/discriminatorCondition.ts
 import {
   constantDiscriminatorNode,
   constantValueNode,
   constantValueNodeFromBytes,
-  isNode as isNode5,
-  isNodeFilter as isNodeFilter2
+  isNode as isNode6,
+  isNodeFilter as isNodeFilter3
 } from "@codama/nodes";
 import { mapFragmentContent } from "@codama/renderers-core";
-import { pipe as pipe7, visit } from "@codama/visitors-core";
+import { pipe as pipe3, visit as visit3 } from "@codama/visitors-core";
 import { getBase64Decoder } from "@solana/codecs-strings";
 function getDiscriminatorConditionFragment(scope) {
-  return pipe7(
+  return pipe3(
     mergeFragments(
       scope.discriminators.flatMap((discriminator) => {
-        if (isNode5(discriminator, "sizeDiscriminatorNode")) {
+        if (isNode6(discriminator, "sizeDiscriminatorNode")) {
           return [getSizeConditionFragment(discriminator, scope)];
         }
-        if (isNode5(discriminator, "constantDiscriminatorNode")) {
+        if (isNode6(discriminator, "constantDiscriminatorNode")) {
           return [getByteConditionFragment(discriminator, scope)];
         }
-        if (isNode5(discriminator, "fieldDiscriminatorNode")) {
+        if (isNode6(discriminator, "fieldDiscriminatorNode")) {
           return [getFieldConditionFragment(discriminator, scope)];
         }
         return [];
       }),
       (c) => c.join(" && ")
     ),
-    (f) => mapFragmentContent(f, (c) => `if (${c}) { ${scope.ifTrue}; }`)
+    (f) => mapFragmentContent(f, (c) => `if (${c}) { ${scope.ifTrue} }`)
   );
 }
 function getSizeConditionFragment(discriminator, scope) {
   const { dataName } = scope;
-  return fragment(`${dataName}.length === ${discriminator.size}`);
+  return fragment`${dataName}.length === ${discriminator.size}`;
 }
 function getByteConditionFragment(discriminator, scope) {
   const { dataName, typeManifestVisitor } = scope;
-  const constant = visit(discriminator.constant, typeManifestVisitor).value;
-  return pipe7(
-    constant,
-    (f) => mapFragmentContent(f, (c) => `containsBytes(${dataName}, ${c}, ${discriminator.offset})`),
-    (f) => addFragmentImports(f, "solanaCodecsCore", ["containsBytes"])
-  );
+  const constant = visit3(discriminator.constant, typeManifestVisitor).value;
+  return fragment`${use("containsBytes", "solanaCodecsCore")}(${dataName}, ${constant}, ${discriminator.offset})`;
 }
 function getFieldConditionFragment(discriminator, scope) {
   const field = scope.struct.fields.find((f) => f.name === discriminator.name);
@@ -691,7 +826,7 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if (isNode5(field.type, "arrayTypeNode") && isNode5(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode5(field.type.count, "fixedCountNode") && isNode5(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter2("numberValueNode"))) {
+  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"))) {
     const base64Bytes = getBase64Decoder().decode(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
@@ -706,35 +841,103 @@ function getFieldConditionFragment(discriminator, scope) {
   );
 }
 
+// src/fragments/errorPage.ts
+function getErrorPageFragment(scope) {
+  return mergeFragments(
+    [
+      getConstantsFragment(scope),
+      getConstantUnionTypeFragment(scope),
+      getErrorMessagesFragment(scope),
+      getErrorMessageFunctionFragment(scope),
+      getIsErrorFunctionFragment(scope)
+    ],
+    (cs) => cs.join("\n\n")
+  );
+}
+function getConstantsFragment(scope) {
+  const constantPrefix = scope.nameApi.programErrorConstantPrefix(scope.programNode.name);
+  return mergeFragments(
+    [...scope.programNode.errors].sort((a, b) => a.code - b.code).map((error) => {
+      const docs = getDocblockFragment(error.docs ?? [], true);
+      const name = constantPrefix + scope.nameApi.programErrorConstant(error.name);
+      return fragment`${docs}export const ${name} = 0x${error.code.toString(16)}; // ${error.code}`;
+    }),
+    (cs) => cs.join("\n")
+  );
+}
+function getConstantUnionTypeFragment(scope) {
+  const constantPrefix = scope.nameApi.programErrorConstantPrefix(scope.programNode.name);
+  const typeName = scope.nameApi.programErrorUnion(scope.programNode.name);
+  const errorTypes = mergeFragments(
+    [...scope.programNode.errors].sort((a, b) => a.name.localeCompare(b.name)).map((error) => fragment`typeof ${constantPrefix + scope.nameApi.programErrorConstant(error.name)}`),
+    (cs) => cs.join(" | ")
+  );
+  return fragment`export type ${typeName} = ${errorTypes};`;
+}
+function getErrorMessagesFragment(scope) {
+  const mapName = scope.nameApi.programErrorMessagesMap(scope.programNode.name);
+  const errorUnionType = scope.nameApi.programErrorUnion(scope.programNode.name);
+  const constantPrefix = scope.nameApi.programErrorConstantPrefix(scope.programNode.name);
+  const messageEntries = mergeFragments(
+    [...scope.programNode.errors].sort((a, b) => a.name.localeCompare(b.name)).map((error) => {
+      const constantName = constantPrefix + scope.nameApi.programErrorConstant(error.name);
+      const escapedMessage = error.message.replace(/`/g, "\\`");
+      return fragment`[${constantName}]: \`${escapedMessage}\``;
+    }),
+    (cs) => cs.join(", ")
+  );
+  return fragment`let ${mapName}: Record<${errorUnionType}, string> | undefined;
+if (process.env.NODE_ENV !== 'production') {
+  ${mapName} = { ${messageEntries} };
+}`;
+}
+function getErrorMessageFunctionFragment(scope) {
+  const functionName = scope.nameApi.programGetErrorMessageFunction(scope.programNode.name);
+  const errorUnionType = scope.nameApi.programErrorUnion(scope.programNode.name);
+  const messageMapName = scope.nameApi.programErrorMessagesMap(scope.programNode.name);
+  return fragment`export function ${functionName}(code: ${errorUnionType}): string {
+  if (process.env.NODE_ENV !== 'production') {
+    return (${messageMapName} as Record<${errorUnionType}, string>)[code];
+  }
+
+  return 'Error message not available in production bundles.';
+}`;
+}
+function getIsErrorFunctionFragment(scope) {
+  const { programNode, nameApi } = scope;
+  const programAddressConstant = use(nameApi.programAddressConstant(programNode.name), "generatedPrograms");
+  const functionName = nameApi.programIsErrorFunction(programNode.name);
+  const programErrorUnion = nameApi.programErrorUnion(programNode.name);
+  return fragment`export function ${functionName}<TProgramErrorCode extends ${programErrorUnion}>(
+    error: unknown,
+    transactionMessage: { instructions: Record<number, { programAddress: ${use("type Address", "solanaAddresses")} }> },
+    code?: TProgramErrorCode,
+): error is ${use("type SolanaError", "solanaErrors")}<typeof ${use("type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM", "solanaErrors")}> & Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+  return ${use("isProgramError", "solanaPrograms")}<TProgramErrorCode>(error, transactionMessage, ${programAddressConstant}, code);
+}`;
+}
+
+// src/fragments/indexPage.ts
+function getIndexPageFragment(items) {
+  if (items.length === 0) return;
+  const names = items.map((item) => 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";
-import { pipe as pipe8 } from "@codama/visitors-core";
 function getInstructionAccountMetaFragment(instructionAccountNode) {
   const typeParam = `TAccount${pascalCase2(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
-    return pipe8(
-      fragment(`WritableSignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaInstructions", ["type WritableSignerAccount"]),
-      (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta"])
-    );
+    return fragment`${use("type WritableSignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
   if (instructionAccountNode.isSigner === true) {
-    return pipe8(
-      fragment(`ReadonlySignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaInstructions", ["type ReadonlySignerAccount"]),
-      (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta"])
-    );
+    return fragment`${use("type ReadonlySignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
   if (instructionAccountNode.isWritable) {
-    return pipe8(
-      fragment(`WritableAccount<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaInstructions", ["type WritableAccount"])
-    );
+    return fragment`${use("type WritableAccount", "solanaInstructions")}<${typeParam}>`;
   }
-  return pipe8(
-    fragment(`ReadonlyAccount<${typeParam}>`),
-    (f) => addFragmentImports(f, "solanaInstructions", ["type ReadonlyAccount"])
-  );
+  return fragment`${use("type ReadonlyAccount", "solanaInstructions")}<${typeParam}>`;
 }
 
 // src/fragments/instructionAccountTypeParam.ts
@@ -742,31 +945,20 @@ import { pascalCase as pascalCase3 } from "@codama/nodes";
 import {
   findInstructionNodeFromPath,
   findProgramNodeFromPath as findProgramNodeFromPath2,
-  getLastNodeFromPath as getLastNodeFromPath5,
-  pipe as pipe9
+  getLastNodeFromPath as getLastNodeFromPath6
 } from "@codama/visitors-core";
 function getInstructionAccountTypeParamFragment(scope) {
   const { instructionAccountPath, allowAccountMeta, linkables } = scope;
-  const instructionAccountNode = getLastNodeFromPath5(instructionAccountPath);
+  const instructionAccountNode = getLastNodeFromPath6(instructionAccountPath);
   const instructionNode = findInstructionNodeFromPath(instructionAccountPath);
   const programNode = findProgramNodeFromPath2(instructionAccountPath);
   const typeParam = `TAccount${pascalCase3(instructionAccountNode.name)}`;
-  const accountMeta = allowAccountMeta ? " | AccountMeta<string>" : "";
-  const imports = new ImportMap();
-  if (allowAccountMeta) {
-    imports.add("solanaInstructions", "type AccountMeta");
-  }
+  const accountMeta = allowAccountMeta ? fragment` | ${use("type AccountMeta", "solanaInstructions")}<string>` : void 0;
   if (instructionNode.optionalAccountStrategy === "omitted" && instructionAccountNode.isOptional) {
-    return pipe9(
-      fragment(`${typeParam} extends string${accountMeta} | undefined = undefined`),
-      (f) => mergeFragmentImports(f, [imports])
-    );
+    return fragment`${typeParam} extends string${accountMeta} | undefined = undefined`;
   }
   const defaultAddress = getDefaultAddress(instructionAccountNode.defaultValue, programNode.publicKey, linkables);
-  return pipe9(
-    fragment(`${typeParam} extends string${accountMeta} = ${defaultAddress}`),
-    (f) => mergeFragmentImports(f, [imports])
-  );
+  return fragment`${typeParam} extends string${accountMeta} = ${defaultAddress}`;
 }
 function getDefaultAddress(defaultValue, programId, linkables) {
   switch (defaultValue?.kind) {
@@ -783,13 +975,13 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 }
 
 // src/fragments/instructionByteDelta.ts
-import { assertIsNode, camelCase as camelCase3, isNode as isNode6 } from "@codama/nodes";
+import { assertIsNode, camelCase as camelCase4, isNode as isNode7 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent2 } from "@codama/renderers-core";
-import { getLastNodeFromPath as getLastNodeFromPath6, pipe as pipe10 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath7, pipe as pipe4 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = getLastNodeFromPath6(scope.instructionPath);
+  const { byteDeltas } = getLastNodeFromPath7(scope.instructionPath);
   const fragments = (byteDeltas ?? []).flatMap((c) => getByteDeltaFragment(c, scope));
-  if (fragments.length === 0) return fragment("");
+  if (fragments.length === 0) return;
   return mergeFragments(
     fragments,
     (c) => `// Bytes created or reallocated by the instruction.
@@ -798,71 +990,68 @@ const byteDelta: number = [${c.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   let bytesFragment = (() => {
-    if (isNode6(byteDelta.value, "numberValueNode")) {
+    if (isNode7(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if (isNode6(byteDelta.value, "argumentValueNode")) {
+    if (isNode7(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if (isNode6(byteDelta.value, "accountLinkNode")) {
+    if (isNode7(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if (isNode6(byteDelta.value, "resolverValueNode")) {
+    if (isNode7(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
   })();
   if (bytesFragment === null) return [];
   if (byteDelta.withHeader) {
-    bytesFragment = pipe10(
-      bytesFragment,
-      (f) => mapFragmentContent2(f, (c) => `${c} + BASE_ACCOUNT_SIZE`),
-      (f) => addFragmentImports(f, "solanaAccounts", ["BASE_ACCOUNT_SIZE"])
-    );
+    bytesFragment = fragment`${bytesFragment} + ${use("BASE_ACCOUNT_SIZE", "solanaAccounts")}`;
   }
   if (byteDelta.subtract) {
-    bytesFragment = pipe10(bytesFragment, (f) => mapFragmentContent2(f, (c) => `- (${c})`));
+    bytesFragment = pipe4(bytesFragment, (f) => mapFragmentContent2(f, (c) => `- (${c})`));
   }
   return [bytesFragment];
 }
 function getNumberValueNodeFragment(byteDelta) {
   assertIsNode(byteDelta.value, "numberValueNode");
-  return fragment(byteDelta.value.number.toString());
+  return fragment`${byteDelta.value.number}`;
 }
 function getArgumentValueNodeFragment(byteDelta) {
   assertIsNode(byteDelta.value, "argumentValueNode");
-  const argumentName = camelCase3(byteDelta.value.name);
-  return fragment(`Number(args.${argumentName})`);
+  const argumentName = camelCase4(byteDelta.value.name);
+  return fragment`Number(args.${argumentName})`;
 }
 function getAccountLinkNodeFragment(byteDelta, scope) {
   assertIsNode(byteDelta.value, "accountLinkNode");
-  const functionName = scope.nameApi.accountGetSizeFunction(byteDelta.value.name);
-  const module = scope.getImportFrom(byteDelta.value);
-  return pipe10(fragment(`${functionName}()`), (f) => addFragmentImports(f, module, [functionName]));
+  const functionName = use(
+    scope.nameApi.accountGetSizeFunction(byteDelta.value.name),
+    scope.getImportFrom(byteDelta.value)
+  );
+  return fragment`${functionName}()`;
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
   assertIsNode(byteDelta.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(byteDelta.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
-  const functionName = scope.nameApi.resolverFunction(byteDelta.value.name);
-  const module = scope.getImportFrom(byteDelta.value);
-  return pipe10(
-    fragment(`${awaitKeyword}${functionName}(resolverScope)`),
-    (f) => addFragmentImports(f, module, [functionName]),
+  const functionName = use(
+    scope.nameApi.resolverFunction(byteDelta.value.name),
+    scope.getImportFrom(byteDelta.value)
+  );
+  return pipe4(
+    fragment`${awaitKeyword}${functionName}(resolverScope)`,
     (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
   );
 }
 
 // src/fragments/instructionData.ts
 import { structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes2 } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath7 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath8 } from "@codama/visitors-core";
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath7(instructionPath);
-  if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) {
-    return fragment("");
-  }
+  const instructionNode = getLastNodeFromPath8(instructionPath);
+  if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) return;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   return getTypeWithCodecFragment({
     manifest: dataArgsManifest,
@@ -873,82 +1062,16 @@ function getInstructionDataFragment(scope) {
   });
 }
 
-// src/fragments/discriminatorConstants.ts
-import {
-  camelCase as camelCase4,
-  isNode as isNode7,
-  isNodeFilter as isNodeFilter3,
-  VALUE_NODES
-} from "@codama/nodes";
-import { mapFragmentContent as mapFragmentContent3 } from "@codama/renderers-core";
-import { visit as visit2 } 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"));
-}
-function getDiscriminatorConstantFragment(discriminatorNode, scope) {
-  switch (discriminatorNode.kind) {
-    case "constantDiscriminatorNode":
-      return getConstantDiscriminatorConstantFragment(discriminatorNode, scope);
-    case "fieldDiscriminatorNode":
-      return getFieldDiscriminatorConstantFragment(discriminatorNode, scope);
-    default:
-      return null;
-  }
-}
-function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
-  const { discriminatorNodes, typeManifestVisitor, prefix } = scope;
-  const index = discriminatorNodes.filter(isNodeFilter3("constantDiscriminatorNode")).indexOf(discriminatorNode);
-  const suffix = index <= 0 ? "" : `_${index + 1}`;
-  const name = camelCase4(`${prefix}_discriminator${suffix}`);
-  const encoder = visit2(discriminatorNode.constant.type, typeManifestVisitor).encoder;
-  const value = visit2(discriminatorNode.constant.value, typeManifestVisitor).value;
-  return getConstantFragment({ ...scope, encoder, name, value });
-}
-function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
-  const { fields, prefix, typeManifestVisitor } = scope;
-  const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !isNode7(field.defaultValue, VALUE_NODES)) {
-    return null;
-  }
-  const name = camelCase4(`${prefix}_${discriminatorNode.name}`);
-  const encoder = visit2(field.type, typeManifestVisitor).encoder;
-  const value = visit2(field.defaultValue, typeManifestVisitor).value;
-  return getConstantFragment({ ...scope, encoder, name, value });
-}
-function getConstantFragment(scope) {
-  const { encoder, name, nameApi, value } = scope;
-  const constantName = nameApi.constant(name);
-  const constantFunction = nameApi.constantFunction(name);
-  return mergeFragments(
-    [
-      mapFragmentContent3(value, (c) => `export const ${constantName} = ${c};`),
-      mapFragmentContent3(
-        encoder,
-        (c) => `export function ${constantFunction}() { return ${c}.encode(${constantName}); }`
-      )
-    ],
-    (c) => c.join("\n\n")
-  );
-}
-
 // src/fragments/instructionExtraArgs.ts
-import { getLastNodeFromPath as getLastNodeFromPath8, pipe as pipe11 } from "@codama/visitors-core";
+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 = getLastNodeFromPath8(instructionPath);
-  if ((instructionNode.extraArguments ?? []).length === 0) {
-    return fragment("");
-  }
+  const instructionNode = getLastNodeFromPath9(instructionPath);
+  if ((instructionNode.extraArguments ?? []).length === 0) return;
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
-  return pipe11(
-    fragmentFromTemplate("instructionExtraArgs.njk", {
-      looseName: nameApi.dataArgsType(instructionExtraName),
-      manifest: extraArgsManifest,
-      strictName: nameApi.dataType(instructionExtraName)
-    }),
-    (f) => mergeFragmentImports(f, [extraArgsManifest.looseType.imports])
-  );
+  const looseName = nameApi.dataArgsType(instructionExtraName);
+  return mapFragmentContent3(extraArgsManifest.looseType, (c) => `export type ${looseName} = ${c};`);
 }
 
 // src/fragments/instructionFunction.ts
@@ -956,132 +1079,106 @@ import { camelCase as camelCase9, isNode as isNode12, isNodeFilter as isNodeFilt
 import { mapFragmentContent as mapFragmentContent7 } from "@codama/renderers-core";
 import {
   findProgramNodeFromPath as findProgramNodeFromPath3,
-  getLastNodeFromPath as getLastNodeFromPath12,
-  pipe as pipe15
+  getLastNodeFromPath as getLastNodeFromPath13,
+  pipe as pipe8
 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputResolved.ts
 import { camelCase as camelCase6, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent5 } from "@codama/renderers-core";
-import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath10 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputDefault.ts
 import { camelCase as camelCase5, isNode as isNode8 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent4, setFragmentContent } from "@codama/renderers-core";
-import { pipe as pipe12, visit as visit3 } from "@codama/visitors-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) {
-    return fragment("");
+    return fragment``;
   }
   if (!useAsync && isAsyncDefaultValue(input.defaultValue, asyncResolvers)) {
-    return fragment("");
+    return fragment``;
   }
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
     const inputName = camelCase5(input.name);
     if (input.kind === "instructionAccountNode" && isNode8(defaultValue, "resolverValueNode")) {
-      return fragment(`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`);
+      return fragment`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`;
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
-      return fragment(`accounts.${inputName}.value = ${renderedValue};`);
+      return fragment`accounts.${inputName}.value = ${renderedValue};`;
     }
     if (input.kind === "instructionAccountNode") {
-      return fragment(
-        `accounts.${inputName}.value = ${renderedValue};
-accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
-      );
+      return fragment`accounts.${inputName}.value = ${renderedValue};\naccounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`;
     }
-    return fragment(`args.${inputName} = ${renderedValue};`);
+    return fragment`args.${inputName} = ${renderedValue};`;
   };
   switch (defaultValue.kind) {
     case "accountValueNode":
       const name = camelCase5(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
-        return pipe12(
+        return pipe5(
           defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`),
           (f) => addFragmentImports(f, "shared", ["expectTransactionSigner"])
         );
       }
       if (input.kind === "instructionAccountNode") {
-        return pipe12(
+        return pipe5(
           defaultFragment(`expectSome(accounts.${name}.value)`),
           (f) => addFragmentImports(f, "shared", ["expectSome"])
         );
       }
-      return pipe12(
+      return pipe5(
         defaultFragment(`expectAddress(accounts.${name}.value)`),
         (f) => addFragmentImports(f, "shared", ["expectAddress"])
       );
     case "pdaValueNode":
       if (isNode8(defaultValue.pda, "pdaNode")) {
-        const pdaProgram = defaultValue.pda.programId ? pipe12(
-          fragment(`'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`),
+        const pdaProgram = defaultValue.pda.programId ? pipe5(
+          fragment`'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`,
           (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-        ) : fragment("programAddress");
+        ) : fragment`programAddress`;
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
           if (isNode8(seed, "constantPdaSeedNode") && isNode8(seed.value, "programIdValueNode")) {
             return [
-              pipe12(
-                fragment(`getAddressEncoder().encode(${pdaProgram.content})`),
-                (f) => mergeFragmentImports(f, [pdaProgram.imports]),
+              pipe5(
+                fragment`getAddressEncoder().encode(${pdaProgram})`,
                 (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
               )
             ];
           }
           if (isNode8(seed, "constantPdaSeedNode") && !isNode8(seed.value, "programIdValueNode")) {
-            const typeManifest2 = visit3(seed.type, typeManifestVisitor);
-            const valueManifest2 = visit3(seed.value, typeManifestVisitor);
-            return [
-              pipe12(
-                fragment(`${typeManifest2.encoder.content}.encode(${valueManifest2.value.content})`),
-                (f) => mergeFragmentImports(f, [
-                  typeManifest2.encoder.imports,
-                  valueManifest2.value.imports
-                ])
-              )
-            ];
+            const typeManifest2 = visit4(seed.type, typeManifestVisitor);
+            const valueManifest2 = visit4(seed.value, typeManifestVisitor);
+            return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
           if (isNode8(seed, "variablePdaSeedNode")) {
-            const typeManifest2 = visit3(seed.type, typeManifestVisitor);
+            const typeManifest2 = visit4(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
             if (isNode8(valueSeed, "accountValueNode")) {
               return [
-                pipe12(
-                  fragment(
-                    `${typeManifest2.encoder.content}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`
-                  ),
-                  (f) => mergeFragmentImports(f, [typeManifest2.encoder.imports]),
+                pipe5(
+                  fragment`${typeManifest2.encoder}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`,
                   (f) => addFragmentImports(f, "shared", ["expectAddress"])
                 )
               ];
             }
             if (isNode8(valueSeed, "argumentValueNode")) {
               return [
-                pipe12(
-                  fragment(
-                    `${typeManifest2.encoder.content}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`
-                  ),
-                  (f) => mergeFragmentImports(f, [typeManifest2.encoder.imports]),
+                pipe5(
+                  fragment`${typeManifest2.encoder}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`,
                   (f) => addFragmentImports(f, "shared", ["expectSome"])
                 )
               ];
             }
-            const valueManifest2 = visit3(valueSeed, typeManifestVisitor);
-            return [
-              pipe12(
-                fragment(`${typeManifest2.encoder.content}.encode(${valueManifest2.value.content})`),
-                (f) => mergeFragmentImports(f, [
-                  typeManifest2.encoder.imports,
-                  valueManifest2.value.imports
-                ])
-              )
-            ];
+            const valueManifest2 = visit4(valueSeed, typeManifestVisitor);
+            return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
           return [];
         });
-        return pipe12(
+        return pipe5(
           mergeFragments([pdaProgram, ...pdaSeeds2], ([p, ...s]) => {
             const programAddress2 = p === "programAddress" ? p : `programAddress: ${p}`;
             return `await getProgramDerivedAddress({ ${programAddress2}, seeds: [${s.join(", ")}] })`;
@@ -1094,23 +1191,23 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
         if (isNode8(seed.value, "accountValueNode")) {
-          return pipe12(
-            fragment(`${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`),
+          return pipe5(
+            fragment`${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`,
             (f) => addFragmentImports(f, "shared", ["expectAddress"])
           );
         }
         if (isNode8(seed.value, "argumentValueNode")) {
-          return pipe12(
-            fragment(`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`),
+          return pipe5(
+            fragment`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`,
             (f) => addFragmentImports(f, "shared", ["expectSome"])
           );
         }
-        return pipe12(
-          visit3(seed.value, typeManifestVisitor).value,
+        return pipe5(
+          visit4(seed.value, typeManifestVisitor).value,
           (f) => mapFragmentContent4(f, (c) => `${seed.name}: ${c}`)
         );
       });
-      const pdaSeedsFragment = pipe12(
+      const pdaSeedsFragment = pipe5(
         mergeFragments(pdaSeeds, (renders) => renders.join(", ")),
         (f) => mapFragmentContent4(f, (c) => `{ ${c} }`)
       );
@@ -1118,44 +1215,44 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
         pdaArgs.push(pdaSeedsFragment.content);
       }
       const module = getImportFrom(defaultValue.pda);
-      return pipe12(
+      return pipe5(
         defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`),
         (f) => mergeFragmentImports(f, [pdaSeedsFragment.imports]),
         (f) => addFragmentImports(f, module, [pdaFunction])
       );
     case "publicKeyValueNode":
-      return pipe12(
+      return pipe5(
         defaultFragment(`'${defaultValue.publicKey}' as Address<'${defaultValue.publicKey}'>`),
         (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
       );
     case "programLinkNode":
       const programAddress = nameApi.programAddressConstant(defaultValue.name);
-      return pipe12(
+      return pipe5(
         defaultFragment(programAddress, false),
         (f) => addFragmentImports(f, getImportFrom(defaultValue), [programAddress])
       );
     case "programIdValueNode":
       if (optionalAccountStrategy === "programId" && input.kind === "instructionAccountNode" && input.isOptional) {
-        return fragment("");
+        return fragment``;
       }
       return defaultFragment("programAddress", false);
     case "identityValueNode":
     case "payerValueNode":
-      return fragment("");
+      return fragment``;
     case "accountBumpValueNode":
-      return pipe12(
+      return pipe5(
         defaultFragment(`expectProgramDerivedAddress(accounts.${camelCase5(defaultValue.name)}.value)[1]`),
         (f) => addFragmentImports(f, "shared", ["expectProgramDerivedAddress"])
       );
     case "argumentValueNode":
-      return pipe12(
+      return pipe5(
         defaultFragment(`expectSome(args.${camelCase5(defaultValue.name)})`),
         (f) => addFragmentImports(f, "shared", ["expectSome"])
       );
     case "resolverValueNode":
       const resolverFunction = nameApi.resolverFunction(defaultValue.name);
       const resolverAwait = useAsync && asyncResolvers.includes(defaultValue.name) ? "await " : "";
-      return pipe12(
+      return pipe5(
         defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
         (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
         (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
@@ -1170,9 +1267,9 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
         defaultValue: defaultValue.ifFalse
       });
       if (!ifTrueRenderer && !ifFalseRenderer) {
-        return fragment("");
+        return fragment``;
       }
-      let conditionalFragment = fragment("");
+      let conditionalFragment = fragment``;
       if (ifTrueRenderer) {
         conditionalFragment = mergeFragments([conditionalFragment, ifTrueRenderer], (c) => c[0]);
       }
@@ -1184,7 +1281,7 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       if (isNode8(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
         const module2 = getImportFrom(defaultValue.condition);
-        conditionalFragment = pipe12(
+        conditionalFragment = pipe5(
           conditionalFragment,
           (f) => addFragmentImports(f, module2, [conditionalResolverFunction]),
           (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
@@ -1195,7 +1292,7 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       } else {
         const comparedInputName = isNode8(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase5(defaultValue.condition.name)}.value` : `args.${camelCase5(defaultValue.condition.name)}`;
         if (defaultValue.value) {
-          const comparedValue = visit3(defaultValue.value, typeManifestVisitor).value;
+          const comparedValue = visit4(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
           const operator = negatedCondition ? "!==" : "===";
           condition = `${comparedInputName} ${operator} ${comparedValue.content}`;
@@ -1220,8 +1317,8 @@ ${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
 }`
       );
     default:
-      const valueManifest = visit3(defaultValue, typeManifestVisitor).value;
-      return pipe12(valueManifest, (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content));
+      const valueManifest = visit4(defaultValue, typeManifestVisitor).value;
+      return pipe5(valueManifest, (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content));
   }
 }
 function renderNestedInstructionDefault(scope) {
@@ -1235,7 +1332,7 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
-  const instructionNode = getLastNodeFromPath9(scope.instructionPath);
+  const instructionNode = getLastNodeFromPath10(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
@@ -1256,9 +1353,9 @@ ${c}
     ];
   });
   if (resolvedInputFragments.length === 0) {
-    return fragment("");
+    return fragment``;
   }
-  return mergeFragments([fragment("// Resolve default values."), ...resolvedInputFragments], (c) => c.join("\n"));
+  return mergeFragments([fragment`// Resolve default values.`, ...resolvedInputFragments], (c) => c.join("\n"));
 }
 
 // src/fragments/instructionInputType.ts
@@ -1266,99 +1363,70 @@ import {
   camelCase as camelCase7,
   getAllInstructionArguments,
   isNode as isNode10,
-  parseDocs,
   pascalCase as pascalCase4
 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent6 } from "@codama/renderers-core";
 import {
-  getLastNodeFromPath as getLastNodeFromPath10,
-  pipe as pipe13
+  getLastNodeFromPath as getLastNodeFromPath11,
+  pipe as pipe6
 } from "@codama/visitors-core";
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath10(instructionPath);
+  const instructionNode = getLastNodeFromPath11(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
-  const accountsFragment = getAccountsFragment(scope);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
-  const extraArgumentsFragment = getExtraArgumentsFragment(scope);
-  const remainingAccountsFragment = getRemainingAccountsFragment(instructionNode);
-  return pipe13(
-    fragmentFromTemplate("instructionInputType.njk", {
-      accountsFragment: accountsFragment.content,
-      customDataArgumentsFragment: customDataArgumentsFragment.content,
-      dataArgumentsFragment: dataArgumentsFragment.content,
-      extraArgumentsFragment: extraArgumentsFragment.content,
-      instruction: instructionNode,
-      instructionInputType,
-      remainingAccountsFragment: remainingAccountsFragment.content
-    }),
-    (f) => mergeFragmentImports(f, [
-      accountsFragment.imports,
-      dataArgumentsFragment.imports,
-      customDataArgumentsFragment.imports,
-      extraArgumentsFragment.imports,
-      remainingAccountsFragment.imports
-    ]),
-    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+  let accountTypeParams = "";
+  if (instructionNode.accounts.length > 0) {
+    accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase4(account.name)} extends string = string`).join(", ");
+    accountTypeParams = `<${accountTypeParams}>`;
+  }
+  const typeBodyFragment = mergeFragments(
+    [
+      getAccountsFragment(scope),
+      dataArgumentsFragment,
+      getExtraArgumentsFragment(scope),
+      getRemainingAccountsFragment(instructionNode)
+    ],
+    (c) => c.join("\n")
   );
+  return fragment`export type ${instructionInputType}${accountTypeParams} = ${customDataArgumentsFragment} {
+  ${typeBodyFragment}
+}`;
 }
 function getAccountsFragment(scope) {
   const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
-  const instructionNode = getLastNodeFromPath10(instructionPath);
+  const instructionNode = getLastNodeFromPath11(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 accountDocs = parseDocs(account.docs);
-    const docblock = accountDocs.length > 0 ? jsDocblock(accountDocs) : "";
+    const docs = getDocblockFragment(account.docs ?? [], true);
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return mapFragmentContent6(
-      getAccountTypeFragment2(resolvedAccount),
-      (c) => `${docblock}${camelCase7(account.name)}${optionalSign}: ${c};`
-    );
+    return fragment`${docs}${camelCase7(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
   });
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getAccountTypeFragment2(account) {
   const typeParam = `TAccount${pascalCase4(account.name)}`;
-  if (account.isPda && account.isSigner === false) {
-    return pipe13(
-      fragment(`ProgramDerivedAddress<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaAddresses", ["type ProgramDerivedAddress"])
-    );
-  }
-  if (account.isPda && account.isSigner === "either") {
-    return pipe13(
-      fragment(`ProgramDerivedAddress<${typeParam}> | TransactionSigner<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaAddresses", ["type ProgramDerivedAddress"]),
-      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
-    );
-  }
-  if (account.isSigner === "either") {
-    return pipe13(
-      fragment(`Address<${typeParam}> | TransactionSigner<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]),
-      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
-    );
-  }
-  if (account.isSigner) {
-    return pipe13(
-      fragment(`TransactionSigner<${typeParam}>`),
-      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
-    );
-  }
-  return pipe13(fragment(`Address<${typeParam}>`), (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]));
+  const address = use("type Address", "solanaAddresses");
+  const signer = use("type TransactionSigner", "solanaSigners");
+  const pda = use("type ProgramDerivedAddress", "solanaAddresses");
+  if (account.isPda && account.isSigner === false) return fragment`${pda}<${typeParam}>`;
+  if (account.isPda && account.isSigner === "either") return fragment`${pda}<${typeParam}> | ${signer}<${typeParam}>`;
+  if (account.isSigner === "either") return fragment`${address}<${typeParam}> | ${signer}<${typeParam}>`;
+  if (account.isSigner) return fragment`${signer}<${typeParam}>`;
+  return fragment`${address}<${typeParam}>`;
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath10(instructionPath);
+  const instructionNode = getLastNodeFromPath11(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
-      fragment(""),
-      pipe13(
-        fragment(nameApi.dataArgsType(customData.importAs)),
+      void 0,
+      pipe6(
+        fragment`${nameApi.dataArgsType(customData.importAs)}`,
         (f) => mergeFragmentImports(f, [scope.dataArgsManifest.looseType.imports]),
         (f) => mapFragmentContent6(f, (c) => `${c} & `)
       )
@@ -1367,20 +1435,21 @@ function getDataArgumentsFragments(scope) {
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
   const dataArgsType = nameApi.dataArgsType(instructionDataName);
   const fragments = instructionNode.arguments.flatMap((arg) => {
-    const argFragment = getArgumentFragment(arg, fragment(dataArgsType), scope.resolvedInputs, scope.renamedArgs);
+    const argFragment = getArgumentFragment(arg, dataArgsType, scope.resolvedInputs, scope.renamedArgs);
     return argFragment ? [argFragment] : [];
   });
-  return [mergeFragments(fragments, (c) => c.join("\n")), fragment("")];
+  return [fragments.length === 0 ? void 0 : mergeFragments(fragments, (c) => c.join("\n")), fragment``];
 }
 function getExtraArgumentsFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath10(instructionPath);
+  const instructionNode = getLastNodeFromPath11(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
-    const argFragment = getArgumentFragment(arg, fragment(extraArgsType), scope.resolvedInputs, scope.renamedArgs);
+    const argFragment = getArgumentFragment(arg, extraArgsType, scope.resolvedInputs, scope.renamedArgs);
     return argFragment ? [argFragment] : [];
   });
+  if (fragments.length === 0) return;
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
@@ -1390,10 +1459,7 @@ function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   if (arg.defaultValue && arg.defaultValueStrategy === "omitted") return null;
   const renamedName = renamedArgs.get(arg.name) ?? arg.name;
   const optionalSign = arg.defaultValue || resolvedArg?.defaultValue ? "?" : "";
-  return mapFragmentContent6(
-    argsType,
-    (c) => `${camelCase7(renamedName)}${optionalSign}: ${c}["${camelCase7(arg.name)}"];`
-  );
+  return fragment`${camelCase7(renamedName)}${optionalSign}: ${argsType}["${camelCase7(arg.name)}"];`;
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
@@ -1404,24 +1470,15 @@ function getRemainingAccountsFragment(instructionNode) {
     if (argumentExists) return [];
     const isSigner = remainingAccountsNode.isSigner ?? false;
     const optionalSign = remainingAccountsNode.isOptional ?? false ? "?" : "";
-    const signerFragment = pipe13(
-      fragment(`TransactionSigner`),
-      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
-    );
-    const addressFragment = pipe13(
-      fragment(`Address`),
-      (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-    );
-    return mapFragmentContent6(
-      (() => {
-        if (isSigner === "either") {
-          return mergeFragments([signerFragment, addressFragment], (c) => c.join(" | "));
-        }
-        return isSigner ? signerFragment : addressFragment;
-      })(),
-      (c) => `${camelCase7(name)}${optionalSign}: Array<${c}>;`
-    );
+    const signerFragment = use("type TransactionSigner", "solanaSigners");
+    const addressFragment = use("type Address", "solanaAddresses");
+    const typeFragment = (() => {
+      if (isSigner === "either") return fragment`${signerFragment} | ${addressFragment}`;
+      return isSigner ? signerFragment : addressFragment;
+    })();
+    return fragment`${camelCase7(name)}${optionalSign}: Array<${typeFragment}>;`;
   });
+  if (fragments.length === 0) return;
   return mergeFragments(fragments, (c) => c.join("\n"));
 }
 
@@ -1432,12 +1489,12 @@ import {
   getAllInstructionArguments as getAllInstructionArguments2,
   isNode as isNode11
 } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath11, pipe as pipe14 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath12, pipe as pipe7 } from "@codama/visitors-core";
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = getLastNodeFromPath11(scope.instructionPath);
+  const { remainingAccounts } = getLastNodeFromPath12(scope.instructionPath);
   const fragments = (remainingAccounts ?? []).flatMap((a) => getRemainingAccountsFragment2(a, scope));
-  if (fragments.length === 0) return fragment("");
-  return pipe14(
+  if (fragments.length === 0) return;
+  return pipe7(
     mergeFragments(
       fragments,
       (c) => `// Remaining accounts.
@@ -1460,75 +1517,50 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const instructionNode = getLastNodeFromPath11(scope.instructionPath);
+  const instructionNode = getLastNodeFromPath12(scope.instructionPath);
   assertIsNode2(remainingAccounts.value, "argumentValueNode");
   const argumentName = camelCase8(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
   const isSigner = remainingAccounts.isSigner ?? false;
   const isWritable = remainingAccounts.isWritable ?? false;
-  const nonSignerRole = isWritable ? "AccountRole.WRITABLE" : "AccountRole.READONLY";
-  const signerRole = isWritable ? "AccountRole.WRITABLE_SIGNER" : "AccountRole.READONLY_SIGNER";
+  const accountRole = use("AccountRole", "solanaInstructions");
+  const nonSignerRole = isWritable ? fragment`${accountRole}.WRITABLE` : fragment`${accountRole}.READONLY`;
+  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 argumentExists = allArguments.some((arg) => arg.name === remainingAccounts.value.name);
   if (argumentExists || isSigner === false) {
-    return pipe14(
-      fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`),
-      (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"])
-    );
+    return fragment`${argumentArray}.map((address) => ({ address, role: ${role} }))`;
   }
   if (isSigner === "either") {
-    return pipe14(
-      fragment(
-        `${argumentArray}.map((addressOrSigner) => (isTransactionSigner(addressOrSigner)
-? { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner }
-: { address: addressOrSigner, role: ${role} }
-))`
-      ),
-      (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"]),
-      (f) => addFragmentImports(f, "shared", ["isTransactionSigner"])
-    );
+    return fragment`${argumentArray}.map((addressOrSigner) => (${use("isTransactionSigner", "shared")}(addressOrSigner) ? { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner } : { address: addressOrSigner, role: ${role} }))`;
   }
-  return pipe14(
-    fragment(`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`),
-    (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"])
-  );
+  return fragment`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`;
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
   assertIsNode2(remainingAccounts.value, "resolverValueNode");
   const isAsync = scope.asyncResolvers.includes(remainingAccounts.value.name);
   if (!scope.useAsync && isAsync) return null;
   const awaitKeyword = scope.useAsync && isAsync ? "await " : "";
-  const functionName = scope.nameApi.resolverFunction(remainingAccounts.value.name);
-  const module = scope.getImportFrom(remainingAccounts.value);
-  return pipe14(
-    fragment(`${awaitKeyword}${functionName}(resolverScope)`),
-    (f) => addFragmentImports(f, module, [functionName]),
+  const functionName = use(
+    scope.nameApi.resolverFunction(remainingAccounts.value.name),
+    scope.getImportFrom(remainingAccounts.value)
+  );
+  return pipe7(
+    fragment`${awaitKeyword}${functionName}(resolverScope)`,
     (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
   );
 }
 
 // src/fragments/instructionFunction.ts
 function getInstructionFunctionFragment(scope) {
-  const {
-    useAsync,
-    instructionPath,
-    resolvedInputs,
-    renamedArgs,
-    dataArgsManifest,
-    asyncResolvers,
-    nameApi,
-    customInstructionData
-  } = scope;
-  const instructionNode = getLastNodeFromPath12(instructionPath);
+  const { useAsync, instructionPath, resolvedInputs, renamedArgs, asyncResolvers, nameApi, customInstructionData } = scope;
+  const instructionNode = getLastNodeFromPath13(instructionPath);
   const programNode = findProgramNodeFromPath3(instructionPath);
-  if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
-    return fragment("");
-  }
+  if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) return;
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
-  const hasLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted" && instructionNode.accounts.some((account) => account.isOptional);
   const instructionDependencies = getInstructionDependencies(instructionNode, asyncResolvers, useAsync);
   const argDependencies = instructionDependencies.filter(isNodeFilter4("argumentValueNode")).map((node) => node.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
@@ -1546,178 +1578,297 @@ function getInstructionFunctionFragment(scope) {
   const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode12(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
-  const instructionDataName = nameApi.instructionDataType(instructionNode.name);
-  const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  const encoderFunction = customData ? dataArgsManifest.encoder.content : `${nameApi.encoderFunction(instructionDataName)}()`;
-  const argsTypeFragment = pipe15(
-    fragment(customData ? dataArgsManifest.looseType.content : nameApi.dataArgsType(instructionDataName)),
-    customData ? (f) => mergeFragmentImports(f, [dataArgsManifest.looseType.imports, dataArgsManifest.encoder.imports]) : (f) => f
-  );
+  const programAddressConstant = use(nameApi.programAddressConstant(programNode.name), "generatedPrograms");
   const functionName = useAsync ? nameApi.instructionAsyncFunction(instructionNode.name) : nameApi.instructionSyncFunction(instructionNode.name);
-  const typeParamsFragment = getTypeParams(instructionNode, programAddressConstant);
-  const instructionTypeFragment = getInstructionType(scope);
-  const inputTypeFragment = getInstructionInputTypeFragment(scope);
-  const inputTypeCallFragment = getInputTypeCall(scope);
-  const renamedArgsText = [...renamedArgs.entries()].map(([k, v]) => `${k}: input.${v}`).join(", ");
   const resolvedInputsFragment = getInstructionInputResolvedFragment(scope);
   const remainingAccountsFragment = getInstructionRemainingAccountsFragment(scope);
   const byteDeltaFragment = getInstructionByteDeltaFragment(scope);
-  const resolvedFragment = mergeFragments(
+  const resolvedInputFragment = mergeFragments(
     [resolvedInputsFragment, remainingAccountsFragment, byteDeltaFragment],
     (content) => content.join("\n\n")
   );
-  const hasRemainingAccounts = remainingAccountsFragment.content !== "";
-  const hasByteDeltas = byteDeltaFragment.content !== "";
-  const hasResolver = resolvedFragment.features.has("instruction:resolverScopeVariable");
-  const getReturnType = (instructionType) => {
-    let returnType = instructionType;
-    if (hasByteDeltas) {
-      returnType = `${returnType} & InstructionWithByteDelta`;
-    }
-    return useAsync ? `Promise<${returnType}>` : returnType;
-  };
-  return pipe15(
-    fragmentFromTemplate("instructionFunction.njk", {
-      argsTypeFragment: argsTypeFragment.content,
-      encoderFunction,
-      functionName,
-      getReturnType,
-      hasAccounts,
-      hasAnyArgs,
-      hasByteDeltas,
-      hasData,
-      hasDataArgs,
-      hasExtraArgs,
-      hasInput,
-      hasLegacyOptionalAccounts,
-      hasRemainingAccounts,
-      hasResolver,
-      inputTypeCallFragment: inputTypeCallFragment.content,
-      inputTypeFragment: inputTypeFragment.content,
-      instruction: instructionNode,
-      instructionTypeFragment: instructionTypeFragment.content,
-      programAddressConstant,
-      renamedArgs: renamedArgsText,
-      resolvedFragment: resolvedFragment.content,
-      typeParamsFragment: typeParamsFragment.content,
-      useAsync
+  const hasRemainingAccounts = !!remainingAccountsFragment;
+  const hasByteDeltas = !!byteDeltaFragment;
+  const hasResolver = resolvedInputFragment.features.has("instruction:resolverScopeVariable");
+  const instructionTypeFragment = getInstructionTypeFragment(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 functionBody = mergeFragments(
+    [
+      getProgramAddressInitializationFragment(programAddressConstant),
+      getAccountsInitializationFragment(instructionNode),
+      getArgumentsInitializationFragment(hasAnyArgs, renamedArgs),
+      getResolverScopeInitializationFragment(hasResolver, hasAccounts, hasAnyArgs),
+      resolvedInputFragment,
+      getReturnStatementFragment({
+        ...scope,
+        hasByteDeltas,
+        hasData,
+        hasDataArgs,
+        hasRemainingAccounts,
+        instructionNode,
+        syncReturnTypeFragment: getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, false)
+      })
+    ],
+    (cs) => cs.join("\n\n")
+  );
+  return fragment`${inputType}\n\nexport ${useAsync ? "async " : ""}function ${functionName}${typeParams}(${inputArg}config?: { programAddress?: TProgramAddress } ): ${returnType} {
+  ${functionBody}
+}`;
+}
+function getProgramAddressInitializationFragment(programAddressConstant) {
+  return fragment`// Program address.
+const programAddress = config?.programAddress ?? ${programAddressConstant};`;
+}
+function getAccountsInitializationFragment(instructionNode) {
+  if (instructionNode.accounts.length === 0) return;
+  const accounts = mergeFragments(
+    instructionNode.accounts.map((account) => {
+      const name = camelCase9(account.name);
+      const isWritable = account.isWritable ? "true" : "false";
+      return fragment`${name}: { value: input.${name} ?? null, isWritable: ${isWritable} }`;
     }),
-    (f) => mergeFragmentImports(f, [
-      typeParamsFragment.imports,
-      instructionTypeFragment.imports,
-      inputTypeFragment.imports,
-      inputTypeCallFragment.imports,
-      resolvedFragment.imports,
-      argsTypeFragment.imports
-    ]),
-    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
-    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]),
-    (f) => hasAccounts ? addFragmentImports(f, "solanaInstructions", ["type AccountMeta"]) : f,
-    (f) => hasAccounts ? addFragmentImports(f, "shared", ["getAccountMetaFactory", "type ResolvedAccount"]) : f,
-    (f) => hasByteDeltas ? addFragmentImports(f, "shared", ["type InstructionWithByteDelta"]) : f
+    (cs) => cs.join(", ")
   );
+  return fragment` // Original accounts.
+const originalAccounts = { ${accounts} }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ${use("type ResolvedAccount", "shared")}>;
+`;
 }
-function getTypeParams(instructionNode, programAddressConstant) {
-  const typeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase5(account.name)} extends string`);
-  typeParams.push(`TProgramAddress extends Address = typeof ${programAddressConstant}`);
-  return pipe15(
-    fragment(typeParams.filter((x) => !!x).join(", ")),
-    (f) => mapFragmentContent7(f, (c) => `<${c}>`),
-    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant])
+function getArgumentsInitializationFragment(hasAnyArgs, renamedArgs) {
+  if (!hasAnyArgs) return;
+  const renamedArgsText = [...renamedArgs.entries()].map(([k, v]) => `${k}: input.${v}`).join(", ");
+  return fragment`// Original args.
+const args = { ...input, ${renamedArgsText} };
+`;
+}
+function getResolverScopeInitializationFragment(hasResolver, hasAccounts, hasAnyArgs) {
+  if (!hasResolver) return;
+  const resolverAttributes = [
+    "programAddress",
+    ...hasAccounts ? ["accounts"] : [],
+    ...hasAnyArgs ? ["args"] : []
+  ].join(", ");
+  return fragment`// Resolver scope.
+const resolverScope = { ${resolverAttributes} };`;
+}
+function getReturnStatementFragment(scope) {
+  const { instructionNode, hasByteDeltas, hasData, hasDataArgs, hasRemainingAccounts, nameApi } = scope;
+  const optionalAccountStrategy = instructionNode.optionalAccountStrategy ?? "programId";
+  const hasAccounts = instructionNode.accounts.length > 0;
+  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.${camelCase9(account.name)})`),
+    ...hasRemainingAccounts ? ["...remainingAccounts"] : []
+  ].join(", ");
+  let accounts;
+  if (hasAccounts && hasLegacyOptionalAccounts) {
+    accounts = fragment`accounts: [${accountItems}].filter(<T>(x: T | undefined): x is T => x !== undefined)`;
+  } else if (hasAccounts) {
+    accounts = fragment`accounts: [${accountItems}]`;
+  } else if (hasRemainingAccounts) {
+    accounts = fragment`accounts: remainingAccounts`;
+  }
+  const customData = scope.customInstructionData.get(instructionNode.name);
+  const instructionDataName = nameApi.instructionDataType(instructionNode.name);
+  const encoderFunctionFragment = customData ? scope.dataArgsManifest.encoder : `${nameApi.encoderFunction(instructionDataName)}()`;
+  const argsTypeFragment = customData ? scope.dataArgsManifest.looseType : nameApi.dataArgsType(instructionDataName);
+  let data;
+  if (hasDataArgs) {
+    data = fragment`data: ${encoderFunctionFragment}.encode(args as ${argsTypeFragment})`;
+  } else if (hasData) {
+    data = fragment`data: ${encoderFunctionFragment}.encode({})`;
+  }
+  const instructionAttributes = pipe8(
+    [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(
+    instructionTypeFragment,
+    (f) => hasByteDeltas ? fragment`${f} & ${use("type InstructionWithByteDelta", "shared")}` : f,
+    (f) => useAsync ? fragment`Promise<${f}>` : f
+  );
+}
+function getTypeParamsFragment(instructionNode, programAddressConstant) {
+  return mergeFragments(
+    [
+      ...instructionNode.accounts.map((account) => fragment`TAccount${pascalCase5(account.name)} extends string`),
+      fragment`TProgramAddress extends ${use("type Address", "solanaAddresses")} = typeof ${programAddressConstant}`
+    ],
+    (cs) => `<${cs.join(", ")}>`
   );
 }
-function getInstructionType(scope) {
+function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath12(instructionPath);
+  const instructionNode = getLastNodeFromPath13(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
-  const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
-    const typeParam = `TAccount${pascalCase5(account.name)}`;
+    const typeParam = fragment`TAccount${pascalCase5(account.name)}`;
     const camelName = camelCase9(account.name);
     if (account.isSigner === "either") {
-      const signerRole = account.isWritable ? "WritableSignerAccount" : "ReadonlySignerAccount";
-      return pipe15(
-        fragment(
-          `typeof input["${camelName}"] extends TransactionSigner<${typeParam}> ? ${signerRole}<${typeParam}> & AccountSignerMeta<${typeParam}> : ${typeParam}`
-        ),
-        (f) => addFragmentImports(f, "solanaInstructions", [`type ${signerRole}`]),
-        (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta"])
+      const signerRole = use(
+        account.isWritable ? "type WritableSignerAccount" : "type ReadonlySignerAccount",
+        "solanaInstructions"
+      );
+      return pipe8(
+        fragment`typeof input["${camelName}"] extends TransactionSigner<${typeParam}> ? ${signerRole}<${typeParam}> & AccountSignerMeta<${typeParam}> : ${typeParam}`,
+        (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta", "type TransactionSigner"])
       );
     }
-    return fragment(typeParam);
+    return typeParam;
   });
-  return pipe15(
-    mergeFragments([programAddressFragment, ...accountTypeParamsFragments], (c) => c.join(", ")),
+  return pipe8(
+    mergeFragments([fragment`TProgramAddress`, ...accountTypeParamsFragments], (c) => c.join(", ")),
     (f) => mapFragmentContent7(f, (c) => `${instructionTypeName}<${c}>`)
   );
 }
-function getInputTypeCall(scope) {
+function getInputTypeCallFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath12(instructionPath);
+  const instructionNode = getLastNodeFromPath13(instructionPath);
   const inputTypeName = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
-  if (instructionNode.accounts.length === 0) return fragment(inputTypeName);
+  if (instructionNode.accounts.length === 0) return fragment`${inputTypeName}`;
   const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase5(account.name)}`).join(", ");
-  return fragment(`${inputTypeName}<${accountTypeParams}>`);
+  return fragment`${inputTypeName}<${accountTypeParams}>`;
 }
 
+// src/fragments/instructionPage.ts
+import { logWarn } from "@codama/errors";
+import { camelCase as camelCase11, 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 { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath13, pipe as pipe16 } from "@codama/visitors-core";
+import { camelCase as camelCase10 } from "@codama/nodes";
+import { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath14, pipe as pipe9 } from "@codama/visitors-core";
 function getInstructionParseFunctionFragment(scope) {
-  const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath13(instructionPath);
-  const programNode = findProgramNodeFromPath4(instructionPath);
-  const customData = customInstructionData.get(instructionNode.name);
-  const hasAccounts = instructionNode.accounts.length > 0;
-  const hasOptionalAccounts = instructionNode.accounts.some((account) => account.isOptional);
-  const minimumNumberOfAccounts = instructionNode.optionalAccountStrategy === "omitted" ? instructionNode.accounts.filter((account) => !account.isOptional).length : instructionNode.accounts.length;
-  const hasData = !!customData || instructionNode.arguments.length > 0;
-  const instructionDataName = nameApi.instructionDataType(instructionNode.name);
-  const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  const dataTypeFragment = customData ? pipe16(
-    fragment(dataArgsManifest.strictType.content),
-    (f) => mergeFragmentImports(f, [dataArgsManifest.strictType.imports, dataArgsManifest.decoder.imports])
-  ) : fragment(nameApi.dataType(instructionDataName));
-  const decoderFunction = customData ? dataArgsManifest.decoder.content : `${nameApi.decoderFunction(instructionDataName)}()`;
-  return pipe16(
-    fragmentFromTemplate("instructionParseFunction.njk", {
-      dataTypeFragment: dataTypeFragment.content,
-      decoderFunction,
-      hasAccounts,
-      hasData,
-      hasOptionalAccounts,
-      instruction: instructionNode,
-      instructionParseFunction: nameApi.instructionParseFunction(instructionNode.name),
-      instructionParsedType: nameApi.instructionParsedType(instructionNode.name),
-      minimumNumberOfAccounts,
-      programAddressConstant
+  const instructionNode = getLastNodeFromPath14(scope.instructionPath);
+  const programNode = findProgramNodeFromPath4(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"));
+}
+function getTypeFragment2(scope) {
+  const customData = scope.customInstructionData.get(scope.instructionNode.name);
+  const instructionParsedType = scope.nameApi.instructionParsedType(scope.instructionNode.name);
+  const instructionDataName = scope.nameApi.instructionDataType(scope.instructionNode.name);
+  const hasData = !!customData || scope.instructionNode.arguments.length > 0;
+  const hasAccounts = scope.instructionNode.accounts.length > 0;
+  const typeParamDeclarations = mergeFragments(
+    [
+      fragment`TProgram extends string = typeof ${scope.programAddressConstant}`,
+      hasAccounts ? fragment`TAccountMetas extends readonly ${use("type AccountMeta", "solanaInstructions")}[] = readonly AccountMeta[]` : void 0
+    ],
+    (cs) => cs.join(", ")
+  );
+  const accounts = mergeFragments(
+    scope.instructionNode.accounts.map((account, i) => {
+      const docs = getDocblockFragment(account.docs ?? [], true);
+      const name = camelCase10(account.name);
+      return fragment`${docs}${name}${account.isOptional ? "?" : ""}: TAccountMetas[${i}]${account.isOptional ? " | undefined" : ""};`;
     }),
-    (f) => mergeFragmentImports(f, [dataTypeFragment.imports]),
-    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
-    (f) => addFragmentImports(f, "solanaInstructions", ["type Instruction"]),
-    hasAccounts ? (f) => addFragmentImports(f, "solanaInstructions", ["type InstructionWithAccounts", "type AccountMeta"]) : (f) => f,
-    hasData ? (f) => addFragmentImports(
-      addFragmentImports(f, "solanaInstructions", ["type InstructionWithData"]),
-      "solanaCodecsCore",
-      ["type ReadonlyUint8Array"]
-    ) : (f) => f
+    (cs) => hasAccounts ? `
+accounts: {
+${cs.join("\n")}
+};` : ""
+  );
+  const dataTypeFragment = customData ? scope.dataArgsManifest.strictType : fragment`${scope.nameApi.dataType(instructionDataName)}`;
+  const data = hasData ? fragment`\ndata: ${dataTypeFragment};` : fragment``;
+  return fragment`export type ${instructionParsedType}<${typeParamDeclarations}> = { programAddress: ${use("type Address", "solanaAddresses")}<TProgram>;${accounts}${data} };`;
+}
+function getFunctionFragment(scope) {
+  const customData = scope.customInstructionData.get(scope.instructionNode.name);
+  const instructionParsedType = scope.nameApi.instructionParsedType(scope.instructionNode.name);
+  const instructionParseFunction = scope.nameApi.instructionParseFunction(scope.instructionNode.name);
+  const instructionDataName = scope.nameApi.instructionDataType(scope.instructionNode.name);
+  const decoderFunction = customData ? scope.dataArgsManifest.decoder : fragment`${scope.nameApi.decoderFunction(instructionDataName)}()`;
+  const hasData = !!customData || scope.instructionNode.arguments.length > 0;
+  const hasAccounts = scope.instructionNode.accounts.length > 0;
+  const hasOptionalAccounts = scope.instructionNode.accounts.some((account) => account.isOptional);
+  const minimumNumberOfAccounts = scope.instructionNode.optionalAccountStrategy === "omitted" ? scope.instructionNode.accounts.filter((account) => !account.isOptional).length : scope.instructionNode.accounts.length;
+  const typeParams = ["TProgram", hasAccounts ? "TAccountMetas" : void 0].filter(Boolean).join(", ");
+  const typeParamDeclarations = mergeFragments(
+    [
+      fragment`TProgram extends string`,
+      hasAccounts ? fragment`TAccountMetas extends readonly ${use("type AccountMeta", "solanaInstructions")}[]` : void 0
+    ],
+    (cs) => cs.join(", ")
+  );
+  const instructionType = mergeFragments(
+    [
+      fragment`${use("type Instruction", "solanaInstructions")}<TProgram>`,
+      hasAccounts ? fragment`${use("type InstructionWithAccounts", "solanaInstructions")}<TAccountMetas>` : void 0,
+      hasData ? pipe9(
+        fragment`InstructionWithData<ReadonlyUint8Array>`,
+        (f) => addFragmentImports(f, "solanaInstructions", ["type InstructionWithData"]),
+        (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
+      ) : void 0
+    ],
+    (cs) => cs.join(" & ")
+  );
+  let accountHelpers;
+  if (hasAccounts) {
+    accountHelpers = fragment`if (instruction.accounts.length < ${minimumNumberOfAccounts}) {
+  // TODO: Coded error.
+  throw new Error('Not enough accounts');
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}`;
+  }
+  if (hasOptionalAccounts && scope.instructionNode.optionalAccountStrategy === "omitted") {
+    accountHelpers = fragment`${accountHelpers}
+let optionalAccountsRemaining = instruction.accounts.length - ${minimumNumberOfAccounts};
+const getNextOptionalAccount = () => {
+  if (optionalAccountsRemaining === 0) return undefined;
+  optionalAccountsRemaining -= 1;
+  return getNextAccount();
+};`;
+  } else if (hasOptionalAccounts) {
+    accountHelpers = fragment`${accountHelpers}
+const getNextOptionalAccount = () => {
+  const accountMeta = getNextAccount();
+  return accountMeta.address === ${scope.programAddressConstant} ? undefined : accountMeta;
+};`;
+  }
+  const accounts = mergeFragments(
+    scope.instructionNode.accounts.map(
+      (account) => account.isOptional ? fragment`${camelCase10(account.name)}: getNextOptionalAccount()` : fragment`${camelCase10(account.name)}: getNextAccount()`
+    ),
+    (cs) => hasAccounts ? `, accounts: { ${cs.join(", ")} }` : ""
   );
+  const data = hasData ? fragment`, data: ${decoderFunction}.decode(instruction.data)` : fragment``;
+  return fragment`export function ${instructionParseFunction}<${typeParamDeclarations}>(instruction: ${instructionType}): ${instructionParsedType}<${typeParams}> {
+  ${accountHelpers}
+  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 getLastNodeFromPath14, pipe as pipe17 } from "@codama/visitors-core";
-function getInstructionTypeFragment(scope) {
+import { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath15 } from "@codama/visitors-core";
+function getInstructionTypeFragment2(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = getLastNodeFromPath14(instructionPath);
+  const instructionNode = getLastNodeFromPath15(instructionPath);
   const programNode = findProgramNodeFromPath5(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
-  const instructionDataName = nameApi.instructionDataType(instructionNode.name);
-  const programAddressConstant = nameApi.programAddressConstant(programNode.name);
-  const dataType = customData ? pascalCase6(customData.importAs) : pascalCase6(instructionDataName);
-  const accountTypeParamsFragment = mergeFragments(
+  const instructionType = nameApi.instructionType(instructionNode.name);
+  const programAddressConstant = use(nameApi.programAddressConstant(programNode.name), "generatedPrograms");
+  const accountTypeParams = mergeFragments(
     instructionNode.accounts.map(
       (account) => getInstructionAccountTypeParamFragment({
         ...scope,
@@ -1725,8 +1876,9 @@ function getInstructionTypeFragment(scope) {
         instructionAccountPath: [...instructionPath, account]
       })
     ),
-    (renders) => renders.join(", ")
+    (cs) => cs.length > 0 ? `${cs.join(", ")}, ` : ""
   );
+  const data = hasData ? fragment` & ${use("type InstructionWithData", "solanaInstructions")}<${use("type ReadonlyUint8Array", "solanaCodecsCore")}>` : void 0;
   const usesLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted";
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
@@ -1740,95 +1892,149 @@ function getInstructionTypeFragment(scope) {
     ),
     (c) => c.join(", ")
   );
-  const fragment2 = pipe17(
-    fragmentFromTemplate("instructionType.njk", {
-      accountMetas: accountMetasFragment.content,
-      accountTypeParams: accountTypeParamsFragment.content,
-      dataType,
-      hasAccounts,
-      hasData,
-      instruction: instructionNode,
-      instructionType: nameApi.instructionType(instructionNode.name),
-      programAddressConstant
-    }),
-    (f) => mergeFragmentImports(f, [accountTypeParamsFragment.imports, accountMetasFragment.imports]),
-    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
-    (f) => addFragmentImports(f, "solanaInstructions", [
-      "type AccountMeta",
-      "type Instruction",
-      "type InstructionWithAccounts",
-      ...hasData ? ["type InstructionWithData"] : []
-    ])
+  const instructionWithAccounts = use("type InstructionWithAccounts", "solanaInstructions");
+  const accounts = hasAccounts ? fragment` & ${instructionWithAccounts}<[${accountMetasFragment}, ...TRemainingAccounts]>` : fragment` & ${instructionWithAccounts}<TRemainingAccounts>`;
+  return fragment`export type ${instructionType}<TProgram extends string = typeof ${programAddressConstant}, ${accountTypeParams}TRemainingAccounts extends readonly ${use("type AccountMeta", "solanaInstructions")}<string>[] = []> =
+${use("type Instruction", "solanaInstructions")}<TProgram>${data}${accounts};`;
+}
+
+// src/fragments/instructionPage.ts
+function getInstructionPageFragment(scope) {
+  const node = getLastNodeFromPath16(scope.instructionPath);
+  if (!findProgramNodeFromPath6(scope.instructionPath)) {
+    throw new Error("Instruction must be visited inside a program.");
+  }
+  const childScope = {
+    ...scope,
+    dataArgsManifest: visit5(node, scope.typeManifestVisitor),
+    extraArgsManifest: visit5(
+      definedTypeNode2({
+        name: scope.nameApi.instructionExtraType(node.name),
+        type: structTypeNodeFromInstructionArgumentNodes3(node.extraArguments ?? [])
+      }),
+      scope.typeManifestVisitor
+    ),
+    renamedArgs: getRenamedArgsMap(node)
+  };
+  return mergeFragments(
+    [
+      getDiscriminatorConstantsFragment({
+        ...childScope,
+        discriminatorNodes: node.discriminators ?? [],
+        fields: node.arguments,
+        prefix: node.name
+      }),
+      getInstructionTypeFragment2(childScope),
+      getInstructionDataFragment(childScope),
+      getInstructionExtraArgsFragment(childScope),
+      getInstructionFunctionFragment({ ...childScope, useAsync: true }),
+      getInstructionFunctionFragment({ ...childScope, useAsync: false }),
+      getInstructionParseFunctionFragment(childScope)
+    ],
+    (cs) => cs.join("\n\n")
+  );
+}
+function getRenamedArgsMap(instruction) {
+  const argNames = [
+    ...instruction.arguments.map((a) => a.name),
+    ...(instruction.extraArguments ?? []).map((a) => a.name)
+  ];
+  const duplicateArgs = argNames.filter((e, i, a) => a.indexOf(e) !== i);
+  if (duplicateArgs.length > 0) {
+    throw new Error(`Duplicate args found: [${duplicateArgs.join(", ")}] in instruction [${instruction.name}].`);
+  }
+  const allNames = [...instruction.accounts.map((account) => account.name), ...argNames];
+  const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
+  if (duplicates.length === 0) return /* @__PURE__ */ new Map();
+  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 fragment2;
+  return new Map(duplicates.map((name) => [camelCase11(name), camelCase11(`${name}Arg`)]));
 }
 
 // src/fragments/pdaFunction.ts
-import { isNode as isNode13, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
-import { findProgramNodeFromPath as findProgramNodeFromPath6, getLastNodeFromPath as getLastNodeFromPath15, pipe as pipe18, visit as visit4 } from "@codama/visitors-core";
+import { camelCase as camelCase12, 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 { pdaPath, typeManifestVisitor, nameApi } = scope;
-  const pdaNode = getLastNodeFromPath15(pdaPath);
-  const programNode = findProgramNodeFromPath6(pdaPath);
-  const imports = new ImportMap();
-  const seeds = pdaNode.seeds.map((seed) => {
+  const pdaNode = getLastNodeFromPath17(scope.pdaPath);
+  const seeds = parsePdaSeedNodes(pdaNode.seeds, scope);
+  return mergeFragments(
+    [getSeedInputTypeFragment(seeds, scope), getFunctionFragment2(seeds, scope)],
+    (cs) => cs.join("\n\n")
+  );
+}
+function getSeedInputTypeFragment(seeds, scope) {
+  const variableSeeds = seeds.filter(isNodeFilter5("variablePdaSeedNode"));
+  if (variableSeeds.length === 0) return;
+  const pdaNode = getLastNodeFromPath17(scope.pdaPath);
+  const seedTypeName = scope.nameApi.pdaSeedsType(pdaNode.name);
+  const seedAttributes = mergeFragments(
+    variableSeeds.map((seed) => seed.inputAttribute),
+    (cs) => cs.join("\n")
+  );
+  return fragment`export type ${seedTypeName} = {\n${seedAttributes}\n};`;
+}
+function getFunctionFragment2(seeds, scope) {
+  const pdaNode = getLastNodeFromPath17(scope.pdaPath);
+  const programNode = findProgramNodeFromPath7(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 seedArgument = hasVariableSeeds ? `seeds: ${seedTypeName}, ` : "";
+  const programAddress = pdaNode.programId ?? programNode.publicKey;
+  const encodedSeeds = mergeFragments(
+    seeds.map((s) => s.encodedValue),
+    (cs) => cs.join(", ")
+  );
+  return fragment`${docs}export async function ${findPdaFunction}(${seedArgument}config: { programAddress?: ${addressType} | undefined } = {}): Promise<${pdaType}> {
+  const { programAddress = '${programAddress}' as ${addressType}<'${programAddress}'> } = config;
+  return await ${getPdaFunction}({ programAddress, seeds: [${encodedSeeds}]});
+}`;
+}
+function parsePdaSeedNodes(seeds, scope) {
+  return seeds.map((seed) => {
     if (isNode13(seed, "variablePdaSeedNode")) {
-      const seedManifest2 = visit4(seed.type, typeManifestVisitor);
-      imports.mergeWith(seedManifest2.looseType, seedManifest2.encoder);
-      return { ...seed, typeManifest: seedManifest2 };
+      const name = camelCase12(seed.name);
+      const docs = getDocblockFragment(seed.docs ?? [], true);
+      const { encoder: encoder2, looseType } = visit6(seed.type, scope.typeManifestVisitor);
+      return {
+        ...seed,
+        encodedValue: fragment`${encoder2}.encode(seeds.${name})`,
+        inputAttribute: fragment`${docs}${name}: ${looseType};`
+      };
     }
     if (isNode13(seed.value, "programIdValueNode")) {
-      imports.add("solanaAddresses", "getAddressEncoder");
-      return seed;
+      const addressEncoder = use("getAddressEncoder", "solanaAddresses");
+      return { ...seed, encodedValue: fragment`${addressEncoder}().encode(programAddress)` };
     }
-    const seedManifest = visit4(seed.type, typeManifestVisitor);
-    imports.mergeWith(seedManifest.encoder);
-    const valueManifest = visit4(seed.value, typeManifestVisitor).value;
-    imports.mergeWith(valueManifest.imports);
-    return { ...seed, typeManifest: seedManifest, valueManifest };
+    const { encoder } = visit6(seed.type, scope.typeManifestVisitor);
+    const { value } = visit6(seed.value, scope.typeManifestVisitor);
+    return { ...seed, encodedValue: fragment`${encoder}.encode(${value})` };
   });
-  const hasVariableSeeds = pdaNode.seeds.filter(isNodeFilter5("variablePdaSeedNode")).length > 0;
-  return pipe18(
-    fragmentFromTemplate("pdaFunction.njk", {
-      findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
-      hasVariableSeeds,
-      pdaDocs: pdaNode.docs,
-      pdaSeedsType: nameApi.pdaSeedsType(pdaNode.name),
-      programAddress: pdaNode.programId ?? programNode.publicKey,
-      seeds
-    }),
-    (f) => mergeFragmentImports(f, [imports]),
-    (f) => addFragmentImports(f, "solanaAddresses", [
-      "type Address",
-      "getProgramDerivedAddress",
-      "type ProgramDerivedAddress"
-    ])
-  );
 }
 
-// src/fragments/program.ts
-import { pipe as pipe19 } from "@codama/visitors-core";
-function getProgramFragment(scope) {
-  const { programNode, nameApi } = scope;
-  return pipe19(
-    fragmentFromTemplate("program.njk", {
-      program: programNode,
-      programAddressConstant: nameApi.programAddressConstant(programNode.name)
-    }),
-    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-  );
+// src/fragments/pdaPage.ts
+import { findProgramNodeFromPath as findProgramNodeFromPath8 } from "@codama/visitors-core";
+function getPdaPageFragment(scope) {
+  if (!findProgramNodeFromPath8(scope.pdaPath)) {
+    throw new Error("PDA must be visited inside a program.");
+  }
+  return getPdaFunctionFragment(scope);
 }
 
 // src/fragments/programAccounts.ts
-import { resolveNestedTypeNode as resolveNestedTypeNode2 } from "@codama/nodes";
+import { resolveNestedTypeNode as resolveNestedTypeNode3 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent9 } from "@codama/renderers-core";
-import { pipe as pipe20 } from "@codama/visitors-core";
+import { pipe as pipe10 } from "@codama/visitors-core";
 function getProgramAccountsFragment(scope) {
-  if (scope.programNode.accounts.length === 0) return fragment("");
+  if (scope.programNode.accounts.length === 0) return;
   return mergeFragments(
     [getProgramAccountsEnumFragment(scope), getProgramAccountsIdentifierFunctionFragment(scope)],
-    (c) => `${c.join("\n\n")}
-`
+    (c) => c.join("\n\n")
   );
 }
 function getProgramAccountsEnumFragment(scope) {
@@ -1837,7 +2043,7 @@ function getProgramAccountsEnumFragment(scope) {
   const programAccountsEnumVariants = programNode.accounts.map(
     (account) => nameApi.programAccountsEnumVariant(account.name)
   );
-  return fragment(`export enum ${programAccountsEnum} { ${programAccountsEnumVariants.join(", ")} }`);
+  return fragment`export enum ${programAccountsEnum} { ${programAccountsEnumVariants.join(", ")} }`;
 }
 function getProgramAccountsIdentifierFunctionFragment(scope) {
   const { programNode, nameApi } = scope;
@@ -1845,10 +2051,10 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
     (account) => (account.discriminators ?? []).length > 0
   );
   const hasAccountDiscriminators = accountsWithDiscriminators.length > 0;
-  if (!hasAccountDiscriminators) return fragment("");
+  if (!hasAccountDiscriminators) return;
   const programAccountsEnum = nameApi.programAccountsEnum(programNode.name);
   const programAccountsIdentifierFunction = nameApi.programAccountsIdentifierFunction(programNode.name);
-  return pipe20(
+  return pipe10(
     mergeFragments(
       accountsWithDiscriminators.map((account) => {
         const variant = nameApi.programAccountsEnumVariant(account.name);
@@ -1857,7 +2063,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
           dataName: "data",
           discriminators: account.discriminators ?? [],
           ifTrue: `return ${programAccountsEnum}.${variant};`,
-          struct: resolveNestedTypeNode2(account.data)
+          struct: resolveNestedTypeNode3(account.data)
         });
       }),
       (c) => c.join("\n")
@@ -1874,25 +2080,13 @@ throw new Error("The provided account could not be identified as a ${programNode
   );
 }
 
-// src/fragments/programErrors.ts
-import { pipe as pipe21 } from "@codama/visitors-core";
-function getProgramErrorsFragment(scope) {
+// 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 pipe21(
-    fragmentFromTemplate("programErrors.njk", {
-      errors: programNode.errors,
-      escapeProgramErrorMessage: (message) => message.replace(/`/g, "\\`"),
-      getProgramErrorConstant: (name) => nameApi.programErrorConstantPrefix(programNode.name) + nameApi.programErrorConstant(name),
-      programAddressConstant,
-      programErrorMessagesMap: nameApi.programErrorMessagesMap(programNode.name),
-      programErrorUnion: nameApi.programErrorUnion(programNode.name),
-      programGetErrorMessageFunction: nameApi.programGetErrorMessageFunction(programNode.name),
-      programIsErrorFunction: nameApi.programIsErrorFunction(programNode.name)
-    }),
-    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
-    (f) => addFragmentImports(f, "solanaPrograms", ["isProgramError"]),
-    (f) => addFragmentImports(f, "solanaErrors", ["type SolanaError", "type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM"]),
+  return pipe11(
+    fragment`export const ${programAddressConstant} = '${programNode.publicKey}' as Address<'${programNode.publicKey}'>;`,
     (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
   );
 }
@@ -1900,12 +2094,12 @@ function getProgramErrorsFragment(scope) {
 // src/fragments/programInstructions.ts
 import {
   getAllInstructionsWithSubs,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent10 } from "@codama/renderers-core";
-import { pipe as pipe22 } from "@codama/visitors-core";
+import { pipe as pipe12 } from "@codama/visitors-core";
 function getProgramInstructionsFragment(scope) {
-  if (scope.programNode.instructions.length === 0) return fragment("");
+  if (scope.programNode.instructions.length === 0) return;
   const allInstructions = getAllInstructionsWithSubs(scope.programNode, {
     leavesOnly: !scope.renderParentInstructions,
     subInstructionsFirst: true
@@ -1917,8 +2111,7 @@ function getProgramInstructionsFragment(scope) {
       getProgramInstructionsIdentifierFunctionFragment(scopeWithInstructions),
       getProgramInstructionsParsedUnionTypeFragment(scopeWithInstructions)
     ],
-    (c) => `${c.join("\n\n")}
-`
+    (c) => c.join("\n\n")
   );
 }
 function getProgramInstructionsEnumFragment(scope) {
@@ -1927,9 +2120,7 @@ function getProgramInstructionsEnumFragment(scope) {
   const programInstructionsEnumVariants = allInstructions.map(
     (instruction) => nameApi.programInstructionsEnumVariant(instruction.name)
   );
-  return fragment(
-    `export enum ${programInstructionsEnum} { ${programInstructionsEnumVariants.join(", ")} }`
-  );
+  return fragment`export enum ${programInstructionsEnum} { ${programInstructionsEnumVariants.join(", ")} }`;
 }
 function getProgramInstructionsIdentifierFunctionFragment(scope) {
   const { programNode, nameApi, allInstructions } = scope;
@@ -1937,7 +2128,7 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
     (instruction) => (instruction.discriminators ?? []).length > 0
   );
   const hasInstructionDiscriminators = instructionsWithDiscriminators.length > 0;
-  if (!hasInstructionDiscriminators) return fragment("");
+  if (!hasInstructionDiscriminators) return;
   const programInstructionsEnum = nameApi.programInstructionsEnum(programNode.name);
   const programInstructionsIdentifierFunction = nameApi.programInstructionsIdentifierFunction(programNode.name);
   const discriminatorsFragment = mergeFragments(
@@ -1948,12 +2139,12 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: structTypeNodeFromInstructionArgumentNodes3(instruction.arguments)
+        struct: structTypeNodeFromInstructionArgumentNodes4(instruction.arguments)
       });
     }),
     (c) => c.join("\n")
   );
-  return pipe22(
+  return pipe12(
     discriminatorsFragment,
     (f) => mapFragmentContent10(
       f,
@@ -1973,78 +2164,256 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
   const programInstructionsEnum = nameApi.programInstructionsEnum(programNode.name);
   const typeVariants = allInstructions.map((instruction) => {
     const instructionEnumVariant = nameApi.programInstructionsEnumVariant(instruction.name);
-    const parsedInstructionType = nameApi.instructionParsedType(instruction.name);
-    return pipe22(
-      fragment(
-        `| { instructionType: ${programInstructionsEnum}.${instructionEnumVariant} } & ${parsedInstructionType}<TProgram>`
-      ),
-      (f) => addFragmentImports(f, "generatedInstructions", [`type ${parsedInstructionType}`])
+    const parsedInstructionType = use(
+      `type ${nameApi.instructionParsedType(instruction.name)}`,
+      "generatedInstructions"
     );
+    return fragment`| { instructionType: ${programInstructionsEnum}.${instructionEnumVariant} } & ${parsedInstructionType}<TProgram>`;
   });
   return mergeFragments(
     [
-      fragment(`export type ${programInstructionsType}<TProgram extends string = '${programAddress}'> =`),
-      ...typeVariants
+      fragment`export type ${programInstructionsType}<TProgram extends string = '${programAddress}'> =`,
+      ...typeVariants
+    ],
+    (c) => c.join("\n")
+  );
+}
+
+// src/fragments/programPage.ts
+function getProgramPageFragment(scope) {
+  return mergeFragments(
+    [getProgramConstantFragment(scope), getProgramAccountsFragment(scope), getProgramInstructionsFragment(scope)],
+    (cs) => cs.join("\n\n")
+  );
+}
+
+// src/fragments/rootIndexPage.ts
+function getRootIndexPageFragment(scope) {
+  const hasAnythingToExport = scope.programsToExport.length > 0 || scope.accountsToExport.length > 0 || scope.instructionsToExport.length > 0 || scope.definedTypesToExport.length > 0;
+  if (!hasAnythingToExport) {
+    return fragment`export default {};`;
+  }
+  const programsWithErrorsToExport = scope.programsToExport.filter((p) => p.errors.length > 0);
+  return mergeFragments(
+    [
+      scope.accountsToExport.length > 0 ? getExportAllFragment("./accounts") : void 0,
+      programsWithErrorsToExport.length > 0 ? getExportAllFragment("./errors") : void 0,
+      scope.instructionsToExport.length > 0 ? getExportAllFragment("./instructions") : void 0,
+      scope.pdasToExport.length > 0 ? getExportAllFragment("./pdas") : void 0,
+      scope.programsToExport.length > 0 ? getExportAllFragment("./programs") : void 0,
+      scope.definedTypesToExport.length > 0 ? getExportAllFragment("./types") : void 0
     ],
-    (c) => c.join("\n")
+    (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.
+ * @internal
+ */
+export function expectSome<T>(value: T | null | undefined): T {
+  if (value === null || value === undefined) {
+    throw new Error('Expected a value but received null or undefined.');
+  }
+  return value;
+}
+
+/**
+ * Asserts that the given value is a PublicKey.
+ * @internal
+ */
+export function expectAddress<T extends string = string>(
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
+): Address<T> {
+  if (!value) {
+    throw new Error('Expected a Address.');
+  }
+  if (typeof value === 'object' && "address" in value) {
+    return value.address;
+  }
+  if (Array.isArray(value)) {
+    return value[0] as Address<T>;
+  }
+  return value as Address<T>;
+}
+
+/**
+ * Asserts that the given value is a PDA.
+ * @internal
+ */
+export function expectProgramDerivedAddress<T extends string = string>(
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
+): ProgramDerivedAddress<T> {
+  if (!value || !Array.isArray(value) || !isProgramDerivedAddress(value)) {
+    throw new Error('Expected a ProgramDerivedAddress.');
+  }
+  return value;
+}
+
+/**
+ * Asserts that the given value is a TransactionSigner.
+ * @internal
+ */
+export function expectTransactionSigner<T extends string = string>(
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
+): TransactionSigner<T> {
+  if (!value || !isTransactionSigner(value)) {
+    throw new Error('Expected a TransactionSigner.');
+  }
+  return value;
+}
+
+/**
+ * Defines an instruction account to resolve.
+ * @internal
+ */
+export type ResolvedAccount<T extends string = string, U extends Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null = Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null> = {
+  isWritable: boolean;
+  value: U;
+};
+
+ /**
+ * Defines an instruction that stores additional bytes on-chain.
+ * @internal
+ */
+export type InstructionWithByteDelta = {
+  byteDelta: number;
+};
+
+/**
+* Get account metas and signers from resolved accounts.
+* @internal
+*/
+export function getAccountMetaFactory(
+  programAddress: Address,
+  optionalAccountStrategy: 'omitted' | 'programId',
+) {
+  return (account: ResolvedAccount): AccountMeta | AccountSignerMeta | undefined => {
+    if (!account.value) {
+      if (optionalAccountStrategy === 'omitted') return;
+      return Object.freeze({ address: programAddress, role: AccountRole.READONLY });
+    }
+
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    return Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
+      ...(isTransactionSigner(account.value) ? { signer: account.value } : {})
+    });
+  };
+}
+
+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(
+    sharedPage,
+    (f) => addFragmentImports(f, "solanaAddresses", [
+      "type Address",
+      "isProgramDerivedAddress",
+      "type ProgramDerivedAddress"
+    ]),
+    (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole", "type AccountMeta", "upgradeRoleToSigner"]),
+    (f) => addFragmentImports(f, "solanaSigners", [
+      "type AccountSignerMeta",
+      "isTransactionSigner as kitIsTransactionSigner",
+      "type TransactionSigner"
+    ])
   );
 }
 
 // src/fragments/typeDiscriminatedUnionHelpers.ts
 import { isDataEnum as isDataEnum3, isNode as isNode14 } from "@codama/nodes";
-import { pipe as pipe23 } from "@codama/visitors-core";
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
   const isDiscriminatedUnion = isNode14(typeNode, "enumTypeNode") && isDataEnum3(typeNode);
-  if (!isDiscriminatedUnion) {
-    return fragment("");
-  }
-  return pipe23(
-    fragmentFromTemplate("typeDiscriminatedUnionHelpers.njk", {
-      discriminatedUnionDiscriminator: nameApi.discriminatedUnionDiscriminator(name),
-      discriminatedUnionFunction: nameApi.discriminatedUnionFunction(name),
-      getVariant: (variant) => nameApi.discriminatedUnionVariant(variant),
-      isDiscriminatedUnionFunction: nameApi.isDiscriminatedUnionFunction(name),
-      looseName: nameApi.dataArgsType(name),
-      strictName: nameApi.dataType(name),
-      typeNode
+  if (!isDiscriminatedUnion) return;
+  const functionName = nameApi.discriminatedUnionFunction(name);
+  const isDiscriminatedUnionFunctionName = nameApi.isDiscriminatedUnionFunction(name);
+  const discriminatorName = nameApi.discriminatedUnionDiscriminator(name);
+  const strictName = nameApi.dataType(name);
+  const looseName = nameApi.dataArgsType(name);
+  const getVariantContentType = use("type GetDiscriminatedUnionVariantContent", "solanaCodecsDataStructures");
+  const getVariantType = use("type GetDiscriminatedUnionVariant", "solanaCodecsDataStructures");
+  const variantSignatures = mergeFragments(
+    typeNode.variants.map((variant) => {
+      const variantName = nameApi.discriminatedUnionVariant(variant.name);
+      if (isNode14(variant, "enumStructVariantTypeNode")) {
+        return fragment`export function ${functionName}(kind: '${variantName}', data: ${getVariantContentType}<${looseName}, '${discriminatorName}', '${variantName}'>): ${getVariantType}<${looseName}, '${discriminatorName}', '${variantName}'>;`;
+      }
+      if (isNode14(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}'>;`;
     }),
-    (f) => addFragmentImports(f, "solanaCodecsDataStructures", [
-      "type GetDiscriminatedUnionVariantContent",
-      "type GetDiscriminatedUnionVariant"
+    (cs) => cs.length > 0 ? `${cs.join("\n")}
+` : ""
+  );
+  return fragment`// Data Enum Helpers.
+${variantSignatures}export function ${functionName}<K extends ${looseName}['${discriminatorName}'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { ${discriminatorName}: kind, fields: data } : { ${discriminatorName}: kind, ...(data ?? {}) };
+}
+
+export function ${isDiscriminatedUnionFunctionName}<K extends ${strictName}['${discriminatorName}']>(kind: K, value: ${strictName}): value is ${strictName} & { ${discriminatorName}: K } {
+  return value.${discriminatorName} === kind;
+};
+`;
+}
+
+// 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(
+    mergeFragments(
+      [
+        getTypeWithCodecFragment({ ...scope, manifest, name: node.name, node: node.type, typeDocs: node.docs }),
+        getTypeDiscriminatedUnionHelpersFragment({ ...scope, name: node.name, typeNode: node.type })
+      ],
+      (cs) => cs.join("\n\n")
+    ),
+    (f) => removeFragmentImports(f, "generatedTypes", [
+      scope.nameApi.dataType(node.name),
+      scope.nameApi.dataArgsType(node.name),
+      scope.nameApi.encoderFunction(node.name),
+      scope.nameApi.decoderFunction(node.name),
+      scope.nameApi.codecFunction(node.name)
     ])
   );
 }
 
-// src/getTypeManifestVisitor.ts
+// src/visitors/getTypeManifestVisitor.ts
 import {
-  camelCase as camelCase10,
+  camelCase as camelCase13,
   isNode as isNode15,
   isNodeFilter as isNodeFilter6,
   isScalarEnum,
-  parseDocs as parseDocs2,
   REGISTERED_TYPE_NODE_KINDS,
   REGISTERED_VALUE_NODE_KINDS,
-  resolveNestedTypeNode as resolveNestedTypeNode3,
+  resolveNestedTypeNode as resolveNestedTypeNode4,
   structFieldTypeNode,
   structTypeNode,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes5
 } from "@codama/nodes";
 import { mapFragmentContent as mapFragmentContent11, setFragmentContent as setFragmentContent2 } from "@codama/renderers-core";
 import {
   extendVisitor,
   findLastNodeFromPath,
   NodeStack,
-  pipe as pipe24,
+  pipe as pipe15,
   recordNodeStackVisitor,
   staticVisitor,
-  visit as visit5
+  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 pipe24(
+  return pipe15(
     staticVisitor(() => typeManifest(), {
       keys: [
         ...REGISTERED_TYPE_NODE_KINDS,
@@ -2062,117 +2431,81 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(account.name)
         };
         const link = customAccountData.get(account.name)?.linkNode;
-        const manifest = link ? visit5(link, self) : visit5(account.data, self);
+        const manifest = link ? visit8(link, self) : visit8(account.data, self);
         parentName = null;
         return manifest;
       },
       visitAmountType(amountType, { self }) {
-        return visit5(amountType.number, self);
+        return visit8(amountType.number, self);
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = visit5(arrayType.item, self);
+        const childManifest = visit8(arrayType.item, self);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
-        const encoderOptions = sizeManifest.encoder.content ? `, { ${sizeManifest.encoder.content} }` : "";
-        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
+        const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
         return typeManifest({
           ...childManifest,
-          decoder: pipe24(
-            childManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getArrayDecoder(${c + decoderOptions})`),
-            (f) => mergeFragmentImports(f, [sizeManifest.decoder.imports]),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getArrayDecoder"])
-          ),
-          encoder: pipe24(
-            childManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getArrayEncoder(${c + encoderOptions})`),
-            (f) => mergeFragmentImports(f, [sizeManifest.encoder.imports]),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getArrayEncoder"])
-          ),
-          looseType: mapFragmentContent11(childManifest.looseType, (c) => `Array<${c}>`),
-          strictType: mapFragmentContent11(childManifest.strictType, (c) => `Array<${c}>`)
+          decoder: fragment`${use("getArrayDecoder", "solanaCodecsDataStructures")}(${childManifest.decoder}${decoderOptions})`,
+          encoder: fragment`${use("getArrayEncoder", "solanaCodecsDataStructures")}(${childManifest.encoder}${encoderOptions})`,
+          looseType: fragment`Array<${childManifest.looseType}>`,
+          strictType: fragment`Array<${childManifest.strictType}>`
         });
       },
       visitArrayValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => visit5(v, self)),
+          node.items.map((v) => visit8(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitBooleanType(booleanType, { self }) {
-        const encoderImports = new ImportMap().add("solanaCodecsDataStructures", "getBooleanEncoder");
-        const decoderImports = new ImportMap().add("solanaCodecsDataStructures", "getBooleanDecoder");
-        let sizeEncoder = "";
-        let sizeDecoder = "";
-        const resolvedSize = resolveNestedTypeNode3(booleanType.size);
+        let sizeEncoder = fragment``;
+        let sizeDecoder = fragment``;
+        const resolvedSize = resolveNestedTypeNode4(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
-          const size = visit5(booleanType.size, self);
-          encoderImports.mergeWith(size.encoder);
-          decoderImports.mergeWith(size.decoder);
-          sizeEncoder = `{ size: ${size.encoder.content} }`;
-          sizeDecoder = `{ size: ${size.decoder.content} }`;
+          const size = visit8(booleanType.size, self);
+          sizeEncoder = fragment`{ size: ${size.encoder} }`;
+          sizeDecoder = fragment`{ size: ${size.decoder} }`;
         }
         return typeManifest({
-          decoder: pipe24(
-            fragment(`getBooleanDecoder(${sizeDecoder})`),
-            (f) => mergeFragmentImports(f, [decoderImports])
-          ),
-          encoder: pipe24(
-            fragment(`getBooleanEncoder(${sizeEncoder})`),
-            (f) => mergeFragmentImports(f, [encoderImports])
-          ),
-          looseType: fragment("boolean"),
-          strictType: fragment("boolean")
+          decoder: fragment`${use("getBooleanDecoder", "solanaCodecsDataStructures")}(${sizeDecoder})`,
+          encoder: fragment`${use("getBooleanEncoder", "solanaCodecsDataStructures")}(${sizeEncoder})`,
+          looseType: fragment`boolean`,
+          strictType: fragment`boolean`
         });
       },
       visitBooleanValue(node) {
-        return typeManifest({
-          value: fragment(JSON.stringify(node.boolean))
-        });
+        return typeManifest({ value: fragment`${JSON.stringify(node.boolean)}` });
       },
       visitBytesType() {
-        const readonlyUint8Array = pipe24(
-          fragment("ReadonlyUint8Array"),
-          (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
-        );
+        const readonlyUint8Array = use("type ReadonlyUint8Array", "solanaCodecsCore");
         return typeManifest({
-          decoder: pipe24(
-            fragment(`getBytesDecoder()`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getBytesDecoder"])
-          ),
-          encoder: pipe24(
-            fragment(`getBytesEncoder()`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getBytesEncoder"])
-          ),
+          decoder: fragment`${use("getBytesDecoder", "solanaCodecsDataStructures")}()`,
+          encoder: fragment`${use("getBytesEncoder", "solanaCodecsDataStructures")}()`,
           looseType: readonlyUint8Array,
           strictType: readonlyUint8Array
         });
       },
       visitBytesValue(node) {
         const bytes = getBytesFromBytesValueNode(node);
-        return typeManifest({
-          value: fragment(`new Uint8Array([${Array.from(bytes).join(", ")}])`)
-        });
+        return typeManifest({ value: fragment`new Uint8Array([${Array.from(bytes).join(", ")}])` });
       },
       visitConstantValue(node, { self }) {
         if (isNode15(node.type, "bytesTypeNode") && isNode15(node.value, "bytesValueNode")) {
-          return visit5(node.value, self);
+          return visit8(node.value, self);
         }
         return typeManifest({
-          value: mergeFragments(
-            [visit5(node.type, self).encoder, visit5(node.value, self).value],
-            ([encoderFunction, value]) => `${encoderFunction}.encode(${value})`
-          )
+          value: fragment`${visit8(node.type, self).encoder}.encode(${visit8(node.value, self).value})`
         });
       },
       visitDateTimeType(dateTimeType, { self }) {
-        return visit5(dateTimeType.number, self);
+        return visit8(dateTimeType.number, self);
       },
       visitDefinedType(definedType, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(definedType.name),
           strict: nameApi.dataType(definedType.name)
         };
-        const manifest = visit5(definedType.type, self);
+        const manifest = visit8(definedType.type, self);
         parentName = null;
         return manifest;
       },
@@ -2183,60 +2516,42 @@ function getTypeManifestVisitor(input) {
         const decoderFunction = nameApi.decoderFunction(node.name);
         const importFrom = getImportFrom(node);
         return typeManifest({
-          decoder: pipe24(
-            fragment(`${decoderFunction}()`),
-            (f) => addFragmentImports(f, importFrom, [decoderFunction])
-          ),
-          encoder: pipe24(
-            fragment(`${encoderFunction}()`),
-            (f) => addFragmentImports(f, importFrom, [encoderFunction])
-          ),
-          looseType: pipe24(
-            fragment(looseName),
-            (f) => addFragmentImports(f, importFrom, [`type ${looseName}`])
-          ),
-          strictType: pipe24(
-            fragment(strictName),
-            (f) => addFragmentImports(f, importFrom, [`type ${strictName}`])
-          )
+          decoder: fragment`${use(decoderFunction, importFrom)}()`,
+          encoder: fragment`${use(encoderFunction, importFrom)}()`,
+          looseType: use(`type ${looseName}`, importFrom),
+          strictType: use(`type ${strictName}`, importFrom)
         });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase10(parentName?.strict ?? ""));
+        const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase13(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         return typeManifest({
-          decoder: pipe24(
-            fragment(`['${name}', getUnitDecoder()]`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getUnitDecoder"])
-          ),
-          encoder: pipe24(
-            fragment(`['${name}', getUnitEncoder()]`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getUnitEncoder"])
-          ),
-          looseType: fragment(`{ ${kindAttribute} }`),
-          strictType: fragment(`{ ${kindAttribute} }`)
+          decoder: fragment`['${name}', ${use("getUnitDecoder", "solanaCodecsDataStructures")}()]`,
+          encoder: fragment`['${name}', ${use("getUnitEncoder", "solanaCodecsDataStructures")}()]`,
+          looseType: fragment`{ ${kindAttribute} }`,
+          strictType: fragment`{ ${kindAttribute} }`
         });
       },
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase10(currentParentName?.strict ?? "")
+          camelCase13(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         parentName = null;
-        const structManifest = visit5(enumStructVariantType.struct, self);
+        const structManifest = visit8(enumStructVariantType.struct, self);
         parentName = currentParentName;
         return typeManifest({
           ...structManifest,
-          decoder: pipe24(structManifest.decoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
-          encoder: pipe24(structManifest.encoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
-          looseType: pipe24(
+          decoder: fragment`['${name}', ${structManifest.decoder}]`,
+          encoder: fragment`['${name}', ${structManifest.encoder}]`,
+          looseType: pipe15(
             structManifest.looseType,
             (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           ),
-          strictType: pipe24(
+          strictType: pipe15(
             structManifest.strictType,
             (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           )
@@ -2245,7 +2560,7 @@ function getTypeManifestVisitor(input) {
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase10(currentParentName?.strict ?? "")
+          camelCase13(currentParentName?.strict ?? "")
         );
         const name = nameApi.discriminatedUnionVariant(enumTupleVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
@@ -2256,17 +2571,17 @@ function getTypeManifestVisitor(input) {
           })
         ]);
         parentName = null;
-        const structManifest = visit5(struct, self);
+        const structManifest = visit8(struct, self);
         parentName = currentParentName;
         return typeManifest({
           ...structManifest,
-          decoder: pipe24(structManifest.decoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
-          encoder: pipe24(structManifest.encoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
-          looseType: pipe24(
+          decoder: fragment`['${name}', ${structManifest.decoder}]`,
+          encoder: fragment`['${name}', ${structManifest.encoder}]`,
+          looseType: pipe15(
             structManifest.looseType,
             (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           ),
-          strictType: pipe24(
+          strictType: pipe15(
             structManifest.strictType,
             (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
           )
@@ -2274,27 +2589,29 @@ function getTypeManifestVisitor(input) {
       },
       visitEnumType(enumType, { self }) {
         const currentParentName = parentName;
-        const encoderImports = new ImportMap();
-        const decoderImports = new ImportMap();
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = resolveNestedTypeNode3(enumType.size);
+        const enumSize = resolveNestedTypeNode4(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
-          const sizeManifest = visit5(enumType.size, self);
-          encoderImports.mergeWith(sizeManifest.encoder);
-          decoderImports.mergeWith(sizeManifest.decoder);
-          encoderOptions.push(`size: ${sizeManifest.encoder.content}`);
-          decoderOptions.push(`size: ${sizeManifest.decoder.content}`);
+          const sizeManifest = visit8(enumType.size, self);
+          encoderOptions.push(fragment`size: ${sizeManifest.encoder}`);
+          decoderOptions.push(fragment`size: ${sizeManifest.decoder}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
-          camelCase10(currentParentName?.strict ?? "")
+          camelCase13(currentParentName?.strict ?? "")
         );
         if (!isScalarEnum(enumType) && discriminator !== "__kind") {
-          encoderOptions.push(`discriminator: '${discriminator}'`);
-          decoderOptions.push(`discriminator: '${discriminator}'`);
+          encoderOptions.push(fragment`discriminator: '${discriminator}'`);
+          decoderOptions.push(fragment`discriminator: '${discriminator}'`);
         }
-        const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
-        const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
+        const encoderOptionsFragment = mergeFragments(
+          encoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        const decoderOptionsFragment = mergeFragments(
+          decoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
         if (isScalarEnum(enumType)) {
           if (currentParentName === null) {
             throw new Error(
@@ -2303,23 +2620,15 @@ function getTypeManifestVisitor(input) {
           }
           const variantNames = enumType.variants.map(({ name }) => nameApi.enumVariant(name));
           return typeManifest({
-            decoder: pipe24(
-              fragment(`getEnumDecoder(${currentParentName.strict + decoderOptionsAsString})`),
-              (f) => mergeFragmentImports(f, [decoderImports]),
-              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getEnumDecoder"])
-            ),
-            encoder: pipe24(
-              fragment(`getEnumEncoder(${currentParentName.strict + encoderOptionsAsString})`),
-              (f) => mergeFragmentImports(f, [encoderImports]),
-              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getEnumEncoder"])
-            ),
+            decoder: fragment`${use("getEnumDecoder", "solanaCodecsDataStructures")}(${currentParentName.strict}${decoderOptionsFragment})`,
+            encoder: fragment`${use("getEnumEncoder", "solanaCodecsDataStructures")}(${currentParentName.strict}${encoderOptionsFragment})`,
             isEnum: true,
-            looseType: fragment(`{ ${variantNames.join(", ")} }`),
-            strictType: fragment(`{ ${variantNames.join(", ")} }`)
+            looseType: fragment`{ ${variantNames.join(", ")} }`,
+            strictType: fragment`{ ${variantNames.join(", ")} }`
           });
         }
         const mergedManifest = mergeTypeManifests(
-          enumType.variants.map((variant) => visit5(variant, self)),
+          enumType.variants.map((variant) => visit8(variant, self)),
           {
             mergeCodecs: (renders) => renders.join(", "),
             mergeTypes: (renders) => renders.join(" | ")
@@ -2327,24 +2636,8 @@ function getTypeManifestVisitor(input) {
         );
         return typeManifest({
           ...mergedManifest,
-          decoder: pipe24(
-            mergedManifest.decoder,
-            (f) => mapFragmentContent11(
-              f,
-              (c) => `getDiscriminatedUnionDecoder([${c}]${decoderOptionsAsString})`
-            ),
-            (f) => mergeFragmentImports(f, [decoderImports]),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getDiscriminatedUnionDecoder"])
-          ),
-          encoder: pipe24(
-            mergedManifest.encoder,
-            (f) => mapFragmentContent11(
-              f,
-              (c) => `getDiscriminatedUnionEncoder([${c}]${encoderOptionsAsString})`
-            ),
-            (f) => mergeFragmentImports(f, [encoderImports]),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getDiscriminatedUnionEncoder"])
-          )
+          decoder: fragment`${use("getDiscriminatedUnionDecoder", "solanaCodecsDataStructures")}([${mergedManifest.decoder}]${decoderOptionsFragment})`,
+          encoder: fragment`${use("getDiscriminatedUnionEncoder", "solanaCodecsDataStructures")}([${mergedManifest.encoder}]${encoderOptionsFragment})`
         });
       },
       visitEnumValue(node, { self }) {
@@ -2358,7 +2651,7 @@ function getTypeManifestVisitor(input) {
           const variantName2 = nameApi.enumVariant(node.variant);
           return typeManifest({
             ...manifest,
-            value: pipe24(
+            value: pipe15(
               manifest.value,
               (f) => setFragmentContent2(f, `${enumName}.${variantName2}`),
               (f) => addFragmentImports(f, importFrom, [enumName])
@@ -2369,7 +2662,7 @@ function getTypeManifestVisitor(input) {
         if (!node.value) {
           return typeManifest({
             ...manifest,
-            value: pipe24(
+            value: pipe15(
               manifest.value,
               (f) => setFragmentContent2(f, `${enumFunction}('${variantName}')`),
               (f) => addFragmentImports(f, importFrom, [enumFunction])
@@ -2378,85 +2671,53 @@ function getTypeManifestVisitor(input) {
         }
         return typeManifest({
           ...manifest,
-          value: pipe24(
-            visit5(node.value, self).value,
+          value: pipe15(
+            visit8(node.value, self).value,
             (f) => mapFragmentContent11(f, (c) => `${enumFunction}('${variantName}', ${c})`),
             (f) => addFragmentImports(f, importFrom, [enumFunction])
           )
         });
       },
       visitFixedSizeType(node, { self }) {
-        const manifest = visit5(node.type, self);
+        const manifest = visit8(node.type, self);
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            manifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `fixDecoderSize(${c}, ${node.size})`),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["fixDecoderSize"])
-          ),
-          encoder: pipe24(
-            manifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `fixEncoderSize(${c}, ${node.size})`),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["fixEncoderSize"])
-          )
+          decoder: fragment`${use("fixDecoderSize", "solanaCodecsCore")}(${manifest.decoder}, ${node.size})`,
+          encoder: fragment`${use("fixEncoderSize", "solanaCodecsCore")}(${manifest.encoder}, ${node.size})`
         });
       },
       visitHiddenPrefixType(node, { self }) {
-        const manifest = visit5(node.type, self);
-        const prefixes = node.prefix.map((c) => visit5(c, self).value);
-        const prefixEncoders = pipe24(
-          mergeFragments(prefixes, (contents) => contents.map((c) => `getConstantEncoder(${c})`).join(", ")),
+        const manifest = visit8(node.type, self);
+        const prefixes = node.prefix.map((c) => visit8(c, self).value);
+        const prefixEncoders = pipe15(
+          mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantEncoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
         );
-        const prefixDecoders = pipe24(
-          mergeFragments(prefixes, (contents) => contents.map((c) => `getConstantDecoder(${c})`).join(", ")),
+        const prefixDecoders = pipe15(
+          mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
         );
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            mergeFragments(
-              [manifest.decoder, prefixDecoders],
-              ([child, prefixes2]) => `getHiddenPrefixDecoder(${child}, [${prefixes2}])`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenPrefixDecoder"])
-          ),
-          encoder: pipe24(
-            mergeFragments(
-              [manifest.encoder, prefixEncoders],
-              ([child, prefixes2]) => `getHiddenPrefixEncoder(${child}, [${prefixes2}])`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenPrefixEncoder"])
-          )
+          decoder: fragment`${use("getHiddenPrefixDecoder", "solanaCodecsDataStructures")}(${manifest.decoder}, [${prefixDecoders}])`,
+          encoder: fragment`${use("getHiddenPrefixEncoder", "solanaCodecsDataStructures")}(${manifest.encoder}, [${prefixEncoders}])`
         });
       },
       visitHiddenSuffixType(node, { self }) {
-        const manifest = visit5(node.type, self);
-        const suffixes = node.suffix.map((c) => visit5(c, self).value);
-        const suffixEncoders = pipe24(
-          mergeFragments(suffixes, (contents) => contents.map((c) => `getConstantEncoder(${c})`).join(", ")),
+        const manifest = visit8(node.type, self);
+        const suffixes = node.suffix.map((c) => visit8(c, self).value);
+        const suffixEncoders = pipe15(
+          mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantEncoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
         );
-        const suffixDecoders = pipe24(
-          mergeFragments(suffixes, (contents) => contents.map((c) => `getConstantDecoder(${c})`).join(", ")),
+        const suffixDecoders = pipe15(
+          mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
           (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
         );
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            mergeFragments(
-              [manifest.decoder, suffixDecoders],
-              ([child, suffixes2]) => `getHiddenSuffixDecoder(${child}, [${suffixes2}])`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenSuffixDecoder"])
-          ),
-          encoder: pipe24(
-            mergeFragments(
-              [manifest.encoder, suffixEncoders],
-              ([child, suffixes2]) => `getHiddenSuffixEncoder(${child}, [${suffixes2}])`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenSuffixEncoder"])
-          )
+          decoder: fragment`${use("getHiddenSuffixDecoder", "solanaCodecsDataStructures")}(${manifest.decoder}, [${suffixDecoders}])`,
+          encoder: fragment`${use("getHiddenSuffixEncoder", "solanaCodecsDataStructures")}(${manifest.encoder}, [${suffixEncoders}])`
         });
       },
       visitInstruction(instruction, { self }) {
@@ -2466,142 +2727,95 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = structTypeNodeFromInstructionArgumentNodes4(instruction.arguments);
-        const manifest = link ? visit5(link, self) : visit5(struct, self);
+        const struct = structTypeNodeFromInstructionArgumentNodes5(instruction.arguments);
+        const manifest = link ? visit8(link, self) : visit8(struct, self);
         parentName = null;
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeTypeManifests([visit5(node.key, self), visit5(node.value, self)], {
+        return mergeTypeManifests([visit8(node.key, self), visit8(node.value, self)], {
           mergeValues: (renders) => `[${renders.join(", ")}]`
         });
       },
       visitMapType(mapType, { self }) {
-        const key = visit5(mapType.key, self);
-        const value = visit5(mapType.value, self);
+        const key = visit8(mapType.key, self);
+        const value = visit8(mapType.value, self);
         const mergedManifest = mergeTypeManifests([key, value], {
           mergeCodecs: ([k, v]) => `${k}, ${v}`,
           mergeTypes: ([k, v]) => `Map<${k}, ${v}>`
         });
         const sizeManifest = getArrayLikeSizeOption(mapType.count, self);
-        const encoderOptions = sizeManifest.encoder.content ? `, { ${sizeManifest.encoder.content} }` : "";
-        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
+        const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
         return typeManifest({
           ...mergedManifest,
-          decoder: pipe24(
-            mergedManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getMapDecoder(${c}${decoderOptions})`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getMapDecoder"])
-          ),
-          encoder: pipe24(
-            mergedManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getMapEncoder(${c}${encoderOptions})`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getMapEncoder"])
-          )
+          decoder: fragment`${use("getMapDecoder", "solanaCodecsDataStructures")}(${mergedManifest.decoder}${decoderOptions})`,
+          encoder: fragment`${use("getMapEncoder", "solanaCodecsDataStructures")}(${mergedManifest.encoder}${encoderOptions})`
         });
       },
       visitMapValue(node, { self }) {
-        const entryFragments = node.entries.map((entry) => visit5(entry, self));
+        const entryFragments = node.entries.map((entry) => visit8(entry, self));
         return mergeTypeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
       },
       visitNoneValue() {
         return typeManifest({
-          value: pipe24(fragment("none()"), (f) => addFragmentImports(f, "solanaOptions", ["none"]))
+          value: fragment`${use("none", "solanaOptions")}()`
         });
       },
       visitNumberType(numberType) {
-        const encoderFunction = nameApi.encoderFunction(numberType.format);
-        const decoderFunction = nameApi.decoderFunction(numberType.format);
+        const encoderFunction = use(nameApi.encoderFunction(numberType.format), "solanaCodecsNumbers");
+        const decoderFunction = use(nameApi.decoderFunction(numberType.format), "solanaCodecsNumbers");
         const isBigNumber = ["u64", "u128", "i64", "i128"].includes(numberType.format);
-        const encoderImports = new ImportMap().add("solanaCodecsNumbers", encoderFunction);
-        const decoderImports = new ImportMap().add("solanaCodecsNumbers", decoderFunction);
-        let endianness = "";
-        if (numberType.endian === "be") {
-          encoderImports.add("solanaCodecsNumbers", "Endian");
-          decoderImports.add("solanaCodecsNumbers", "Endian");
-          endianness = "{ endian: Endian.Big }";
-        }
+        const endianness = numberType.endian === "be" ? fragment`{ endian: ${use("Endian", "solanaCodecsNumbers")}.Big }` : "";
         return typeManifest({
-          decoder: pipe24(
-            fragment(`${decoderFunction}(${endianness})`),
-            (f) => mergeFragmentImports(f, [decoderImports])
-          ),
-          encoder: pipe24(
-            fragment(`${encoderFunction}(${endianness})`),
-            (f) => mergeFragmentImports(f, [encoderImports])
-          ),
-          looseType: fragment(isBigNumber ? "number | bigint" : "number"),
-          strictType: fragment(isBigNumber ? "bigint" : "number")
+          decoder: fragment`${decoderFunction}(${endianness})`,
+          encoder: fragment`${encoderFunction}(${endianness})`,
+          looseType: fragment`${isBigNumber ? "number | bigint" : "number"}`,
+          strictType: fragment`${isBigNumber ? "bigint" : "number"}`
         });
       },
       visitNumberValue(node) {
-        return typeManifest({
-          value: fragment(JSON.stringify(node.number))
-        });
+        return typeManifest({ value: fragment`${JSON.stringify(node.number)}` });
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visit5(optionType.item, self);
+        const childManifest = visit8(optionType.item, self);
         const encoderOptions = [];
         const decoderOptions = [];
-        const encoderImports = new ImportMap();
-        const decoderImports = new ImportMap();
-        const optionPrefix = resolveNestedTypeNode3(optionType.prefix);
+        const optionPrefix = resolveNestedTypeNode4(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = visit5(optionType.prefix, self);
-          encoderImports.mergeWith(prefixManifest.encoder);
-          decoderImports.mergeWith(prefixManifest.decoder);
-          encoderOptions.push(`prefix: ${prefixManifest.encoder.content}`);
-          decoderOptions.push(`prefix: ${prefixManifest.decoder.content}`);
+          const prefixManifest = visit8(optionType.prefix, self);
+          encoderOptions.push(fragment`prefix: ${prefixManifest.encoder}`);
+          decoderOptions.push(fragment`prefix: ${prefixManifest.decoder}`);
         }
         if (optionType.fixed) {
-          encoderOptions.push(`noneValue: "zeroes"`);
-          decoderOptions.push(`noneValue: "zeroes"`);
+          encoderOptions.push(fragment`noneValue: "zeroes"`);
+          decoderOptions.push(fragment`noneValue: "zeroes"`);
         }
-        const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
-        const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
+        const encoderOptionsFragment = mergeFragments(
+          encoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        const decoderOptionsFragment = mergeFragments(
+          decoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
         return typeManifest({
           ...childManifest,
-          decoder: pipe24(
-            childManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"]),
-            (f) => mergeFragmentImports(f, [decoderImports])
-          ),
-          encoder: pipe24(
-            childManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"]),
-            (f) => mergeFragmentImports(f, [encoderImports])
-          ),
-          looseType: pipe24(
-            childManifest.looseType,
-            (f) => mapFragmentContent11(f, (c) => `OptionOrNullable<${c}>`),
-            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
-          ),
-          strictType: pipe24(
-            childManifest.strictType,
-            (f) => mapFragmentContent11(f, (c) => `Option<${c}>`),
-            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
-          )
+          decoder: fragment`${use("getOptionDecoder", "solanaOptions")}(${childManifest.decoder}${decoderOptionsFragment})`,
+          encoder: fragment`${use("getOptionEncoder", "solanaOptions")}(${childManifest.encoder}${encoderOptionsFragment})`,
+          looseType: fragment`${use("type OptionOrNullable", "solanaOptions")}<${childManifest.looseType}>`,
+          strictType: fragment`${use("type Option", "solanaOptions")}<${childManifest.strictType}>`
         });
       },
       visitPostOffsetType(node, { self }) {
-        const manifest = visit5(node.type, self);
+        const manifest = visit8(node.type, self);
         if (node.strategy === "padded") {
           return typeManifest({
             ...manifest,
-            decoder: pipe24(
-              manifest.decoder,
-              (f) => mapFragmentContent11(f, (c) => `padRightDecoder(${c}, ${node.offset})`),
-              (f) => addFragmentImports(f, "solanaCodecsCore", ["padRightDecoder"])
-            ),
-            encoder: pipe24(
-              manifest.encoder,
-              (f) => mapFragmentContent11(f, (c) => `padRightEncoder(${c}, ${node.offset})`),
-              (f) => addFragmentImports(f, "solanaCodecsCore", ["padRightEncoder"])
-            )
+            decoder: fragment`${use("padRightDecoder", "solanaCodecsCore")}(${manifest.decoder}, ${node.offset})`,
+            encoder: fragment`${use("padRightEncoder", "solanaCodecsCore")}(${manifest.encoder}, ${node.offset})`
           });
         }
         const fn = (() => {
@@ -2617,33 +2831,17 @@ function getTypeManifestVisitor(input) {
         })();
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            manifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `offsetDecoder(${c}, { postOffset: ${fn} })`),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetDecoder"])
-          ),
-          encoder: pipe24(
-            manifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `offsetEncoder(${c}, { postOffset: ${fn} })`),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetEncoder"])
-          )
+          decoder: fragment`${use("offsetDecoder", "solanaCodecsCore")}(${manifest.decoder}, { postOffset: ${fn} })`,
+          encoder: fragment`${use("offsetEncoder", "solanaCodecsCore")}(${manifest.encoder}, { postOffset: ${fn} })`
         });
       },
       visitPreOffsetType(node, { self }) {
-        const manifest = visit5(node.type, self);
+        const manifest = visit8(node.type, self);
         if (node.strategy === "padded") {
           return typeManifest({
             ...manifest,
-            decoder: pipe24(
-              manifest.decoder,
-              (f) => mapFragmentContent11(f, (c) => `padLeftDecoder(${c}, ${node.offset})`),
-              (f) => addFragmentImports(f, "solanaCodecsCore", ["padLeftDecoder"])
-            ),
-            encoder: pipe24(
-              manifest.encoder,
-              (f) => mapFragmentContent11(f, (c) => `padLeftEncoder(${c}, ${node.offset})`),
-              (f) => addFragmentImports(f, "solanaCodecsCore", ["padLeftEncoder"])
-            )
+            decoder: fragment`${use("padLeftDecoder", "solanaCodecsCore")}(${manifest.decoder}, ${node.offset})`,
+            encoder: fragment`${use("padLeftEncoder", "solanaCodecsCore")}(${manifest.encoder}, ${node.offset})`
           });
         }
         const fn = (() => {
@@ -2657,174 +2855,88 @@ function getTypeManifestVisitor(input) {
         })();
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            manifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `offsetDecoder(${c}, { preOffset: ${fn} })`),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetDecoder"])
-          ),
-          encoder: pipe24(
-            manifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `offsetEncoder(${c}, { preOffset: ${fn} })`),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetEncoder"])
-          )
+          decoder: fragment`${use("offsetDecoder", "solanaCodecsCore")}(${manifest.decoder}, { preOffset: ${fn} })`,
+          encoder: fragment`${use("offsetEncoder", "solanaCodecsCore")}(${manifest.encoder}, { preOffset: ${fn} })`
         });
       },
       visitPublicKeyType() {
-        const addressFragment = pipe24(
-          fragment("Address"),
-          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-        );
         return typeManifest({
-          decoder: pipe24(
-            fragment("getAddressDecoder()"),
-            (f) => addFragmentImports(f, "solanaAddresses", ["getAddressDecoder"])
-          ),
-          encoder: pipe24(
-            fragment("getAddressEncoder()"),
-            (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
-          ),
-          looseType: addressFragment,
-          strictType: addressFragment
+          decoder: fragment`${use("getAddressDecoder", "solanaAddresses")}()`,
+          encoder: fragment`${use("getAddressEncoder", "solanaAddresses")}()`,
+          looseType: use("type Address", "solanaAddresses"),
+          strictType: use("type Address", "solanaAddresses")
         });
       },
       visitPublicKeyValue(node) {
         return typeManifest({
-          value: pipe24(
-            fragment(`address("${node.publicKey}")`),
-            (f) => addFragmentImports(f, "solanaAddresses", ["address"])
-          )
+          value: fragment`${use("address", "solanaAddresses")}("${node.publicKey}")`
         });
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = visit5(node.item, self);
+        const childManifest = visit8(node.item, self);
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
         const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
         const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
         return typeManifest({
           ...childManifest,
-          decoder: pipe24(
-            childManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"])
-          ),
-          encoder: pipe24(
-            childManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"])
-          ),
-          looseType: pipe24(
-            childManifest.looseType,
-            (f) => mapFragmentContent11(f, (c) => `OptionOrNullable<${c}>`),
-            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
-          ),
-          strictType: pipe24(
-            childManifest.strictType,
-            (f) => mapFragmentContent11(f, (c) => `Option<${c}>`),
-            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
-          )
+          decoder: fragment`${use("getOptionDecoder", "solanaOptions")}(${childManifest.decoder}${decoderOptionsAsString})`,
+          encoder: fragment`${use("getOptionEncoder", "solanaOptions")}(${childManifest.encoder}${encoderOptionsAsString})`,
+          looseType: fragment`${use("type OptionOrNullable", "solanaOptions")}<${childManifest.looseType}>`,
+          strictType: fragment`${use("type Option", "solanaOptions")}<${childManifest.strictType}>`
         });
       },
       visitSentinelType(node, { self }) {
-        const manifest = visit5(node.type, self);
-        const sentinel = visit5(node.sentinel, self).value;
+        const manifest = visit8(node.type, self);
+        const sentinel = visit8(node.sentinel, self).value;
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            mergeFragments(
-              [manifest.decoder, sentinel],
-              ([child, sentinel2]) => `addDecoderSentinel(${child}, ${sentinel2})`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["addDecoderSentinel"])
-          ),
-          encoder: pipe24(
-            mergeFragments(
-              [manifest.encoder, sentinel],
-              ([child, sentinel2]) => `addEncoderSentinel(${child}, ${sentinel2})`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["addEncoderSentinel"])
-          )
+          decoder: fragment`${use("addDecoderSentinel", "solanaCodecsCore")}(${manifest.decoder}, ${sentinel})`,
+          encoder: fragment`${use("addEncoderSentinel", "solanaCodecsCore")}(${manifest.encoder}, ${sentinel})`
         });
       },
       visitSetType(setType, { self }) {
-        const childManifest = visit5(setType.item, self);
+        const childManifest = visit8(setType.item, self);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
-        const encoderOptions = sizeManifest.encoder.content ? `, { ${sizeManifest.encoder.content} }` : "";
-        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
+        const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
         return typeManifest({
           ...childManifest,
-          decoder: pipe24(
-            childManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getSetDecoder(${c + decoderOptions})`),
-            (f) => mergeFragmentImports(f, [sizeManifest.decoder.imports]),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getSetDecoder"])
-          ),
-          encoder: pipe24(
-            childManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getSetEncoder(${c + encoderOptions})`),
-            (f) => mergeFragmentImports(f, [sizeManifest.encoder.imports]),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getSetEncoder"])
-          ),
-          looseType: pipe24(childManifest.looseType, (f) => mapFragmentContent11(f, (c) => `Set<${c}>`)),
-          strictType: pipe24(childManifest.strictType, (f) => mapFragmentContent11(f, (c) => `Set<${c}>`))
+          decoder: fragment`${use("getSetDecoder", "solanaCodecsDataStructures")}(${childManifest.decoder}${decoderOptions})`,
+          encoder: fragment`${use("getSetEncoder", "solanaCodecsDataStructures")}(${childManifest.encoder}${encoderOptions})`,
+          looseType: fragment`Set<${childManifest.looseType}>`,
+          strictType: fragment`Set<${childManifest.strictType}>`
         });
       },
       visitSetValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => visit5(v, self)),
+          node.items.map((v) => visit8(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
       },
       visitSizePrefixType(node, { self }) {
-        const manifest = visit5(node.type, self);
-        const prefix = visit5(node.prefix, self);
+        const manifest = visit8(node.type, self);
+        const prefix = visit8(node.prefix, self);
         return typeManifest({
           ...manifest,
-          decoder: pipe24(
-            mergeFragments(
-              [manifest.decoder, prefix.decoder],
-              ([decoder, prefix2]) => `addDecoderSizePrefix(${decoder}, ${prefix2})`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["addDecoderSizePrefix"])
-          ),
-          encoder: pipe24(
-            mergeFragments(
-              [manifest.encoder, prefix.encoder],
-              ([encoder, prefix2]) => `addEncoderSizePrefix(${encoder}, ${prefix2})`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["addEncoderSizePrefix"])
-          )
+          decoder: fragment`${use("addDecoderSizePrefix", "solanaCodecsCore")}(${manifest.decoder}, ${prefix.decoder})`,
+          encoder: fragment`${use("addEncoderSizePrefix", "solanaCodecsCore")}(${manifest.encoder}, ${prefix.encoder})`
         });
       },
       visitSolAmountType({ number }, { self }) {
-        const numberManifest = visit5(number, self);
-        const lamportFragment = pipe24(
-          fragment("Lamports"),
-          (f) => addFragmentImports(f, "solanaRpcTypes", ["type Lamports"])
-        );
+        const numberManifest = visit8(number, self);
         return typeManifest({
           ...numberManifest,
-          decoder: pipe24(
-            numberManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getLamportsDecoder(${c})`),
-            (f) => addFragmentImports(f, "solanaRpcTypes", ["getLamportsDecoder"])
-          ),
-          encoder: pipe24(
-            numberManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getLamportsEncoder(${c})`),
-            (f) => addFragmentImports(f, "solanaRpcTypes", ["getLamportsEncoder"])
-          ),
-          looseType: lamportFragment,
-          strictType: lamportFragment
+          decoder: fragment`${use("getLamportsDecoder", "solanaRpcTypes")}(${numberManifest.decoder})`,
+          encoder: fragment`${use("getLamportsEncoder", "solanaRpcTypes")}(${numberManifest.encoder})`,
+          looseType: use("type Lamports", "solanaRpcTypes"),
+          strictType: use("type Lamports", "solanaRpcTypes")
         });
       },
       visitSomeValue(node, { self }) {
+        const innerValue = visit8(node.value, self).value;
         return typeManifest({
-          value: pipe24(
-            visit5(node.value, self).value,
-            (f) => mapFragmentContent11(f, (c) => `some(${c})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["some"])
-          )
+          value: fragment`${use("some", "solanaOptions")}(${innerValue})`
         });
       },
       visitStringType(stringType) {
@@ -2843,48 +2955,28 @@ function getTypeManifestVisitor(input) {
           }
         })();
         return typeManifest({
-          decoder: pipe24(
-            fragment(`${decoder}()`),
-            (f) => addFragmentImports(f, "solanaCodecsStrings", [decoder])
-          ),
-          encoder: pipe24(
-            fragment(`${encoder}()`),
-            (f) => addFragmentImports(f, "solanaCodecsStrings", [encoder])
-          ),
-          looseType: fragment("string"),
-          strictType: fragment("string")
+          decoder: fragment`${use(decoder, "solanaCodecsStrings")}()`,
+          encoder: fragment`${use(encoder, "solanaCodecsStrings")}()`,
+          looseType: fragment`string`,
+          strictType: fragment`string`
         });
       },
       visitStringValue(node) {
         return typeManifest({
-          value: fragment(JSON.stringify(node.string))
+          value: fragment`${JSON.stringify(node.string)}`
         });
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = camelCase10(structFieldType.name);
-        const originalChildManifest = visit5(structFieldType.type, self);
-        const structFieldDocs = parseDocs2(structFieldType.docs);
-        const docblock = structFieldDocs.length > 0 ? `
-${jsDocblock(structFieldDocs)}` : "";
-        const originalLooseType = originalChildManifest.looseType.content;
+        const name = camelCase13(structFieldType.name);
+        const originalChildManifest = visit8(structFieldType.type, self);
+        let docs = getDocblockFragment(structFieldType.docs ?? [], true);
+        docs = docs ? fragment`\n${docs}` : docs;
         const childManifest = typeManifest({
           ...originalChildManifest,
-          decoder: pipe24(
-            originalChildManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)
-          ),
-          encoder: pipe24(
-            originalChildManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)
-          ),
-          looseType: pipe24(
-            originalChildManifest.looseType,
-            (f) => mapFragmentContent11(f, (c) => `${docblock}${name}: ${c}; `)
-          ),
-          strictType: pipe24(
-            originalChildManifest.strictType,
-            (f) => mapFragmentContent11(f, (c) => `${docblock}${name}: ${c}; `)
-          )
+          decoder: fragment`['${name}', ${originalChildManifest.decoder}]`,
+          encoder: fragment`['${name}', ${originalChildManifest.encoder}]`,
+          looseType: fragment`${docs}${name}: ${originalChildManifest.looseType}; `,
+          strictType: fragment`${docs}${name}: ${originalChildManifest.strictType}; `
         });
         if (!structFieldType.defaultValue) {
           return childManifest;
@@ -2892,30 +2984,22 @@ ${jsDocblock(structFieldDocs)}` : "";
         if (structFieldType.defaultValueStrategy !== "omitted") {
           return typeManifest({
             ...childManifest,
-            looseType: pipe24(
-              childManifest.looseType,
-              (f) => setFragmentContent2(f, `${docblock}${name}?: ${originalLooseType}; `)
-            )
+            looseType: fragment`${docs}${name}?: ${originalChildManifest.looseType}; `
           });
         }
-        return typeManifest({
-          ...childManifest,
-          looseType: fragment("")
-        });
+        return typeManifest({ ...childManifest, looseType: fragment`` });
       },
       visitStructFieldValue(node, { self }) {
+        const innerValue = visit8(node.value, self).value;
         return typeManifest({
-          value: pipe24(
-            visit5(node.value, self).value,
-            (f) => mapFragmentContent11(f, (c) => `${node.name}: ${c}`)
-          )
+          value: fragment`${node.name}: ${innerValue}`
         });
       },
       visitStructType(structType, { self }) {
         const optionalFields = structType.fields.filter((f) => !!f.defaultValue);
-        const mergedManifest = pipe24(
+        const mergedManifest = pipe15(
           mergeTypeManifests(
-            structType.fields.map((field) => visit5(field, self)),
+            structType.fields.map((field) => visit8(field, self)),
             {
               mergeCodecs: (renders) => `([${renders.join(", ")}])`,
               mergeTypes: (renders) => `{ ${renders.join("")} }`
@@ -2923,16 +3007,8 @@ ${jsDocblock(structFieldDocs)}` : "";
           ),
           (manifest) => typeManifest({
             ...manifest,
-            decoder: pipe24(
-              manifest.decoder,
-              (f) => mapFragmentContent11(f, (c) => `getStructDecoder${c}`),
-              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getStructDecoder"])
-            ),
-            encoder: pipe24(
-              manifest.encoder,
-              (f) => mapFragmentContent11(f, (c) => `getStructEncoder${c}`),
-              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getStructEncoder"])
-            )
+            decoder: fragment`${use("getStructDecoder", "solanaCodecsDataStructures")}${manifest.decoder}`,
+            encoder: fragment`${use("getStructEncoder", "solanaCodecsDataStructures")}${manifest.encoder}`
           })
         );
         if (optionalFields.length === 0) {
@@ -2944,105 +3020,74 @@ ${jsDocblock(structFieldDocs)}` : "";
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
         const fieldDiscriminators = discriminators.filter(isNodeFilter6("fieldDiscriminatorNode"));
-        const encoderImports = new ImportMap();
-        const defaultValues = optionalFields.map((f) => {
-          const key = camelCase10(f.name);
-          if (fieldDiscriminators.some((d) => d.name === f.name)) {
-            const constantName = nameApi.constant(camelCase10(`${discriminatorPrefix}_${f.name}`));
-            return f.defaultValueStrategy === "omitted" ? `${key}: ${constantName}` : `${key}: value.${key} ?? ${constantName}`;
-          }
-          const defaultValue = f.defaultValue;
-          const { content: renderedValue, imports } = visit5(defaultValue, self).value;
-          encoderImports.mergeWith(imports);
-          return f.defaultValueStrategy === "omitted" ? `${key}: ${renderedValue}` : `${key}: value.${key} ?? ${renderedValue}`;
-        }).join(", ");
+        const defaultValues = mergeFragments(
+          optionalFields.map((f) => {
+            const key = camelCase13(f.name);
+            if (fieldDiscriminators.some((d) => d.name === f.name)) {
+              const constantName = nameApi.constant(camelCase13(`${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;
+            return f.defaultValueStrategy === "omitted" ? fragment`${key}: ${value}` : fragment`${key}: value.${key} ?? ${value}`;
+          }),
+          (cs) => cs.join(", ")
+        );
         return typeManifest({
           ...mergedManifest,
-          encoder: pipe24(
-            mergedManifest.encoder,
-            (f) => mapFragmentContent11(
-              f,
-              (c) => `transformEncoder(${c}, (value) => ({ ...value, ${defaultValues} }))`
-            ),
-            (f) => addFragmentImports(f, "solanaCodecsCore", ["transformEncoder"]),
-            (f) => mergeFragmentImports(f, [encoderImports])
-          )
+          encoder: fragment`${use("transformEncoder", "solanaCodecsCore")}(${mergedManifest.encoder}, (value) => ({ ...value, ${defaultValues} }))`
         });
       },
       visitStructValue(node, { self }) {
         return mergeTypeManifests(
-          node.fields.map((field) => visit5(field, self)),
+          node.fields.map((field) => visit8(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visit5(item, self));
+        const items = tupleType.items.map((item) => visit8(item, self));
         const mergedManifest = mergeTypeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
         });
         return typeManifest({
           ...mergedManifest,
-          decoder: pipe24(
-            mergedManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getTupleDecoder(${c})`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getTupleDecoder"])
-          ),
-          encoder: pipe24(
-            mergedManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getTupleEncoder(${c})`),
-            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getTupleEncoder"])
-          )
+          decoder: fragment`${use("getTupleDecoder", "solanaCodecsDataStructures")}(${mergedManifest.decoder})`,
+          encoder: fragment`${use("getTupleEncoder", "solanaCodecsDataStructures")}(${mergedManifest.encoder})`
         });
       },
       visitTupleValue(node, { self }) {
         return mergeTypeManifests(
-          node.items.map((v) => visit5(v, self)),
+          node.items.map((v) => visit8(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = visit5(node.item, self);
-        const encoderOptions = ["prefix: null"];
-        const decoderOptions = ["prefix: null"];
-        const encoderImports = new ImportMap();
-        const decoderImports = new ImportMap();
+        const childManifest = visit8(node.item, self);
+        const encoderOptions = [fragment`prefix: null`];
+        const decoderOptions = [fragment`prefix: null`];
         if (node.zeroValue) {
-          const zeroValueManifest = visit5(node.zeroValue, self);
-          encoderImports.mergeWith(zeroValueManifest.value);
-          decoderImports.mergeWith(zeroValueManifest.value);
-          encoderOptions.push(`noneValue: ${zeroValueManifest.value.content}`);
-          decoderOptions.push(`noneValue: ${zeroValueManifest.value.content}`);
+          const zeroValueManifest = visit8(node.zeroValue, self);
+          encoderOptions.push(fragment`noneValue: ${zeroValueManifest.value}`);
+          decoderOptions.push(fragment`noneValue: ${zeroValueManifest.value}`);
         } else {
-          encoderOptions.push(`noneValue: "zeroes"`);
-          decoderOptions.push(`noneValue: "zeroes"`);
+          encoderOptions.push(fragment`noneValue: "zeroes"`);
+          decoderOptions.push(fragment`noneValue: "zeroes"`);
         }
-        const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
-        const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
+        const encoderOptionsFragment = mergeFragments(
+          encoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        const decoderOptionsFragment = mergeFragments(
+          decoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
         return typeManifest({
           ...childManifest,
-          decoder: pipe24(
-            childManifest.decoder,
-            (f) => mapFragmentContent11(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"]),
-            (f) => mergeFragmentImports(f, [decoderImports])
-          ),
-          encoder: pipe24(
-            childManifest.encoder,
-            (f) => mapFragmentContent11(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
-            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"]),
-            (f) => mergeFragmentImports(f, [encoderImports])
-          ),
-          looseType: pipe24(
-            childManifest.looseType,
-            (f) => mapFragmentContent11(f, (c) => `OptionOrNullable<${c}>`),
-            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
-          ),
-          strictType: pipe24(
-            childManifest.strictType,
-            (f) => mapFragmentContent11(f, (c) => `Option<${c}>`),
-            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
-          )
+          decoder: fragment`${use("getOptionDecoder", "solanaOptions")}(${childManifest.decoder}${decoderOptionsFragment})`,
+          encoder: fragment`${use("getOptionEncoder", "solanaOptions")}(${childManifest.encoder}${encoderOptionsFragment})`,
+          looseType: fragment`${use("type OptionOrNullable", "solanaOptions")}<${childManifest.looseType}>`,
+          strictType: fragment`${use("type Option", "solanaOptions")}<${childManifest.strictType}>`
         });
       }
     }),
@@ -3052,292 +3097,99 @@ ${jsDocblock(structFieldDocs)}` : "";
 function getArrayLikeSizeOption(count, visitor) {
   if (isNode15(count, "fixedCountNode")) {
     return {
-      decoder: fragment(`size: ${count.value}`),
-      encoder: fragment(`size: ${count.value}`)
+      decoder: fragment`size: ${count.value}`,
+      encoder: fragment`size: ${count.value}`
     };
   }
   if (isNode15(count, "remainderCountNode")) {
     return {
-      decoder: fragment(`size: 'remainder'`),
-      encoder: fragment(`size: 'remainder'`)
+      decoder: fragment`size: 'remainder'`,
+      encoder: fragment`size: 'remainder'`
     };
   }
-  const prefix = resolveNestedTypeNode3(count.prefix);
+  const prefix = resolveNestedTypeNode4(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
-    return { decoder: fragment(""), encoder: fragment("") };
+    return { decoder: void 0, encoder: void 0 };
   }
-  const prefixManifest = visit5(count.prefix, visitor);
+  const prefixManifest = visit8(count.prefix, visitor);
   return {
-    decoder: pipe24(prefixManifest.decoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`)),
-    encoder: pipe24(prefixManifest.encoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`))
-  };
-}
-
-// src/nameTransformers.ts
-import { camelCase as camelCase11, capitalize, kebabCase as kebabCase2, pascalCase as pascalCase7, snakeCase as snakeCase2, titleCase as titleCase2 } from "@codama/nodes";
-function getNameApi(transformers) {
-  const helpers = {
-    camelCase: camelCase11,
-    capitalize,
-    kebabCase: kebabCase2,
-    pascalCase: pascalCase7,
-    snakeCase: snakeCase2,
-    titleCase: titleCase2
+    decoder: pipe15(prefixManifest.decoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`)),
+    encoder: pipe15(prefixManifest.encoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`))
   };
-  return Object.fromEntries(
-    Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
-  );
 }
-var DEFAULT_NAME_TRANSFORMERS = {
-  accountDecodeFunction: (name) => `decode${pascalCase7(name)}`,
-  accountFetchAllFunction: (name) => `fetchAll${pascalCase7(name)}`,
-  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${pascalCase7(name)}`,
-  accountFetchFromSeedsFunction: (name) => `fetch${pascalCase7(name)}FromSeeds`,
-  accountFetchFunction: (name) => `fetch${pascalCase7(name)}`,
-  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${pascalCase7(name)}FromSeeds`,
-  accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase7(name)}`,
-  accountGetSizeFunction: (name) => `get${pascalCase7(name)}Size`,
-  codecFunction: (name) => `get${pascalCase7(name)}Codec`,
-  constant: (name) => snakeCase2(name).toUpperCase(),
-  constantFunction: (name) => `get${pascalCase7(name)}Bytes`,
-  dataArgsType: (name) => `${pascalCase7(name)}Args`,
-  dataType: (name) => `${pascalCase7(name)}`,
-  decoderFunction: (name) => `get${pascalCase7(name)}Decoder`,
-  discriminatedUnionDiscriminator: () => "__kind",
-  discriminatedUnionFunction: (name) => `${camelCase11(name)}`,
-  discriminatedUnionVariant: (name) => `${pascalCase7(name)}`,
-  encoderFunction: (name) => `get${pascalCase7(name)}Encoder`,
-  enumVariant: (name) => `${pascalCase7(name)}`,
-  instructionAsyncFunction: (name) => `get${pascalCase7(name)}InstructionAsync`,
-  instructionAsyncInputType: (name) => `${pascalCase7(name)}AsyncInput`,
-  instructionDataType: (name) => `${pascalCase7(name)}InstructionData`,
-  instructionExtraType: (name) => `${pascalCase7(name)}InstructionExtra`,
-  instructionParseFunction: (name) => `parse${pascalCase7(name)}Instruction`,
-  instructionParsedType: (name) => `Parsed${pascalCase7(name)}Instruction`,
-  instructionSyncFunction: (name) => `get${pascalCase7(name)}Instruction`,
-  instructionSyncInputType: (name) => `${pascalCase7(name)}Input`,
-  instructionType: (name) => `${pascalCase7(name)}Instruction`,
-  isDiscriminatedUnionFunction: (name) => `is${pascalCase7(name)}`,
-  pdaFindFunction: (name) => `find${pascalCase7(name)}Pda`,
-  pdaSeedsType: (name) => `${pascalCase7(name)}Seeds`,
-  programAccountsEnum: (name) => `${pascalCase7(name)}Account`,
-  programAccountsEnumVariant: (name) => `${pascalCase7(name)}`,
-  programAccountsIdentifierFunction: (name) => `identify${pascalCase7(name)}Account`,
-  programAddressConstant: (name) => `${snakeCase2(name).toUpperCase()}_PROGRAM_ADDRESS`,
-  programErrorConstant: (name) => snakeCase2(name).toUpperCase(),
-  programErrorConstantPrefix: (name) => `${snakeCase2(name).toUpperCase()}_ERROR__`,
-  programErrorMessagesMap: (name) => `${camelCase11(name)}ErrorMessages`,
-  programErrorUnion: (name) => `${pascalCase7(name)}Error`,
-  programGetErrorMessageFunction: (name) => `get${pascalCase7(name)}ErrorMessage`,
-  programInstructionsEnum: (name) => `${pascalCase7(name)}Instruction`,
-  programInstructionsEnumVariant: (name) => `${pascalCase7(name)}`,
-  programInstructionsIdentifierFunction: (name) => `identify${pascalCase7(name)}Instruction`,
-  programInstructionsParsedUnionType: (name) => `Parsed${pascalCase7(name)}Instruction`,
-  programIsErrorFunction: (name) => `is${pascalCase7(name)}Error`,
-  resolverFunction: (name) => `${camelCase11(name)}`
-};
 
-// src/getRenderMapVisitor.ts
+// src/visitors/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
   const linkables = new LinkableDictionary3();
   const stack = new NodeStack2();
-  const nameTransformers = {
-    ...DEFAULT_NAME_TRANSFORMERS,
-    ...options.nameTransformers
-  };
-  const nameApi = getNameApi(nameTransformers);
-  const renderParentInstructions = options.renderParentInstructions ?? false;
-  const dependencyMap = options.dependencyMap ?? {};
-  const useGranularImports = options.useGranularImports ?? false;
-  const asyncResolvers = (options.asyncResolvers ?? []).map(camelCase12);
-  const nonScalarEnums = (options.nonScalarEnums ?? []).map(camelCase12);
-  const internalNodes = (options.internalNodes ?? []).map(camelCase12);
   const customAccountData = parseCustomDataOptions(options.customAccountData ?? [], "AccountData");
   const customInstructionData = parseCustomDataOptions(options.customInstructionData ?? [], "InstructionData");
-  const getImportFrom = getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData);
-  const typeManifestVisitor = getTypeManifestVisitor({
+  const renderScopeWithTypeManifestVisitor = {
+    asyncResolvers: (options.asyncResolvers ?? []).map(camelCase14),
     customAccountData,
     customInstructionData,
-    getImportFrom,
+    dependencyMap: options.dependencyMap ?? {},
+    getImportFrom: getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData),
     linkables,
-    nameApi,
-    nonScalarEnums,
-    stack
-  });
+    nameApi: getNameApi({ ...DEFAULT_NAME_TRANSFORMERS, ...options.nameTransformers }),
+    nonScalarEnums: (options.nonScalarEnums ?? []).map(camelCase14),
+    renderParentInstructions: options.renderParentInstructions ?? false,
+    useGranularImports: options.useGranularImports ?? false
+  };
+  const typeManifestVisitor = getTypeManifestVisitor({ ...renderScopeWithTypeManifestVisitor, stack });
+  const renderScope = { ...renderScopeWithTypeManifestVisitor, typeManifestVisitor };
+  const internalNodes = (options.internalNodes ?? []).map(camelCase14);
   const resolvedInstructionInputVisitor = getResolvedInstructionInputsVisitor();
   const byteSizeVisitor = getByteSizeVisitor(linkables, { stack });
-  const globalScope = {
-    asyncResolvers,
-    customAccountData,
-    customInstructionData,
-    getImportFrom,
-    linkables,
-    nameApi,
-    nonScalarEnums,
-    renderParentInstructions,
-    typeManifestVisitor
-  };
-  const render2 = (template, context, renderOptions) => {
-    return render(join2("pages", template), context, renderOptions);
+  const asPage = (fragment2, dependencyMap = {}) => {
+    if (!fragment2) return void 0;
+    return getPageFragment(fragment2, {
+      ...renderScope,
+      dependencyMap: { ...renderScope.dependencyMap, ...dependencyMap }
+    });
   };
-  return pipe25(
-    staticVisitor2(() => renderMap(), {
+  return pipe16(
+    staticVisitor2(() => createRenderMap(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
     (v) => extendVisitor2(v, {
       visitAccount(node) {
-        const accountPath = stack.getPath("accountNode");
-        if (!findProgramNodeFromPath7(accountPath)) {
-          throw new Error("Account must be visited inside a program.");
-        }
-        const scope = {
-          ...globalScope,
-          accountPath,
-          size: visit6(node, byteSizeVisitor),
-          typeManifest: visit6(node, typeManifestVisitor)
-        };
-        const fields = resolveNestedTypeNode4(node.data).fields;
-        const accountDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
-          ...scope,
-          discriminatorNodes: node.discriminators ?? [],
-          fields,
-          prefix: node.name
-        });
-        const accountTypeFragment = getAccountTypeFragment(scope);
-        const accountFetchHelpersFragment = getAccountFetchHelpersFragment(scope);
-        const accountSizeHelpersFragment = getAccountSizeHelpersFragment(scope);
-        const accountPdaHelpersFragment = getAccountPdaHelpersFragment(scope);
-        const imports = new ImportMap().mergeWith(
-          accountDiscriminatorConstantsFragment,
-          accountTypeFragment,
-          accountFetchHelpersFragment,
-          accountSizeHelpersFragment,
-          accountPdaHelpersFragment
-        );
-        return addToRenderMap(
-          renderMap(),
-          `accounts/${camelCase12(node.name)}.ts`,
-          render2("accountsPage.njk", {
-            accountDiscriminatorConstantsFragment: accountDiscriminatorConstantsFragment.content,
-            accountFetchHelpersFragment: accountFetchHelpersFragment.content,
-            accountPdaHelpersFragment: accountPdaHelpersFragment.content,
-            accountSizeHelpersFragment: accountSizeHelpersFragment.content,
-            accountTypeFragment: accountTypeFragment.content,
-            imports: imports.toString(dependencyMap, useGranularImports)
-          })
+        return createRenderMap(
+          `accounts/${camelCase14(node.name)}.ts`,
+          asPage(
+            getAccountPageFragment({
+              ...renderScope,
+              accountPath: stack.getPath("accountNode"),
+              size: visit9(node, byteSizeVisitor)
+            })
+          )
         );
       },
       visitDefinedType(node) {
-        const scope = {
-          ...globalScope,
-          codecDocs: [],
-          decoderDocs: [],
-          encoderDocs: [],
-          manifest: visit6(node, typeManifestVisitor),
-          name: node.name,
-          node: node.type,
-          size: visit6(node, byteSizeVisitor),
-          typeDocs: node.docs,
-          typeNode: node.type
-        };
-        const typeWithCodecFragment = getTypeWithCodecFragment(scope);
-        const typeDiscriminatedUnionHelpersFragment = getTypeDiscriminatedUnionHelpersFragment(scope);
-        const imports = new ImportMap().mergeWith(typeWithCodecFragment, typeDiscriminatedUnionHelpersFragment).remove("generatedTypes", [
-          nameApi.dataType(node.name),
-          nameApi.dataArgsType(node.name),
-          nameApi.encoderFunction(node.name),
-          nameApi.decoderFunction(node.name),
-          nameApi.codecFunction(node.name)
-        ]);
-        return addToRenderMap(
-          renderMap(),
-          `types/${camelCase12(node.name)}.ts`,
-          render2("definedTypesPage.njk", {
-            imports: imports.toString({ ...dependencyMap, generatedTypes: "." }),
-            typeDiscriminatedUnionHelpersFragment: typeDiscriminatedUnionHelpersFragment.content,
-            typeWithCodecFragment: typeWithCodecFragment.content
+        return createRenderMap(
+          `types/${camelCase14(node.name)}.ts`,
+          asPage(getTypePageFragment({ ...renderScope, node, size: visit9(node, byteSizeVisitor) }), {
+            generatedTypes: "."
           })
         );
       },
       visitInstruction(node) {
-        const instructionPath = stack.getPath("instructionNode");
-        if (!findProgramNodeFromPath7(instructionPath)) {
-          throw new Error("Instruction must be visited inside a program.");
-        }
-        const instructionExtraName = nameApi.instructionExtraType(node.name);
-        const scope = {
-          ...globalScope,
-          dataArgsManifest: visit6(node, typeManifestVisitor),
-          extraArgsManifest: visit6(
-            definedTypeNode2({
-              name: instructionExtraName,
-              type: structTypeNodeFromInstructionArgumentNodes5(node.extraArguments ?? [])
-            }),
-            typeManifestVisitor
-          ),
-          instructionPath,
-          renamedArgs: getRenamedArgsMap(node),
-          resolvedInputs: visit6(node, resolvedInstructionInputVisitor),
-          size: visit6(node, byteSizeVisitor)
-        };
-        const instructionDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
-          ...scope,
-          discriminatorNodes: node.discriminators ?? [],
-          fields: node.arguments,
-          prefix: node.name
-        });
-        const instructionTypeFragment = getInstructionTypeFragment(scope);
-        const instructionDataFragment = getInstructionDataFragment(scope);
-        const instructionExtraArgsFragment = getInstructionExtraArgsFragment(scope);
-        const instructionFunctionAsyncFragment = getInstructionFunctionFragment({
-          ...scope,
-          useAsync: true
-        });
-        const instructionFunctionSyncFragment = getInstructionFunctionFragment({
-          ...scope,
-          useAsync: false
-        });
-        const instructionParseFunctionFragment = getInstructionParseFunctionFragment(scope);
-        const imports = new ImportMap().mergeWith(
-          instructionDiscriminatorConstantsFragment,
-          instructionTypeFragment,
-          instructionDataFragment,
-          instructionExtraArgsFragment,
-          instructionFunctionAsyncFragment,
-          instructionFunctionSyncFragment,
-          instructionParseFunctionFragment
-        );
-        return addToRenderMap(
-          renderMap(),
-          `instructions/${camelCase12(node.name)}.ts`,
-          render2("instructionsPage.njk", {
-            imports: imports.toString(dependencyMap, useGranularImports),
-            instruction: node,
-            instructionDataFragment: instructionDataFragment.content,
-            instructionDiscriminatorConstantsFragment: instructionDiscriminatorConstantsFragment.content,
-            instructionExtraArgsFragment: instructionExtraArgsFragment.content,
-            instructionFunctionAsyncFragment: instructionFunctionAsyncFragment.content,
-            instructionFunctionSyncFragment: instructionFunctionSyncFragment.content,
-            instructionParseFunctionFragment: instructionParseFunctionFragment.content,
-            instructionTypeFragment: instructionTypeFragment.content
-          })
+        return createRenderMap(
+          `instructions/${camelCase14(node.name)}.ts`,
+          asPage(
+            getInstructionPageFragment({
+              ...renderScope,
+              instructionPath: stack.getPath("instructionNode"),
+              resolvedInputs: visit9(node, resolvedInstructionInputVisitor),
+              size: visit9(node, byteSizeVisitor)
+            })
+          )
         );
       },
       visitPda(node) {
-        const pdaPath = stack.getPath("pdaNode");
-        if (!findProgramNodeFromPath7(pdaPath)) {
-          throw new Error("PDA must be visited inside a program.");
-        }
-        const scope = { ...globalScope, pdaPath };
-        const pdaFunctionFragment = getPdaFunctionFragment(scope);
-        const imports = new ImportMap().mergeWith(pdaFunctionFragment);
-        return addToRenderMap(
-          renderMap(),
-          `pdas/${camelCase12(node.name)}.ts`,
-          render2("pdasPage.njk", {
-            imports: imports.toString(dependencyMap, useGranularImports),
-            pdaFunctionFragment: pdaFunctionFragment.content
-          })
+        return createRenderMap(
+          `pdas/${camelCase14(node.name)}.ts`,
+          asPage(getPdaPageFragment({ ...renderScope, pdaPath: stack.getPath("pdaNode") }))
         );
       },
       visitProgram(node, { self }) {
@@ -3345,42 +3197,19 @@ function getRenderMapVisitor(options = {}) {
           ...getDefinedTypeNodesToExtract(node.accounts, customAccountData),
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
         ];
-        const scope = { ...globalScope, programNode: node };
-        let renders = mergeRenderMaps([
-          ...node.pdas.map((p) => visit6(p, self)),
-          ...node.accounts.map((a) => visit6(a, self)),
-          ...node.definedTypes.map((t) => visit6(t, self)),
-          ...customDataDefinedType.map((t) => visit6(t, self))
-        ]);
-        if (node.errors.length > 0) {
-          const programErrorsFragment = getProgramErrorsFragment(scope);
-          renders = addToRenderMap(
-            renders,
-            `errors/${camelCase12(node.name)}.ts`,
-            render2("errorsPage.njk", {
-              imports: new ImportMap().mergeWith(programErrorsFragment).toString(dependencyMap, useGranularImports),
-              programErrorsFragment: programErrorsFragment.content
-            })
-          );
-        }
-        const programFragment = getProgramFragment(scope);
-        const programAccountsFragment = getProgramAccountsFragment(scope);
-        const programInstructionsFragment = getProgramInstructionsFragment(scope);
-        renders = addToRenderMap(
-          renders,
-          `programs/${camelCase12(node.name)}.ts`,
-          render2("programsPage.njk", {
-            imports: new ImportMap().mergeWith(programFragment, programAccountsFragment, programInstructionsFragment).toString(dependencyMap, useGranularImports),
-            programAccountsFragment: programAccountsFragment.content,
-            programFragment: programFragment.content,
-            programInstructionsFragment: programInstructionsFragment.content
-          })
-        );
+        const scope = { ...renderScope, programNode: node };
         return mergeRenderMaps([
-          renders,
-          ...getAllInstructionsWithSubs2(node, {
-            leavesOnly: !renderParentInstructions
-          }).map((ix) => visit6(ix, self))
+          createRenderMap({
+            [`programs/${camelCase14(node.name)}.ts`]: asPage(getProgramPageFragment(scope)),
+            [`errors/${camelCase14(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)
+          )
         ]);
       },
       visitRoot(node, { self }) {
@@ -3390,97 +3219,41 @@ function getRenderMapVisitor(options = {}) {
         const pdasToExport = getAllPdas(node);
         const accountsToExport = getAllAccounts(node).filter(isNotInternal);
         const instructionsToExport = getAllInstructionsWithSubs2(node, {
-          leavesOnly: !renderParentInstructions
+          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 ctx = {
+        const scope = {
+          ...renderScope,
           accountsToExport,
           definedTypesToExport,
-          hasAnythingToExport,
           instructionsToExport,
           pdasToExport,
-          programsToExport,
-          programsWithErrorsToExport,
-          root: node
+          programsToExport
         };
-        let renders = renderMap();
-        if (hasAnythingToExport) {
-          renders = addToRenderMap(
-            renders,
-            "shared/index.ts",
-            render2("sharedPage.njk", {
-              ...ctx,
-              imports: new ImportMap().add("solanaAddresses", [
-                "type Address",
-                "isProgramDerivedAddress",
-                "type ProgramDerivedAddress"
-              ]).add("solanaInstructions", [
-                "AccountRole",
-                "type AccountMeta",
-                "upgradeRoleToSigner"
-              ]).add("solanaSigners", [
-                "type AccountSignerMeta",
-                "isTransactionSigner",
-                "type TransactionSigner"
-              ]).addAlias("solanaSigners", "isTransactionSigner", "kitIsTransactionSigner").toString(dependencyMap, useGranularImports)
-            })
-          );
-        }
-        if (programsToExport.length > 0) {
-          renders = addToRenderMap(renders, "programs/index.ts", render2("programsIndex.njk", ctx));
-        }
-        if (programsWithErrorsToExport.length > 0) {
-          renders = addToRenderMap(renders, "errors/index.ts", render2("errorsIndex.njk", ctx));
-        }
-        if (accountsToExport.length > 0) {
-          renders = addToRenderMap(renders, "accounts/index.ts", render2("accountsIndex.njk", ctx));
-        }
-        if (pdasToExport.length > 0) {
-          renders = addToRenderMap(renders, "pdas/index.ts", render2("pdasIndex.njk", ctx));
-        }
-        if (instructionsToExport.length > 0) {
-          renders = addToRenderMap(
-            renders,
-            "instructions/index.ts",
-            render2("instructionsIndex.njk", ctx)
-          );
-        }
-        if (definedTypesToExport.length > 0) {
-          renders = addToRenderMap(renders, "types/index.ts", render2("definedTypesIndex.njk", ctx));
-        }
-        return pipe25(
-          renders,
-          (r) => addToRenderMap(r, "index.ts", render2("rootIndex.njk", ctx)),
-          (r) => mergeRenderMaps([r, ...getAllPrograms(node).map((p) => visit6(p, self))])
-        );
+        return mergeRenderMaps([
+          createRenderMap({
+            ["accounts/index.ts"]: asPage(getIndexPageFragment(accountsToExport)),
+            ["errors/index.ts"]: asPage(getIndexPageFragment(programsWithErrorsToExport)),
+            ["index.ts"]: asPage(getRootIndexPageFragment(scope)),
+            ["instructions/index.ts"]: asPage(getIndexPageFragment(instructionsToExport)),
+            ["pdas/index.ts"]: asPage(getIndexPageFragment(pdasToExport)),
+            ["programs/index.ts"]: asPage(getIndexPageFragment(programsToExport)),
+            ["shared/index.ts"]: hasAnythingToExport ? asPage(getSharedPageFragment()) : void 0,
+            ["types/index.ts"]: asPage(getIndexPageFragment(definedTypesToExport))
+          }),
+          ...getAllPrograms(node).map((p) => visit9(p, self))
+        ]);
       }
     }),
     (v) => recordNodeStackVisitor2(v, stack),
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
-function getRenamedArgsMap(instruction) {
-  const argNames = [
-    ...instruction.arguments.map((a) => a.name),
-    ...(instruction.extraArguments ?? []).map((a) => a.name)
-  ];
-  const duplicateArgs = argNames.filter((e, i, a) => a.indexOf(e) !== i);
-  if (duplicateArgs.length > 0) {
-    throw new Error(`Duplicate args found: [${duplicateArgs.join(", ")}] in instruction [${instruction.name}].`);
-  }
-  const allNames = [...instruction.accounts.map((account) => account.name), ...argNames];
-  const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
-  if (duplicates.length === 0) return /* @__PURE__ */ new Map();
-  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`)]));
-}
 
-// src/renderVisitor.ts
+// src/visitors/renderVisitor.ts
 import { deleteDirectory, mapRenderMapContentAsync, writeRenderMap } from "@codama/renderers-core";
-import { rootNodeVisitor, visit as visit7 } from "@codama/visitors-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";
@@ -3500,22 +3273,27 @@ function renderVisitor(path, options = {}) {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    let renderMap2 = visit7(root, getRenderMapVisitor(options));
+    let renderMap = visit10(root, getRenderMapVisitor(options));
     if (options.formatCode ?? true) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      renderMap2 = await mapRenderMapContentAsync(renderMap2, (code) => format(code, prettierOptions));
+      renderMap = await mapRenderMapContentAsync(renderMap, (code) => format(code, prettierOptions));
     }
-    writeRenderMap(renderMap2, path);
+    writeRenderMap(renderMap, path);
   });
 }
 export {
   DEFAULT_NAME_TRANSFORMERS,
-  ImportMap,
+  addToImportMap,
+  createImportMap,
   renderVisitor as default,
   getNameApi,
   getRenderMapVisitor,
   getTypeManifestVisitor,
+  importMapToString,
+  mergeImportMaps,
   mergeTypeManifests,
+  parseImportInput,
+  removeFromImportMap,
   renderVisitor,
   typeManifest
 };