@codama/renderers-js 1.3.4 → 1.4.0

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,102 +40,255 @@ 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;
-  }
-  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]);
+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);
+  }
+  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/fragments/accountFetchHelpers.ts
-import { getLastNodeFromPath } from "@codama/visitors-core";
+// 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/common.ts
-import { join as join2 } from "path";
+// src/fragments/accountFetchHelpers.ts
+import { getLastNodeFromPath, pipe } from "@codama/visitors-core";
 
 // src/utils/async.ts
 import {
@@ -232,7 +385,7 @@ function getBytesFromBytesValueNode(node) {
 
 // src/utils/customData.ts
 import {
-  camelCase,
+  camelCase as camelCase2,
   definedTypeLinkNode,
   definedTypeNode,
   isNode as isNode2,
@@ -241,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)
@@ -318,169 +471,128 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
   };
 }
 
-// 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")}
- */
-`;
+// src/fragments/accountFetchHelpers.ts
+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 accountType = hasCustomData ? typeManifest2.strictType : nameApi.dataType(accountNode.name);
+  const decoderFunction = hasCustomData ? typeManifest2.decoder : `${nameApi.decoderFunction(accountNode.name)}()`;
+  return pipe(
+    fragment`export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<${accountType}, TAddress>;
+export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<${accountType}, TAddress>;
+export function ${decodeFunction}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<${accountType}, TAddress> | MaybeAccount<${accountType}, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, ${decoderFunction});
 }
-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/fragments/common.ts
-function fragment(render2, imports) {
-  return new Fragment(render2, imports);
+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;
 }
-function fragmentFromTemplate(fragmentFile, context, options) {
-  return fragment(render(join2("fragments", fragmentFile), context, options));
+
+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);
 }
-function mergeFragments(fragments, mergeRenders) {
-  return new Fragment(
-    mergeRenders(fragments.map((f) => f.render)),
-    new ImportMap().mergeWith(...fragments),
-    new Set(fragments.flatMap((f) => [...f.features]))
-  );
+
+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;
 }
-var Fragment = class _Fragment {
-  render;
-  imports;
-  features;
-  constructor(render2, imports, features) {
-    this.render = render2;
-    this.imports = imports ? new ImportMap().mergeWith(imports) : new ImportMap();
-    this.features = /* @__PURE__ */ new Set([...features ?? []]);
-  }
-  setRender(render2) {
-    this.render = render2;
-    return this;
-  }
-  mapRender(fn) {
-    this.render = fn(this.render);
-    return this;
-  }
-  addImports(module, imports) {
-    this.imports.add(module, imports);
-    return this;
-  }
-  removeImports(module, imports) {
-    this.imports.remove(module, imports);
-    return this;
-  }
-  mergeImportsWith(...others) {
-    this.imports.mergeWith(...others);
-    return this;
-  }
-  addImportAlias(module, name, alias) {
-    this.imports.addAlias(module, name, alias);
-    return this;
-  }
-  addFeatures(features) {
-    const featureArray = typeof features === "string" ? [features] : features;
-    featureArray.forEach((f) => this.features.add(f));
-    return this;
-  }
-  removeFeatures(features) {
-    const featureArray = typeof features === "string" ? [features] : features;
-    featureArray.forEach((f) => this.features.delete(f));
-    return this;
-  }
-  hasFeatures(features) {
-    const featureArray = typeof features === "string" ? [features] : features;
-    return featureArray.every((f) => this.features.has(f));
-  }
-  mergeFeaturesWith(...others) {
-    others.forEach((f) => this.addFeatures([...f.features]));
-    return this;
-  }
-  clone() {
-    return new _Fragment(this.render).mergeImportsWith(this.imports);
-  }
-  toString() {
-    return this.render;
-  }
-};
 
-// src/fragments/accountFetchHelpers.ts
-function getAccountFetchHelpersFragment(scope) {
-  const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = getLastNodeFromPath(accountPath);
-  const hasCustomData = customAccountData.has(accountNode.name);
-  const accountTypeFragment = hasCustomData ? typeManifest2.strictType.clone() : fragment(nameApi.dataType(accountNode.name));
-  const decoderFunctionFragment = hasCustomData ? typeManifest2.decoder.clone() : fragment(`${nameApi.decoderFunction(accountNode.name)}()`);
-  return fragmentFromTemplate("accountFetchHelpers.njk", {
-    accountType: accountTypeFragment.render,
-    decodeFunction: nameApi.accountDecodeFunction(accountNode.name),
-    decoderFunction: decoderFunctionFragment.render,
-    fetchAllFunction: nameApi.accountFetchAllFunction(accountNode.name),
-    fetchAllMaybeFunction: nameApi.accountFetchAllMaybeFunction(accountNode.name),
-    fetchFunction: nameApi.accountFetchFunction(accountNode.name),
-    fetchMaybeFunction: nameApi.accountFetchMaybeFunction(accountNode.name)
-  }).mergeImportsWith(accountTypeFragment, decoderFunctionFragment).addImports("solanaAddresses", ["type Address"]).addImports("solanaAccounts", [
-    "type Account",
-    "assertAccountExists",
-    "assertAccountsExist",
-    "decodeAccount",
-    "type EncodedAccount",
-    "fetchEncodedAccount",
-    "fetchEncodedAccounts",
-    "type FetchAccountConfig",
-    "type FetchAccountsConfig",
-    "type MaybeAccount",
-    "type MaybeEncodedAccount"
-  ]);
+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",
+      "assertAccountExists",
+      "assertAccountsExist",
+      "decodeAccount",
+      "type EncodedAccount",
+      "fetchEncodedAccount",
+      "fetchEncodedAccounts",
+      "type FetchAccountConfig",
+      "type FetchAccountsConfig",
+      "type MaybeAccount",
+      "type MaybeEncodedAccount"
+    ])
+  );
 }
 
+// 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 } 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.clone() : 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;
-  return fragmentFromTemplate("accountPdaHelpers.njk", {
-    accountType: accountTypeFragment.render,
-    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
-  }).mergeImportsWith(accountTypeFragment).addImports(importFrom, hasVariableSeeds ? [pdaSeedsType, findPdaFunction] : [findPdaFunction]).addImports("solanaAddresses", ["type Address"]).addImports("solanaAccounts", [
-    "type Account",
-    "assertAccountExists",
-    "type FetchAccountConfig",
-    "type MaybeAccount"
-  ]);
+  const fetchFromSeedsFunction = nameApi.accountFetchFromSeedsFunction(accountNode.name);
+  const fetchMaybeFromSeedsFunction = nameApi.accountFetchMaybeFromSeedsFunction(accountNode.name);
+  const fetchMaybeFunction = nameApi.accountFetchMaybeFunction(accountNode.name);
+  return pipe2(
+    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", [
+      "type Account",
+      "assertAccountExists",
+      "type FetchAccountConfig",
+      "type MaybeAccount"
+    ])
+  );
 }
 
 // src/fragments/accountSizeHelpers.ts
@@ -488,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
@@ -504,70 +614,70 @@ import { getLastNodeFromPath as getLastNodeFromPath4 } from "@codama/visitors-co
 // src/fragments/type.ts
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
-  const typeFragment = fragmentFromTemplate("type.njk", {
-    docs,
-    looseName: nameApi.dataArgsType(name),
-    manifest,
-    strictName: nameApi.dataType(name)
-  });
-  if (!manifest.isEnum) {
-    typeFragment.mergeImportsWith(manifest.strictType, manifest.looseType);
+  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}`;
   }
-  return typeFragment;
+  const looseExport = manifest.strictType.content === manifest.looseType.content ? aliasedLooseName : fragment`export type ${looseName} = ${manifest.looseType};`;
+  return fragment`${docblock}export type ${strictName} = ${manifest.strictType};\n\n${looseExport}`;
 }
 
 // src/fragments/typeDecoder.ts
 import { isDataEnum, isNode as isNode3 } from "@codama/nodes";
 function getTypeDecoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
-  const decoderType = typeof scope.size === "number" ? "FixedSizeDecoder" : "Decoder";
+  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";
-  return fragmentFromTemplate("typeDecoder.njk", {
-    decoderFunction: nameApi.decoderFunction(name),
-    decoderType,
-    docs,
-    looseName: nameApi.dataArgsType(name),
-    manifest,
-    strictName: nameApi.dataType(name),
-    useTypeCast
-  }).mergeImportsWith(manifest.decoder).addImports("solanaCodecsCore", `type ${decoderType}`);
+  const typeCast = useTypeCast ? fragment` as ${decoderType}<${strictName}>` : "";
+  return fragment`${docblock}export function ${decoderFunction}(): ${decoderType}<${strictName}> {
+    return ${manifest.decoder}${typeCast};
+}`;
 }
 
 // src/fragments/typeEncoder.ts
 import { isDataEnum as isDataEnum2, isNode as isNode4 } from "@codama/nodes";
 function getTypeEncoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
-  const encoderType = typeof scope.size === "number" ? "FixedSizeEncoder" : "Encoder";
+  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";
-  return fragmentFromTemplate("typeEncoder.njk", {
-    docs,
-    encoderFunction: nameApi.encoderFunction(name),
-    encoderType,
-    looseName: nameApi.dataArgsType(name),
-    manifest,
-    strictName: nameApi.dataType(name),
-    useTypeCast
-  }).mergeImportsWith(manifest.encoder).addImports("solanaCodecsCore", `type ${encoderType}`);
+  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 }),
-      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)
-      }).addImports("solanaCodecsCore", [`type ${codecType}`, "combineCodec"])
+      fragment`${docblock}export function ${codecFunction}(): ${codecType}<${looseName}, ${strictName}> {
+    return ${use("combineCodec", "solanaCodecsCore")}(${encoderFunction}(), ${decoderFunction}());
+}`
     ],
     (renders) => renders.join("\n\n")
   );
@@ -585,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,
@@ -597,41 +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 { visit } from "@codama/visitors-core";
+import { mapFragmentContent } from "@codama/renderers-core";
+import { pipe as pipe3, visit as visit3 } from "@codama/visitors-core";
 import { getBase64Decoder } from "@solana/codecs-strings";
 function getDiscriminatorConditionFragment(scope) {
-  return mergeFragments(
-    scope.discriminators.flatMap((discriminator) => {
-      if (isNode5(discriminator, "sizeDiscriminatorNode")) {
-        return [getSizeConditionFragment(discriminator, scope)];
-      }
-      if (isNode5(discriminator, "constantDiscriminatorNode")) {
-        return [getByteConditionFragment(discriminator, scope)];
-      }
-      if (isNode5(discriminator, "fieldDiscriminatorNode")) {
-        return [getFieldConditionFragment(discriminator, scope)];
-      }
-      return [];
-    }),
-    (r) => r.join(" && ")
-  ).mapRender((r) => `if (${r}) { ${scope.ifTrue}; }`);
+  return pipe3(
+    mergeFragments(
+      scope.discriminators.flatMap((discriminator) => {
+        if (isNode6(discriminator, "sizeDiscriminatorNode")) {
+          return [getSizeConditionFragment(discriminator, scope)];
+        }
+        if (isNode6(discriminator, "constantDiscriminatorNode")) {
+          return [getByteConditionFragment(discriminator, scope)];
+        }
+        if (isNode6(discriminator, "fieldDiscriminatorNode")) {
+          return [getFieldConditionFragment(discriminator, scope)];
+        }
+        return [];
+      }),
+      (c) => c.join(" && ")
+    ),
+    (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 constant.mapRender((r) => `containsBytes(${dataName}, ${r}, ${discriminator.offset})`).addImports("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);
@@ -640,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))
     );
@@ -655,20 +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";
 function getInstructionAccountMetaFragment(instructionAccountNode) {
   const typeParam = `TAccount${pascalCase2(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
-    return fragment(`WritableSignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type WritableSignerAccount"]).addImports("solanaSigners", ["type AccountSignerMeta"]);
+    return fragment`${use("type WritableSignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
   if (instructionAccountNode.isSigner === true) {
-    return fragment(`ReadonlySignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type ReadonlySignerAccount"]).addImports("solanaSigners", ["type AccountSignerMeta"]);
+    return fragment`${use("type ReadonlySignerAccount", "solanaInstructions")}<${typeParam}> & ${use("type AccountSignerMeta", "solanaSigners")}<${typeParam}>`;
   }
   if (instructionAccountNode.isWritable) {
-    return fragment(`WritableAccount<${typeParam}>`).addImports("solanaInstructions", "type WritableAccount");
+    return fragment`${use("type WritableAccount", "solanaInstructions")}<${typeParam}>`;
   }
-  return fragment(`ReadonlyAccount<${typeParam}>`).addImports("solanaInstructions", "type ReadonlyAccount");
+  return fragment`${use("type ReadonlyAccount", "solanaInstructions")}<${typeParam}>`;
 }
 
 // src/fragments/instructionAccountTypeParam.ts
@@ -676,24 +945,20 @@ import { pascalCase as pascalCase3 } from "@codama/nodes";
 import {
   findInstructionNodeFromPath,
   findProgramNodeFromPath as findProgramNodeFromPath2,
-  getLastNodeFromPath as getLastNodeFromPath5
+  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 fragment(`${typeParam} extends string${accountMeta} | undefined = undefined`, imports);
+    return fragment`${typeParam} extends string${accountMeta} | undefined = undefined`;
   }
   const defaultAddress = getDefaultAddress(instructionAccountNode.defaultValue, programNode.publicKey, linkables);
-  return fragment(`${typeParam} extends string${accountMeta} = ${defaultAddress}`, imports);
+  return fragment`${typeParam} extends string${accountMeta} = ${defaultAddress}`;
 }
 function getDefaultAddress(defaultValue, programId, linkables) {
   switch (defaultValue?.kind) {
@@ -710,75 +975,83 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 }
 
 // src/fragments/instructionByteDelta.ts
-import { assertIsNode, camelCase as camelCase3, isNode as isNode6 } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath6 } from "@codama/visitors-core";
+import { assertIsNode, camelCase as camelCase4, isNode as isNode7 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent2 } from "@codama/renderers-core";
+import { getLastNodeFromPath as getLastNodeFromPath7, pipe as pipe4 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = getLastNodeFromPath6(scope.instructionPath);
-  const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
-  if (fragments.length === 0) return fragment("");
+  const { byteDeltas } = getLastNodeFromPath7(scope.instructionPath);
+  const fragments = (byteDeltas ?? []).flatMap((c) => getByteDeltaFragment(c, scope));
+  if (fragments.length === 0) return;
   return mergeFragments(
     fragments,
-    (r) => `// Bytes created or reallocated by the instruction.
-const byteDelta: number = [${r.join(",")}].reduce((a, b) => a + b, 0);`
+    (c) => `// Bytes created or reallocated by the instruction.
+const byteDelta: number = [${c.join(",")}].reduce((a, b) => a + b, 0);`
   );
 }
 function getByteDeltaFragment(byteDelta, scope) {
-  const bytesFragment = (() => {
-    if (isNode6(byteDelta.value, "numberValueNode")) {
+  let bytesFragment = (() => {
+    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.mapRender((r) => `${r} + BASE_ACCOUNT_SIZE`).addImports("solanaAccounts", "BASE_ACCOUNT_SIZE");
+    bytesFragment = fragment`${bytesFragment} + ${use("BASE_ACCOUNT_SIZE", "solanaAccounts")}`;
   }
   if (byteDelta.subtract) {
-    bytesFragment.mapRender((r) => `- (${r})`);
+    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);
-  return fragment(`${functionName}()`).addImports(scope.getImportFrom(byteDelta.value), 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);
-  return fragment(`${awaitKeyword}${functionName}(resolverScope)`).addImports(scope.getImportFrom(byteDelta.value), functionName).addFeatures(["instruction:resolverScopeVariable"]);
+  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,
@@ -789,232 +1062,201 @@ function getInstructionDataFragment(scope) {
   });
 }
 
-// src/fragments/discriminatorConstants.ts
-import {
-  camelCase as camelCase4,
-  isNode as isNode7,
-  isNodeFilter as isNodeFilter3,
-  VALUE_NODES
-} from "@codama/nodes";
-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, (r) => r.join("\n\n"));
+// src/fragments/instructionExtraArgs.ts
+import { mapFragmentContent as mapFragmentContent3 } from "@codama/renderers-core";
+import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
+function getInstructionExtraArgsFragment(scope) {
+  const { instructionPath, extraArgsManifest, nameApi } = scope;
+  const instructionNode = getLastNodeFromPath9(instructionPath);
+  if ((instructionNode.extraArguments ?? []).length === 0) return;
+  const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
+  const looseName = nameApi.dataArgsType(instructionExtraName);
+  return mapFragmentContent3(extraArgsManifest.looseType, (c) => `export type ${looseName} = ${c};`);
 }
-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(
-    [
-      value.mapRender((r) => `export const ${constantName} = ${r};`),
-      encoder.mapRender((r) => `export function ${constantFunction}() { return ${r}.encode(${constantName}); }`)
-    ],
-    (r) => r.join("\n\n")
-  );
-}
-
-// src/fragments/instructionExtraArgs.ts
-import { getLastNodeFromPath as getLastNodeFromPath8 } from "@codama/visitors-core";
-function getInstructionExtraArgsFragment(scope) {
-  const { instructionPath, extraArgsManifest, nameApi } = scope;
-  const instructionNode = getLastNodeFromPath8(instructionPath);
-  if ((instructionNode.extraArguments ?? []).length === 0) {
-    return fragment("");
-  }
-  const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
-  return fragmentFromTemplate("instructionExtraArgs.njk", {
-    looseName: nameApi.dataArgsType(instructionExtraName),
-    manifest: extraArgsManifest,
-    strictName: nameApi.dataType(instructionExtraName)
-  }).mergeImportsWith(extraArgsManifest.looseType);
-}
-
-// src/fragments/instructionFunction.ts
-import { camelCase as camelCase9, isNode as isNode12, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
-import {
-  findProgramNodeFromPath as findProgramNodeFromPath3,
-  getLastNodeFromPath as getLastNodeFromPath12
-} from "@codama/visitors-core";
-
-// src/fragments/instructionInputResolved.ts
-import { camelCase as camelCase6, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
-
-// src/fragments/instructionInputDefault.ts
-import { camelCase as camelCase5, isNode as isNode8 } from "@codama/nodes";
-import { visit as visit3 } from "@codama/visitors-core";
-function getInstructionInputDefaultFragment(scope) {
-  const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
-  if (!input.defaultValue) {
-    return fragment("");
+
+// src/fragments/instructionFunction.ts
+import { camelCase as camelCase9, isNode as isNode12, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent7 } from "@codama/renderers-core";
+import {
+  findProgramNodeFromPath as findProgramNodeFromPath3,
+  getLastNodeFromPath as getLastNodeFromPath13,
+  pipe as pipe8
+} from "@codama/visitors-core";
+
+// src/fragments/instructionInputResolved.ts
+import { camelCase as camelCase6, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent5 } from "@codama/renderers-core";
+import { getLastNodeFromPath as getLastNodeFromPath10 } from "@codama/visitors-core";
+
+// src/fragments/instructionInputDefault.ts
+import { camelCase as camelCase5, isNode as isNode8 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent4, setFragmentContent } from "@codama/renderers-core";
+import { pipe as pipe5, visit as visit4 } from "@codama/visitors-core";
+function getInstructionInputDefaultFragment(scope) {
+  const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
+  if (!input.defaultValue) {
+    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 defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`).addImports(
-          "shared",
-          "expectTransactionSigner"
+        return pipe5(
+          defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`),
+          (f) => addFragmentImports(f, "shared", ["expectTransactionSigner"])
         );
       }
       if (input.kind === "instructionAccountNode") {
-        return defaultFragment(`expectSome(accounts.${name}.value)`).addImports("shared", "expectSome");
+        return pipe5(
+          defaultFragment(`expectSome(accounts.${name}.value)`),
+          (f) => addFragmentImports(f, "shared", ["expectSome"])
+        );
       }
-      return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
+      return pipe5(
+        defaultFragment(`expectAddress(accounts.${name}.value)`),
+        (f) => addFragmentImports(f, "shared", ["expectAddress"])
+      );
     case "pdaValueNode":
       if (isNode8(defaultValue.pda, "pdaNode")) {
-        const pdaProgram = defaultValue.pda.programId ? fragment(
-          `'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`
-        ).addImports("solanaAddresses", "type Address") : fragment("programAddress");
+        const pdaProgram = defaultValue.pda.programId ? pipe5(
+          fragment`'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`,
+          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+        ) : fragment`programAddress`;
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
           if (isNode8(seed, "constantPdaSeedNode") && isNode8(seed.value, "programIdValueNode")) {
             return [
-              fragment(`getAddressEncoder().encode(${pdaProgram.render})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
+              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 [
-              fragment(
-                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
-              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
-            ];
+            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 [
-                fragment(
-                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`
-                ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
+                pipe5(
+                  fragment`${typeManifest2.encoder}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`,
+                  (f) => addFragmentImports(f, "shared", ["expectAddress"])
+                )
               ];
             }
             if (isNode8(valueSeed, "argumentValueNode")) {
               return [
-                fragment(
-                  `${typeManifest2.encoder.render}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`
-                ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
+                pipe5(
+                  fragment`${typeManifest2.encoder}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`,
+                  (f) => addFragmentImports(f, "shared", ["expectSome"])
+                )
               ];
             }
-            const valueManifest2 = visit3(valueSeed, typeManifestVisitor);
-            return [
-              fragment(
-                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
-              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
-            ];
+            const valueManifest2 = visit4(valueSeed, typeManifestVisitor);
+            return [fragment`${typeManifest2.encoder}.encode(${valueManifest2.value})`];
           }
           return [];
         });
-        const pdaStatement = mergeFragments([pdaProgram, ...pdaSeeds2], ([p, ...s]) => {
-          const programAddress2 = p === "programAddress" ? p : `programAddress: ${p}`;
-          return `await getProgramDerivedAddress({ ${programAddress2}, seeds: [${s.join(", ")}] })`;
-        }).addImports("solanaAddresses", "getProgramDerivedAddress");
-        return defaultFragment(pdaStatement.render).mergeImportsWith(pdaStatement);
+        return pipe5(
+          mergeFragments([pdaProgram, ...pdaSeeds2], ([p, ...s]) => {
+            const programAddress2 = p === "programAddress" ? p : `programAddress: ${p}`;
+            return `await getProgramDerivedAddress({ ${programAddress2}, seeds: [${s.join(", ")}] })`;
+          }),
+          (f) => addFragmentImports(f, "solanaAddresses", ["getProgramDerivedAddress"]),
+          (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content)
+        );
       }
       const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
         if (isNode8(seed.value, "accountValueNode")) {
-          return fragment(
-            `${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`
-          ).addImports("shared", "expectAddress");
+          return pipe5(
+            fragment`${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`,
+            (f) => addFragmentImports(f, "shared", ["expectAddress"])
+          );
         }
         if (isNode8(seed.value, "argumentValueNode")) {
-          return fragment(`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`).addImports(
-            "shared",
-            "expectSome"
+          return pipe5(
+            fragment`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`,
+            (f) => addFragmentImports(f, "shared", ["expectSome"])
           );
         }
-        return visit3(seed.value, typeManifestVisitor).value.mapRender((r) => `${seed.name}: ${r}`);
+        return pipe5(
+          visit4(seed.value, typeManifestVisitor).value,
+          (f) => mapFragmentContent4(f, (c) => `${seed.name}: ${c}`)
+        );
       });
-      const pdaSeedsFragment = mergeFragments(pdaSeeds, (renders) => renders.join(", ")).mapRender((r) => `{ ${r} }`);
+      const pdaSeedsFragment = pipe5(
+        mergeFragments(pdaSeeds, (renders) => renders.join(", ")),
+        (f) => mapFragmentContent4(f, (c) => `{ ${c} }`)
+      );
       if (pdaSeeds.length > 0) {
-        pdaArgs.push(pdaSeedsFragment.render);
+        pdaArgs.push(pdaSeedsFragment.content);
       }
-      return defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`).mergeImportsWith(pdaSeedsFragment).addImports(getImportFrom(defaultValue.pda), pdaFunction);
+      const module = getImportFrom(defaultValue.pda);
+      return pipe5(
+        defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`),
+        (f) => mergeFragmentImports(f, [pdaSeedsFragment.imports]),
+        (f) => addFragmentImports(f, module, [pdaFunction])
+      );
     case "publicKeyValueNode":
-      return defaultFragment(`'${defaultValue.publicKey}' as Address<'${defaultValue.publicKey}'>`).addImports(
-        "solanaAddresses",
-        "type Address"
+      return pipe5(
+        defaultFragment(`'${defaultValue.publicKey}' as Address<'${defaultValue.publicKey}'>`),
+        (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
       );
     case "programLinkNode":
       const programAddress = nameApi.programAddressConstant(defaultValue.name);
-      return defaultFragment(programAddress, false).addImports(getImportFrom(defaultValue), programAddress);
+      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 defaultFragment(
-        `expectProgramDerivedAddress(accounts.${camelCase5(defaultValue.name)}.value)[1]`
-      ).addImports("shared", "expectProgramDerivedAddress");
+      return pipe5(
+        defaultFragment(`expectProgramDerivedAddress(accounts.${camelCase5(defaultValue.name)}.value)[1]`),
+        (f) => addFragmentImports(f, "shared", ["expectProgramDerivedAddress"])
+      );
     case "argumentValueNode":
-      return defaultFragment(`expectSome(args.${camelCase5(defaultValue.name)})`).addImports(
-        "shared",
-        "expectSome"
+      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 defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`).addImports(getImportFrom(defaultValue), resolverFunction).addFeatures(["instruction:resolverScopeVariable"]);
+      return pipe5(
+        defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
+        (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
+        (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+      );
     case "conditionalValueNode":
       const ifTrueRenderer = renderNestedInstructionDefault({
         ...scope,
@@ -1025,51 +1267,58 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
         defaultValue: defaultValue.ifFalse
       });
       if (!ifTrueRenderer && !ifFalseRenderer) {
-        return fragment("");
+        return fragment``;
       }
-      const conditionalFragment = fragment("");
+      let conditionalFragment = fragment``;
       if (ifTrueRenderer) {
-        conditionalFragment.mergeImportsWith(ifTrueRenderer).mergeFeaturesWith(ifTrueRenderer);
+        conditionalFragment = mergeFragments([conditionalFragment, ifTrueRenderer], (c) => c[0]);
       }
       if (ifFalseRenderer) {
-        conditionalFragment.mergeImportsWith(ifFalseRenderer).mergeFeaturesWith(ifFalseRenderer);
+        conditionalFragment = mergeFragments([conditionalFragment, ifFalseRenderer], (c) => c[0]);
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
       if (isNode8(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
-        conditionalFragment.addImports(getImportFrom(defaultValue.condition), conditionalResolverFunction).addFeatures(["instruction:resolverScopeVariable"]);
+        const module2 = getImportFrom(defaultValue.condition);
+        conditionalFragment = pipe5(
+          conditionalFragment,
+          (f) => addFragmentImports(f, module2, [conditionalResolverFunction]),
+          (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+        );
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
         const comparedInputName = 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;
-          conditionalFragment.mergeImportsWith(comparedValue).mergeFeaturesWith(comparedValue);
+          const comparedValue = visit4(defaultValue.value, typeManifestVisitor).value;
+          conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
           const operator = negatedCondition ? "!==" : "===";
-          condition = `${comparedInputName} ${operator} ${comparedValue.render}`;
+          condition = `${comparedInputName} ${operator} ${comparedValue.content}`;
         } else {
           condition = negatedCondition ? `!${comparedInputName}` : comparedInputName;
         }
       }
       if (ifTrueRenderer && ifFalseRenderer) {
-        return conditionalFragment.setRender(
+        return setFragmentContent(
+          conditionalFragment,
           `if (${condition}) {
-${ifTrueRenderer.render}
+${ifTrueRenderer.content}
 } else {
-${ifFalseRenderer.render}
+${ifFalseRenderer.content}
 }`
         );
       }
-      return conditionalFragment.setRender(
+      return setFragmentContent(
+        conditionalFragment,
         `if (${condition}) {
-${ifTrueRenderer ? ifTrueRenderer.render : ifFalseRenderer?.render}
+${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
 }`
       );
     default:
-      const valueManifest = visit3(defaultValue, typeManifestVisitor).value;
-      return defaultFragment(valueManifest.render).mergeImportsWith(valueManifest);
+      const valueManifest = visit4(defaultValue, typeManifestVisitor).value;
+      return pipe5(valueManifest, (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content));
   }
 }
 function renderNestedInstructionDefault(scope) {
@@ -1083,32 +1332,30 @@ 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,
       input,
       optionalAccountStrategy: parseOptionalAccountStrategy(instructionNode.optionalAccountStrategy)
     });
-    if (!inputFragment.render) return [];
+    if (!inputFragment.content) return [];
     const camelName = camelCase6(input.name);
     return [
-      inputFragment.mapRender(
-        (r) => isNode9(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
-${r}
+      mapFragmentContent5(
+        inputFragment,
+        (c) => isNode9(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+${c}
 }` : `if (!accounts.${camelName}.value) {
-${r}
+${c}
 }`
       )
     ];
   });
   if (resolvedInputFragments.length === 0) {
-    return fragment("");
+    return fragment``;
   }
-  return mergeFragments(
-    [fragment("// Resolve default values."), ...resolvedInputFragments],
-    (renders) => renders.join("\n")
-  );
+  return mergeFragments([fragment`// Resolve default values.`, ...resolvedInputFragments], (c) => c.join("\n"));
 }
 
 // src/fragments/instructionInputType.ts
@@ -1116,99 +1363,94 @@ 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
+  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 fragmentFromTemplate("instructionInputType.njk", {
-    accountsFragment,
-    customDataArgumentsFragment,
-    dataArgumentsFragment,
-    extraArgumentsFragment,
-    instruction: instructionNode,
-    instructionInputType,
-    remainingAccountsFragment
-  }).mergeImportsWith(
-    accountsFragment,
-    dataArgumentsFragment,
-    customDataArgumentsFragment,
-    extraArgumentsFragment,
-    remainingAccountsFragment
-  ).addImports("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 getAccountTypeFragment2(resolvedAccount).mapRender(
-      (r) => `${docblock}${camelCase7(account.name)}${optionalSign}: ${r};`
-    );
+    return fragment`${docs}${camelCase7(account.name)}${optionalSign}: ${getAccountTypeFragment2(resolvedAccount)};`;
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getAccountTypeFragment2(account) {
   const typeParam = `TAccount${pascalCase4(account.name)}`;
-  if (account.isPda && account.isSigner === false) {
-    return fragment(`ProgramDerivedAddress<${typeParam}>`).addImports("solanaAddresses", [
-      "type ProgramDerivedAddress"
-    ]);
-  }
-  if (account.isPda && account.isSigner === "either") {
-    return fragment(`ProgramDerivedAddress<${typeParam}> | TransactionSigner<${typeParam}>`).addImports("solanaAddresses", ["type ProgramDerivedAddress"]).addImports("solanaSigners", ["type TransactionSigner"]);
-  }
-  if (account.isSigner === "either") {
-    return fragment(`Address<${typeParam}> | TransactionSigner<${typeParam}>`).addImports("solanaAddresses", ["type Address"]).addImports("solanaSigners", ["type TransactionSigner"]);
-  }
-  if (account.isSigner) {
-    return fragment(`TransactionSigner<${typeParam}>`).addImports("solanaSigners", ["type TransactionSigner"]);
-  }
-  return fragment(`Address<${typeParam}>`).addImports("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(""),
-      fragment(nameApi.dataArgsType(customData.importAs)).mergeImportsWith(scope.dataArgsManifest.looseType).mapRender((r) => `${r} & `)
+      void 0,
+      pipe6(
+        fragment`${nameApi.dataArgsType(customData.importAs)}`,
+        (f) => mergeFragmentImports(f, [scope.dataArgsManifest.looseType.imports]),
+        (f) => mapFragmentContent6(f, (c) => `${c} & `)
+      )
     ];
   }
   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, (r) => r.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] : [];
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  if (fragments.length === 0) return;
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
@@ -1217,7 +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 argsType.mapRender((r) => `${camelCase7(renamedName)}${optionalSign}: ${r}["${camelCase7(arg.name)}"];`);
+  return fragment`${camelCase7(renamedName)}${optionalSign}: ${argsType}["${camelCase7(arg.name)}"];`;
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
@@ -1228,16 +1470,16 @@ function getRemainingAccountsFragment(instructionNode) {
     if (argumentExists) return [];
     const isSigner = remainingAccountsNode.isSigner ?? false;
     const optionalSign = remainingAccountsNode.isOptional ?? false ? "?" : "";
-    const signerFragment = fragment(`TransactionSigner`).addImports("solanaSigners", ["type TransactionSigner"]);
-    const addressFragment = fragment(`Address`).addImports("solanaAddresses", ["type Address"]);
-    return (() => {
-      if (isSigner === "either") {
-        return mergeFragments([signerFragment, addressFragment], (r) => r.join(" | "));
-      }
+    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;
-    })().mapRender((r) => `${camelCase7(name)}${optionalSign}: Array<${r}>;`);
+    })();
+    return fragment`${camelCase7(name)}${optionalSign}: Array<${typeFragment}>;`;
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  if (fragments.length === 0) return;
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 
 // src/fragments/instructionRemainingAccounts.ts
@@ -1247,16 +1489,19 @@ import {
   getAllInstructionArguments as getAllInstructionArguments2,
   isNode as isNode11
 } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath11 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath12, pipe as pipe7 } from "@codama/visitors-core";
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = getLastNodeFromPath11(scope.instructionPath);
-  const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
-  if (fragments.length === 0) return fragment("");
-  return mergeFragments(
-    fragments,
-    (r) => `// Remaining accounts.
-const remainingAccounts: AccountMeta[] = ${r.length === 1 ? r[0] : `[...${r.join(", ...")}]`}`
-  ).addImports("solanaInstructions", ["type AccountMeta"]);
+  const { remainingAccounts } = getLastNodeFromPath12(scope.instructionPath);
+  const fragments = (remainingAccounts ?? []).flatMap((a) => getRemainingAccountsFragment2(a, scope));
+  if (fragments.length === 0) return;
+  return pipe7(
+    mergeFragments(
+      fragments,
+      (c) => `// Remaining accounts.
+const remainingAccounts: AccountMeta[] = ${c.length === 1 ? c[0] : `[...${c.join(", ...")}]`}`
+    ),
+    (f) => addFragmentImports(f, "solanaInstructions", ["type AccountMeta"])
+  );
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
@@ -1272,65 +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 fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`).addImports(
-      "solanaInstructions",
-      ["AccountRole"]
-    );
+    return fragment`${argumentArray}.map((address) => ({ address, role: ${role} }))`;
   }
   if (isSigner === "either") {
-    return fragment(
-      `${argumentArray}.map((addressOrSigner) => (isTransactionSigner(addressOrSigner)
-? { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner }
-: { address: addressOrSigner, role: ${role} }
-))`
-    ).addImports("solanaInstructions", ["AccountRole"]).addImports("shared", ["isTransactionSigner"]);
+    return fragment`${argumentArray}.map((addressOrSigner) => (${use("isTransactionSigner", "shared")}(addressOrSigner) ? { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner } : { address: addressOrSigner, role: ${role} }))`;
   }
-  return fragment(
-    `${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`
-  ).addImports("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);
-  return fragment(`${awaitKeyword}${functionName}(resolverScope)`).addImports(scope.getImportFrom(remainingAccounts.value), functionName).addFeatures(["instruction:resolverScopeVariable"]);
+  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;
@@ -1348,161 +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.render : `${nameApi.encoderFunction(instructionDataName)}()`;
-  const argsTypeFragment = fragment(
-    customData ? dataArgsManifest.looseType.render : nameApi.dataArgsType(instructionDataName)
-  );
-  if (customData) {
-    argsTypeFragment.mergeImportsWith(dataArgsManifest.looseType, dataArgsManifest.encoder);
-  }
+  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],
-    (renders) => renders.join("\n\n")
+    (content) => content.join("\n\n")
   );
-  const hasRemainingAccounts = remainingAccountsFragment.render !== "";
-  const hasByteDeltas = byteDeltaFragment.render !== "";
-  const hasResolver = resolvedFragment.hasFeatures("instruction:resolverScopeVariable");
-  const getReturnType = (instructionType) => {
-    let returnType = instructionType;
-    if (hasByteDeltas) {
-      returnType = `${returnType} & InstructionWithByteDelta`;
-    }
-    return useAsync ? `Promise<${returnType}>` : returnType;
-  };
-  const functionFragment = fragmentFromTemplate("instructionFunction.njk", {
-    argsTypeFragment,
-    encoderFunction,
-    functionName,
-    getReturnType,
-    hasAccounts,
-    hasAnyArgs,
-    hasByteDeltas,
-    hasData,
-    hasDataArgs,
-    hasExtraArgs,
-    hasInput,
-    hasLegacyOptionalAccounts,
-    hasRemainingAccounts,
-    hasResolver,
-    inputTypeCallFragment,
-    inputTypeFragment,
-    instruction: instructionNode,
-    instructionTypeFragment,
-    programAddressConstant,
-    renamedArgs: renamedArgsText,
-    resolvedFragment,
-    typeParamsFragment,
-    useAsync
-  }).mergeImportsWith(
-    typeParamsFragment,
-    instructionTypeFragment,
-    inputTypeFragment,
-    inputTypeCallFragment,
-    resolvedFragment,
-    argsTypeFragment
-  ).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaAddresses", ["type Address"]);
-  if (hasAccounts) {
-    functionFragment.addImports("solanaInstructions", ["type AccountMeta"]).addImports("shared", ["getAccountMetaFactory", "type ResolvedAccount"]);
-  }
-  if (hasByteDeltas) {
-    functionFragment.addImports("shared", ["type InstructionWithByteDelta"]);
+  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} }`;
+    }),
+    (cs) => cs.join(", ")
+  );
+  return fragment` // Original accounts.
+const originalAccounts = { ${accounts} }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ${use("type ResolvedAccount", "shared")}>;
+`;
+}
+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`;
   }
-  return functionFragment;
+  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 getTypeParams(instructionNode, programAddressConstant) {
-  const typeParams = instructionNode.accounts.map((account) => `TAccount${pascalCase5(account.name)} extends string`);
-  typeParams.push(`TProgramAddress extends Address = typeof ${programAddressConstant}`);
-  return fragment(typeParams.filter((x) => !!x).join(", ")).mapRender((r) => `<${r}>`).addImports("generatedPrograms", [programAddressConstant]);
+function 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 fragment(
-        `typeof input["${camelName}"] extends TransactionSigner<${typeParam}> ? ${signerRole}<${typeParam}> & AccountSignerMeta<${typeParam}> : ${typeParam}`
-      ).addImports("solanaInstructions", [`type ${signerRole}`]).addImports("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 mergeFragments(
-    [programAddressFragment, ...accountTypeParamsFragments],
-    (renders) => renders.join(", ")
-  ).mapRender((r) => `${instructionTypeName}<${r}>`);
+  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 } 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 = fragment(
-    customData ? dataArgsManifest.strictType.render : nameApi.dataType(instructionDataName)
+  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 decoderFunction = customData ? dataArgsManifest.decoder.render : `${nameApi.decoderFunction(instructionDataName)}()`;
-  if (customData) {
-    dataTypeFragment.mergeImportsWith(dataArgsManifest.strictType, dataArgsManifest.decoder);
-  }
-  return fragmentFromTemplate("instructionParseFunction.njk", {
-    dataTypeFragment,
-    decoderFunction,
-    hasAccounts,
-    hasData,
-    hasOptionalAccounts,
-    instruction: instructionNode,
-    instructionParseFunction: nameApi.instructionParseFunction(instructionNode.name),
-    instructionParsedType: nameApi.instructionParsedType(instructionNode.name),
-    minimumNumberOfAccounts,
-    programAddressConstant
-  }).mergeImportsWith(dataTypeFragment).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaInstructions", ["type Instruction"]).addImports("solanaInstructions", hasAccounts ? ["type InstructionWithAccounts", "type AccountMeta"] : []).addImports("solanaInstructions", hasData ? ["type InstructionWithData"] : []).addImports("solanaCodecsCore", hasData ? ["type ReadonlyUint8Array"] : []);
+  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" : ""};`;
+    }),
+    (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 { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath14 } from "@codama/visitors-core";
-function getInstructionTypeFragment(scope) {
+import { mapFragmentContent as mapFragmentContent8 } from "@codama/renderers-core";
+import { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath15 } from "@codama/visitors-core";
+function getInstructionTypeFragment2(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = 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,
@@ -1510,91 +1876,165 @@ 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(
-      (account) => getInstructionAccountMetaFragment(account).mapRender((r) => {
+      (account) => mapFragmentContent8(getInstructionAccountMetaFragment(account), (c) => {
         const typeParam = `TAccount${pascalCase6(account.name)}`;
         const isLegacyOptional = account.isOptional && usesLegacyOptionalAccounts;
-        const type = `${typeParam} extends string ? ${r} : ${typeParam}`;
+        const type = `${typeParam} extends string ? ${c} : ${typeParam}`;
         if (!isLegacyOptional) return type;
         return `...(${typeParam} extends undefined ? [] : [${type}])`;
       })
     ),
-    (renders) => renders.join(", ")
-  );
-  const fragment2 = fragmentFromTemplate("instructionType.njk", {
-    accountMetas: accountMetasFragment.render,
-    accountTypeParams: accountTypeParamsFragment.render,
-    dataType,
-    hasAccounts,
-    hasData,
-    instruction: instructionNode,
-    instructionType: nameApi.instructionType(instructionNode.name),
-    programAddressConstant
-  }).mergeImportsWith(accountTypeParamsFragment, accountMetasFragment).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaCodecsCore", hasData ? ["type ReadonlyUint8Array"] : []).addImports("solanaInstructions", [
-    "type AccountMeta",
-    "type Instruction",
-    "type InstructionWithAccounts",
-    ...hasData ? ["type InstructionWithData"] : []
-  ]);
-  return fragment2;
+    (c) => c.join(", ")
+  );
+  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 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, 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 fragmentFromTemplate("pdaFunction.njk", {
-    findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
-    hasVariableSeeds,
-    pdaDocs: pdaNode.docs,
-    pdaSeedsType: nameApi.pdaSeedsType(pdaNode.name),
-    programAddress: pdaNode.programId ?? programNode.publicKey,
-    seeds
-  }).mergeImportsWith(imports).addImports("solanaAddresses", ["type Address", "getProgramDerivedAddress", "type ProgramDerivedAddress"]);
-}
-
-// src/fragments/program.ts
-function getProgramFragment(scope) {
-  const { programNode, nameApi } = scope;
-  return fragmentFromTemplate("program.njk", {
-    program: programNode,
-    programAddressConstant: nameApi.programAddressConstant(programNode.name)
-  }).addImports("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 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)],
-    (r) => `${r.join("\n\n")}
-`
+    (c) => c.join("\n\n")
   );
 }
 function getProgramAccountsEnumFragment(scope) {
@@ -1603,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;
@@ -1611,54 +2051,55 @@ 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);
-  const discriminatorsFragment = mergeFragments(
-    accountsWithDiscriminators.map((account) => {
-      const variant = nameApi.programAccountsEnumVariant(account.name);
-      return getDiscriminatorConditionFragment({
-        ...scope,
-        dataName: "data",
-        discriminators: account.discriminators ?? [],
-        ifTrue: `return ${programAccountsEnum}.${variant};`,
-        struct: resolveNestedTypeNode2(account.data)
-      });
-    }),
-    (r) => r.join("\n")
-  );
-  return discriminatorsFragment.mapRender(
-    (discriminators) => `export function ${programAccountsIdentifierFunction}(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programAccountsEnum} {
+  return pipe10(
+    mergeFragments(
+      accountsWithDiscriminators.map((account) => {
+        const variant = nameApi.programAccountsEnumVariant(account.name);
+        return getDiscriminatorConditionFragment({
+          ...scope,
+          dataName: "data",
+          discriminators: account.discriminators ?? [],
+          ifTrue: `return ${programAccountsEnum}.${variant};`,
+          struct: resolveNestedTypeNode3(account.data)
+        });
+      }),
+      (c) => c.join("\n")
+    ),
+    (f) => mapFragmentContent9(
+      f,
+      (discriminators) => `export function ${programAccountsIdentifierFunction}(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programAccountsEnum} {
 const data = 'data' in account ? account.data : account;
 ${discriminators}
 throw new Error("The provided account could not be identified as a ${programNode.name} account.")
 }`
-  ).addImports("solanaCodecsCore", "type ReadonlyUint8Array");
+    ),
+    (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
+  );
 }
 
-// src/fragments/programErrors.ts
-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 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)
-  }).addImports("generatedPrograms", [programAddressConstant]).addImports("solanaPrograms", ["isProgramError"]).addImports("solanaErrors", ["type SolanaError", "type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM"]).addImports("solanaAddresses", ["type Address"]);
+  return pipe11(
+    fragment`export const ${programAddressConstant} = '${programNode.publicKey}' as Address<'${programNode.publicKey}'>;`,
+    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+  );
 }
 
 // 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 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
@@ -1670,8 +2111,7 @@ function getProgramInstructionsFragment(scope) {
       getProgramInstructionsIdentifierFunctionFragment(scopeWithInstructions),
       getProgramInstructionsParsedUnionTypeFragment(scopeWithInstructions)
     ],
-    (r) => `${r.join("\n\n")}
-`
+    (c) => c.join("\n\n")
   );
 }
 function getProgramInstructionsEnumFragment(scope) {
@@ -1680,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;
@@ -1690,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(
@@ -1701,18 +2139,23 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: structTypeNodeFromInstructionArgumentNodes3(instruction.arguments)
+        struct: structTypeNodeFromInstructionArgumentNodes4(instruction.arguments)
       });
     }),
-    (r) => r.join("\n")
+    (c) => c.join("\n")
   );
-  return discriminatorsFragment.mapRender(
-    (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
+  return pipe12(
+    discriminatorsFragment,
+    (f) => mapFragmentContent10(
+      f,
+      (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
 const data = 'data' in instruction ? instruction.data : instruction;
 ${discriminators}
 throw new Error("The provided instruction could not be identified as a ${programNode.name} instruction.")
 }`
-  ).addImports("solanaCodecsCore", "type ReadonlyUint8Array");
+    ),
+    (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
+  );
 }
 function getProgramInstructionsParsedUnionTypeFragment(scope) {
   const { programNode, allInstructions, nameApi } = scope;
@@ -1721,17 +2164,164 @@ 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 fragment(
-      `| { instructionType: ${programInstructionsEnum}.${instructionEnumVariant} } & ${parsedInstructionType}<TProgram>`
-    ).addImports("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}'> =`),
+      fragment`export type ${programInstructionsType}<TProgram extends string = '${programAddress}'> =`,
       ...typeVariants
     ],
-    (r) => r.join("\n")
+    (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
+    ],
+    (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"
+    ])
   );
 }
 
@@ -1740,124 +2330,100 @@ import { isDataEnum as isDataEnum3, isNode as isNode14 } from "@codama/nodes";
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
   const isDiscriminatedUnion = isNode14(typeNode, "enumTypeNode") && isDataEnum3(typeNode);
-  if (!isDiscriminatedUnion) {
-    return fragment("");
-  }
-  return 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
-  }).addImports("solanaCodecsDataStructures", [
-    "type GetDiscriminatedUnionVariantContent",
-    "type GetDiscriminatedUnionVariant"
-  ]);
+  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}'>;`;
+    }),
+    (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 ?? {}) };
 }
 
-// src/TypeManifest.ts
-function typeManifest() {
-  return {
-    decoder: fragment(""),
-    encoder: fragment(""),
-    isEnum: false,
-    looseType: fragment(""),
-    strictType: fragment(""),
-    value: fragment("")
-  };
-}
-function mergeManifests(manifests, options = {}) {
-  const { mergeTypes, mergeCodecs, mergeValues } = options;
-  const merge = (fragmentFn, mergeFn) => mergeFn ? mergeFragments(manifests.map(fragmentFn), mergeFn) : fragment("");
-  return {
-    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)
-  };
+export function ${isDiscriminatedUnionFunctionName}<K extends ${strictName}['${discriminatorName}']>(kind: K, value: ${strictName}): value is ${strictName} & { ${discriminatorName}: K } {
+  return value.${discriminatorName} === kind;
+};
+`;
 }
 
-// src/getRenderMapVisitor.ts
-import { join as join3 } 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 { RenderMap } from "@codama/renderers-core";
-import {
-  extendVisitor as extendVisitor2,
-  findProgramNodeFromPath as findProgramNodeFromPath7,
-  getByteSizeVisitor,
-  getResolvedInstructionInputsVisitor,
-  LinkableDictionary as LinkableDictionary3,
-  NodeStack as NodeStack2,
-  pipe as pipe2,
-  recordLinkablesOnFirstVisitVisitor,
-  recordNodeStackVisitor as recordNodeStackVisitor2,
-  staticVisitor as staticVisitor2,
-  visit as visit6
-} from "@codama/visitors-core";
+// 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,
+  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 pipe(
-    staticVisitor(
-      () => ({
-        decoder: fragment(""),
-        encoder: fragment(""),
-        isEnum: false,
-        looseType: fragment(""),
-        strictType: fragment(""),
-        value: fragment("")
-      }),
-      {
-        keys: [
-          ...REGISTERED_TYPE_NODE_KINDS,
-          ...REGISTERED_VALUE_NODE_KINDS,
-          "definedTypeLinkNode",
-          "definedTypeNode",
-          "accountNode",
-          "instructionNode"
-        ]
-      }
-    ),
+  return pipe15(
+    staticVisitor(() => typeManifest(), {
+      keys: [
+        ...REGISTERED_TYPE_NODE_KINDS,
+        ...REGISTERED_VALUE_NODE_KINDS,
+        "definedTypeLinkNode",
+        "definedTypeNode",
+        "accountNode",
+        "instructionNode"
+      ]
+    }),
     (visitor) => extendVisitor(visitor, {
       visitAccount(account, { self }) {
         parentName = {
@@ -1865,106 +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);
-        childManifest.looseType.mapRender((r) => `Array<${r}>`);
-        childManifest.strictType.mapRender((r) => `Array<${r}>`);
+        const childManifest = visit8(arrayType.item, self);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
-        const encoderOptions = sizeManifest.encoder.render ? `, { ${sizeManifest.encoder.render} }` : "";
-        const decoderOptions = sizeManifest.decoder.render ? `, { ${sizeManifest.decoder.render} }` : "";
-        childManifest.encoder.mapRender((r) => `getArrayEncoder(${r + encoderOptions})`).mergeImportsWith(sizeManifest.encoder).addImports("solanaCodecsDataStructures", "getArrayEncoder");
-        childManifest.decoder.mapRender((r) => `getArrayDecoder(${r + decoderOptions})`).mergeImportsWith(sizeManifest.decoder).addImports("solanaCodecsDataStructures", "getArrayDecoder");
-        return childManifest;
+        const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
+        const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
+        return typeManifest({
+          ...childManifest,
+          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 mergeManifests(
-          node.items.map((v) => visit5(v, self)),
+        return mergeTypeManifests(
+          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.render} }`;
-          sizeDecoder = `{ size: ${size.decoder.render} }`;
+          const size = visit8(booleanType.size, self);
+          sizeEncoder = fragment`{ size: ${size.encoder} }`;
+          sizeDecoder = fragment`{ size: ${size.decoder} }`;
         }
-        return {
-          decoder: fragment(`getBooleanDecoder(${sizeDecoder})`, decoderImports),
-          encoder: fragment(`getBooleanEncoder(${sizeEncoder})`, encoderImports),
-          isEnum: false,
-          looseType: fragment("boolean"),
-          strictType: fragment("boolean"),
-          value: fragment("")
-        };
+        return typeManifest({
+          decoder: fragment`${use("getBooleanDecoder", "solanaCodecsDataStructures")}(${sizeDecoder})`,
+          encoder: fragment`${use("getBooleanEncoder", "solanaCodecsDataStructures")}(${sizeEncoder})`,
+          looseType: fragment`boolean`,
+          strictType: fragment`boolean`
+        });
       },
       visitBooleanValue(node) {
-        const manifest = typeManifest();
-        manifest.value.setRender(JSON.stringify(node.boolean));
-        return manifest;
+        return typeManifest({ value: fragment`${JSON.stringify(node.boolean)}` });
       },
       visitBytesType() {
-        return {
-          decoder: fragment(`getBytesDecoder()`).addImports(
-            "solanaCodecsDataStructures",
-            "getBytesDecoder"
-          ),
-          encoder: fragment(`getBytesEncoder()`).addImports(
-            "solanaCodecsDataStructures",
-            "getBytesEncoder"
-          ),
-          isEnum: false,
-          looseType: fragment("ReadonlyUint8Array").addImports(
-            "solanaCodecsCore",
-            "type ReadonlyUint8Array"
-          ),
-          strictType: fragment("ReadonlyUint8Array").addImports(
-            "solanaCodecsCore",
-            "type ReadonlyUint8Array"
-          ),
-          value: fragment("")
-        };
+        const readonlyUint8Array = use("type ReadonlyUint8Array", "solanaCodecsCore");
+        return typeManifest({
+          decoder: fragment`${use("getBytesDecoder", "solanaCodecsDataStructures")}()`,
+          encoder: fragment`${use("getBytesEncoder", "solanaCodecsDataStructures")}()`,
+          looseType: readonlyUint8Array,
+          strictType: readonlyUint8Array
+        });
       },
       visitBytesValue(node) {
-        const manifest = typeManifest();
         const bytes = getBytesFromBytesValueNode(node);
-        manifest.value.setRender(`new Uint8Array([${Array.from(bytes).join(", ")}])`);
-        return manifest;
+        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})`
-          )
-        };
+        return typeManifest({
+          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;
       },
@@ -1974,54 +2515,52 @@ function getTypeManifestVisitor(input) {
         const encoderFunction = nameApi.encoderFunction(node.name);
         const decoderFunction = nameApi.decoderFunction(node.name);
         const importFrom = getImportFrom(node);
-        return {
-          decoder: fragment(`${decoderFunction}()`).addImports(importFrom, decoderFunction),
-          encoder: fragment(`${encoderFunction}()`).addImports(importFrom, encoderFunction),
-          isEnum: false,
-          looseType: fragment(looseName).addImports(importFrom, `type ${looseName}`),
-          strictType: fragment(strictName).addImports(importFrom, `type ${strictName}`),
-          value: fragment("")
-        };
+        return typeManifest({
+          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 {
-          decoder: fragment(`['${name}', getUnitDecoder()]`).addImports(
-            "solanaCodecsDataStructures",
-            "getUnitDecoder"
-          ),
-          encoder: fragment(`['${name}', getUnitEncoder()]`).addImports(
-            "solanaCodecsDataStructures",
-            "getUnitEncoder"
-          ),
-          isEnum: false,
-          looseType: fragment(`{ ${kindAttribute} }`),
-          strictType: fragment(`{ ${kindAttribute} }`),
-          value: fragment("")
-        };
+        return typeManifest({
+          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;
-        structManifest.strictType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
-        structManifest.looseType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
-        structManifest.encoder.mapRender((r) => `['${name}', ${r}]`);
-        structManifest.decoder.mapRender((r) => `['${name}', ${r}]`);
-        return structManifest;
+        return typeManifest({
+          ...structManifest,
+          decoder: fragment`['${name}', ${structManifest.decoder}]`,
+          encoder: fragment`['${name}', ${structManifest.encoder}]`,
+          looseType: pipe15(
+            structManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          ),
+          strictType: pipe15(
+            structManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          )
+        });
       },
       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}"`;
@@ -2032,37 +2571,47 @@ function getTypeManifestVisitor(input) {
           })
         ]);
         parentName = null;
-        const structManifest = visit5(struct, self);
+        const structManifest = visit8(struct, self);
         parentName = currentParentName;
-        structManifest.strictType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
-        structManifest.looseType.mapRender((r) => `{ ${kindAttribute},${r.slice(1, -1)}}`);
-        structManifest.encoder.mapRender((r) => `['${name}', ${r}]`);
-        structManifest.decoder.mapRender((r) => `['${name}', ${r}]`);
-        return structManifest;
+        return typeManifest({
+          ...structManifest,
+          decoder: fragment`['${name}', ${structManifest.decoder}]`,
+          encoder: fragment`['${name}', ${structManifest.encoder}]`,
+          looseType: pipe15(
+            structManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          ),
+          strictType: pipe15(
+            structManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          )
+        });
       },
       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.render}`);
-          decoderOptions.push(`size: ${sizeManifest.decoder.render}`);
+          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(
@@ -2070,31 +2619,26 @@ function getTypeManifestVisitor(input) {
             );
           }
           const variantNames = enumType.variants.map(({ name }) => nameApi.enumVariant(name));
-          return {
-            decoder: fragment(
-              `getEnumDecoder(${currentParentName.strict + decoderOptionsAsString})`,
-              decoderImports.add("solanaCodecsDataStructures", "getEnumDecoder")
-            ),
-            encoder: fragment(
-              `getEnumEncoder(${currentParentName.strict + encoderOptionsAsString})`,
-              encoderImports.add("solanaCodecsDataStructures", "getEnumEncoder")
-            ),
+          return typeManifest({
+            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(", ")} }`),
-            value: fragment("")
-          };
+            looseType: fragment`{ ${variantNames.join(", ")} }`,
+            strictType: fragment`{ ${variantNames.join(", ")} }`
+          });
         }
-        const mergedManifest = mergeManifests(
-          enumType.variants.map((variant) => visit5(variant, self)),
+        const mergedManifest = mergeTypeManifests(
+          enumType.variants.map((variant) => visit8(variant, self)),
           {
             mergeCodecs: (renders) => renders.join(", "),
             mergeTypes: (renders) => renders.join(" | ")
           }
         );
-        mergedManifest.encoder.mapRender((r) => `getDiscriminatedUnionEncoder([${r}]${encoderOptionsAsString})`).mergeImportsWith(encoderImports).addImports("solanaCodecsDataStructures", ["getDiscriminatedUnionEncoder"]);
-        mergedManifest.decoder.mapRender((r) => `getDiscriminatedUnionDecoder([${r}]${decoderOptionsAsString})`).mergeImportsWith(decoderImports).addImports("solanaCodecsDataStructures", ["getDiscriminatedUnionDecoder"]);
-        return mergedManifest;
+        return typeManifest({
+          ...mergedManifest,
+          decoder: fragment`${use("getDiscriminatedUnionDecoder", "solanaCodecsDataStructures")}([${mergedManifest.decoder}]${decoderOptionsFragment})`,
+          encoder: fragment`${use("getDiscriminatedUnionEncoder", "solanaCodecsDataStructures")}([${mergedManifest.encoder}]${encoderOptionsFragment})`
+        });
       },
       visitEnumValue(node, { self }) {
         const manifest = typeManifest();
@@ -2105,40 +2649,76 @@ function getTypeManifestVisitor(input) {
         const isScalar = enumNode && isNode15(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
-          manifest.value.setRender(`${enumName}.${variantName2}`).addImports(importFrom, enumName);
-          return manifest;
+          return typeManifest({
+            ...manifest,
+            value: pipe15(
+              manifest.value,
+              (f) => setFragmentContent2(f, `${enumName}.${variantName2}`),
+              (f) => addFragmentImports(f, importFrom, [enumName])
+            )
+          });
         }
         const variantName = nameApi.discriminatedUnionVariant(node.variant);
         if (!node.value) {
-          manifest.value.setRender(`${enumFunction}('${variantName}')`).addImports(importFrom, enumFunction);
-          return manifest;
+          return typeManifest({
+            ...manifest,
+            value: pipe15(
+              manifest.value,
+              (f) => setFragmentContent2(f, `${enumFunction}('${variantName}')`),
+              (f) => addFragmentImports(f, importFrom, [enumFunction])
+            )
+          });
         }
-        manifest.value = visit5(node.value, self).value.mapRender((r) => `${enumFunction}('${variantName}', ${r})`).addImports(importFrom, enumFunction);
-        return manifest;
+        return typeManifest({
+          ...manifest,
+          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);
-        manifest.encoder.mapRender((r) => `fixEncoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixEncoderSize");
-        manifest.decoder.mapRender((r) => `fixDecoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixDecoderSize");
-        return manifest;
+        const manifest = visit8(node.type, self);
+        return typeManifest({
+          ...manifest,
+          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 = fragment(prefixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...prefixes);
-        const prefixDecoders = fragment(prefixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...prefixes);
-        manifest.encoder.mapRender((r) => `getHiddenPrefixEncoder(${r}, [${prefixEncoders.render}])`).mergeImportsWith(prefixEncoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixEncoder");
-        manifest.decoder.mapRender((r) => `getHiddenPrefixDecoder(${r}, [${prefixDecoders.render}])`).mergeImportsWith(prefixDecoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixDecoder");
-        return manifest;
+        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 = pipe15(
+          mergeFragments(prefixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
+        );
+        return typeManifest({
+          ...manifest,
+          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 = fragment(suffixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...suffixes);
-        const suffixDecoders = fragment(suffixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...suffixes);
-        manifest.encoder.mapRender((r) => `getHiddenSuffixEncoder(${r}, [${suffixEncoders.render}])`).mergeImportsWith(suffixEncoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixEncoder");
-        manifest.decoder.mapRender((r) => `getHiddenSuffixDecoder(${r}, [${suffixDecoders.render}])`).mergeImportsWith(suffixDecoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixDecoder");
-        return manifest;
+        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 = pipe15(
+          mergeFragments(suffixes, (cs) => cs.map((c) => `getConstantDecoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
+        );
+        return typeManifest({
+          ...manifest,
+          decoder: fragment`${use("getHiddenSuffixDecoder", "solanaCodecsDataStructures")}(${manifest.decoder}, [${suffixDecoders}])`,
+          encoder: fragment`${use("getHiddenSuffixEncoder", "solanaCodecsDataStructures")}(${manifest.encoder}, [${suffixEncoders}])`
+        });
       },
       visitInstruction(instruction, { self }) {
         const instructionDataName = nameApi.instructionDataType(instruction.name);
@@ -2147,97 +2727,96 @@ 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 mergeManifests([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 mergedManifest = mergeManifests([key, value], {
+        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.render ? `, { ${sizeManifest.encoder.render} }` : "";
-        const decoderOptions = sizeManifest.decoder.render ? `, { ${sizeManifest.decoder.render} }` : "";
-        mergedManifest.encoder.mapRender((r) => `getMapEncoder(${r}${encoderOptions})`).addImports("solanaCodecsDataStructures", "getMapEncoder");
-        mergedManifest.decoder.mapRender((r) => `getMapDecoder(${r}${decoderOptions})`).addImports("solanaCodecsDataStructures", "getMapDecoder");
-        return mergedManifest;
+        const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
+        const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
+        return typeManifest({
+          ...mergedManifest,
+          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));
-        return mergeManifests(entryFragments, {
+        const entryFragments = node.entries.map((entry) => visit8(entry, self));
+        return mergeTypeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
       },
       visitNoneValue() {
-        const manifest = typeManifest();
-        manifest.value.setRender("none()").addImports("solanaOptions", "none");
-        return manifest;
+        return typeManifest({
+          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 }";
-        }
-        return {
-          decoder: fragment(`${decoderFunction}(${endianness})`, decoderImports),
-          encoder: fragment(`${encoderFunction}(${endianness})`, encoderImports),
-          isEnum: false,
-          looseType: fragment(isBigNumber ? "number | bigint" : "number"),
-          strictType: fragment(isBigNumber ? "bigint" : "number"),
-          value: fragment("")
-        };
+        const endianness = numberType.endian === "be" ? fragment`{ endian: ${use("Endian", "solanaCodecsNumbers")}.Big }` : "";
+        return typeManifest({
+          decoder: fragment`${decoderFunction}(${endianness})`,
+          encoder: fragment`${encoderFunction}(${endianness})`,
+          looseType: fragment`${isBigNumber ? "number | bigint" : "number"}`,
+          strictType: fragment`${isBigNumber ? "bigint" : "number"}`
+        });
       },
       visitNumberValue(node) {
-        const manifest = typeManifest();
-        manifest.value.setRender(JSON.stringify(node.number));
-        return manifest;
+        return typeManifest({ value: fragment`${JSON.stringify(node.number)}` });
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visit5(optionType.item, self);
-        childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
-        childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
+        const childManifest = visit8(optionType.item, self);
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = resolveNestedTypeNode3(optionType.prefix);
+        const optionPrefix = resolveNestedTypeNode4(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = visit5(optionType.prefix, self);
-          childManifest.encoder.mergeImportsWith(prefixManifest.encoder);
-          childManifest.decoder.mergeImportsWith(prefixManifest.decoder);
-          encoderOptions.push(`prefix: ${prefixManifest.encoder.render}`);
-          decoderOptions.push(`prefix: ${prefixManifest.decoder.render}`);
+          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(", ")} }` : "";
-        childManifest.encoder.mapRender((r) => `getOptionEncoder(${r + encoderOptionsAsString})`).addImports("solanaOptions", "getOptionEncoder");
-        childManifest.decoder.mapRender((r) => `getOptionDecoder(${r + decoderOptionsAsString})`).addImports("solanaOptions", "getOptionDecoder");
-        return childManifest;
+        const encoderOptionsFragment = mergeFragments(
+          encoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        const decoderOptionsFragment = mergeFragments(
+          decoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        return typeManifest({
+          ...childManifest,
+          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") {
-          manifest.encoder.mapRender((r) => `padRightEncoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padRightEncoder");
-          manifest.decoder.mapRender((r) => `padRightDecoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padRightDecoder");
-          return manifest;
+          return typeManifest({
+            ...manifest,
+            decoder: fragment`${use("padRightDecoder", "solanaCodecsCore")}(${manifest.decoder}, ${node.offset})`,
+            encoder: fragment`${use("padRightEncoder", "solanaCodecsCore")}(${manifest.encoder}, ${node.offset})`
+          });
         }
         const fn = (() => {
           switch (node.strategy) {
@@ -2250,16 +2829,20 @@ function getTypeManifestVisitor(input) {
               return node.offset < 0 ? `({ postOffset }) => postOffset ${node.offset}` : `({ postOffset }) => postOffset + ${node.offset}`;
           }
         })();
-        manifest.encoder.mapRender((r) => `offsetEncoder(${r}, { postOffset: ${fn} })`).addImports("solanaCodecsCore", "offsetEncoder");
-        manifest.decoder.mapRender((r) => `offsetDecoder(${r}, { postOffset: ${fn} })`).addImports("solanaCodecsCore", "offsetDecoder");
-        return manifest;
+        return typeManifest({
+          ...manifest,
+          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") {
-          manifest.encoder.mapRender((r) => `padLeftEncoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padLeftEncoder");
-          manifest.decoder.mapRender((r) => `padLeftDecoder(${r}, ${node.offset})`).addImports("solanaCodecsCore", "padLeftDecoder");
-          return manifest;
+          return typeManifest({
+            ...manifest,
+            decoder: fragment`${use("padLeftDecoder", "solanaCodecsCore")}(${manifest.decoder}, ${node.offset})`,
+            encoder: fragment`${use("padLeftEncoder", "solanaCodecsCore")}(${manifest.encoder}, ${node.offset})`
+          });
         }
         const fn = (() => {
           switch (node.strategy) {
@@ -2270,85 +2853,91 @@ function getTypeManifestVisitor(input) {
               return node.offset < 0 ? `({ preOffset }) => preOffset ${node.offset}` : `({ preOffset }) => preOffset + ${node.offset}`;
           }
         })();
-        manifest.encoder.mapRender((r) => `offsetEncoder(${r}, { preOffset: ${fn} })`).addImports("solanaCodecsCore", "offsetEncoder");
-        manifest.decoder.mapRender((r) => `offsetDecoder(${r}, { preOffset: ${fn} })`).addImports("solanaCodecsCore", "offsetDecoder");
-        return manifest;
+        return typeManifest({
+          ...manifest,
+          decoder: fragment`${use("offsetDecoder", "solanaCodecsCore")}(${manifest.decoder}, { preOffset: ${fn} })`,
+          encoder: fragment`${use("offsetEncoder", "solanaCodecsCore")}(${manifest.encoder}, { preOffset: ${fn} })`
+        });
       },
       visitPublicKeyType() {
-        const imports = new ImportMap().add("solanaAddresses", "type Address");
-        return {
-          decoder: fragment("getAddressDecoder()").addImports("solanaAddresses", "getAddressDecoder"),
-          encoder: fragment("getAddressEncoder()").addImports("solanaAddresses", "getAddressEncoder"),
-          isEnum: false,
-          looseType: fragment("Address", imports),
-          strictType: fragment("Address", imports),
-          value: fragment("")
-        };
+        return typeManifest({
+          decoder: fragment`${use("getAddressDecoder", "solanaAddresses")}()`,
+          encoder: fragment`${use("getAddressEncoder", "solanaAddresses")}()`,
+          looseType: use("type Address", "solanaAddresses"),
+          strictType: use("type Address", "solanaAddresses")
+        });
       },
       visitPublicKeyValue(node) {
-        const manifest = typeManifest();
-        manifest.value.setRender(`address("${node.publicKey}")`).addImports("solanaAddresses", "address");
-        return manifest;
+        return typeManifest({
+          value: fragment`${use("address", "solanaAddresses")}("${node.publicKey}")`
+        });
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = visit5(node.item, self);
-        childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
-        childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
+        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(", ")} }` : "";
-        childManifest.encoder.mapRender((r) => `getOptionEncoder(${r + encoderOptionsAsString})`).addImports("solanaOptions", "getOptionEncoder");
-        childManifest.decoder.mapRender((r) => `getOptionDecoder(${r + decoderOptionsAsString})`).addImports("solanaOptions", "getOptionDecoder");
-        return childManifest;
+        return typeManifest({
+          ...childManifest,
+          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;
-        manifest.encoder.mapRender((r) => `addEncoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addEncoderSentinel");
-        manifest.decoder.mapRender((r) => `addDecoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addDecoderSentinel");
-        return manifest;
+        const manifest = visit8(node.type, self);
+        const sentinel = visit8(node.sentinel, self).value;
+        return typeManifest({
+          ...manifest,
+          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);
-        childManifest.strictType.mapRender((r) => `Set<${r}>`);
-        childManifest.looseType.mapRender((r) => `Set<${r}>`);
+        const childManifest = visit8(setType.item, self);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
-        const encoderOptions = sizeManifest.encoder.render ? `, { ${sizeManifest.encoder.render} }` : "";
-        const decoderOptions = sizeManifest.decoder.render ? `, { ${sizeManifest.decoder.render} }` : "";
-        childManifest.encoder.mergeImportsWith(sizeManifest.encoder).mapRender((r) => `getSetEncoder(${r + encoderOptions})`).addImports("solanaCodecsDataStructures", "getSetEncoder");
-        childManifest.decoder.mergeImportsWith(sizeManifest.decoder).mapRender((r) => `getSetDecoder(${r + decoderOptions})`).addImports("solanaCodecsDataStructures", "getSetDecoder");
-        return childManifest;
+        const encoderOptions = sizeManifest.encoder ? fragment`, { ${sizeManifest.encoder} }` : "";
+        const decoderOptions = sizeManifest.decoder ? fragment`, { ${sizeManifest.decoder} }` : "";
+        return typeManifest({
+          ...childManifest,
+          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 mergeManifests(
-          node.items.map((v) => visit5(v, self)),
+        return mergeTypeManifests(
+          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);
-        manifest.encoder.mapRender((r) => `addEncoderSizePrefix(${r}, ${prefix.encoder.render})`).mergeImportsWith(prefix.encoder).addImports("solanaCodecsCore", "addEncoderSizePrefix");
-        manifest.decoder.mapRender((r) => `addDecoderSizePrefix(${r}, ${prefix.decoder.render})`).mergeImportsWith(prefix.decoder).addImports("solanaCodecsCore", "addDecoderSizePrefix");
-        return manifest;
+        const manifest = visit8(node.type, self);
+        const prefix = visit8(node.prefix, self);
+        return typeManifest({
+          ...manifest,
+          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 lamportsType = "Lamports";
-        const lamportsImport = new ImportMap().add("solanaRpcTypes", "type Lamports");
-        return {
+        const numberManifest = visit8(number, self);
+        return typeManifest({
           ...numberManifest,
-          decoder: numberManifest.decoder.mapRender((r) => `getLamportsDecoder(${r})`).addImports("solanaRpcTypes", "getLamportsDecoder"),
-          encoder: numberManifest.encoder.mapRender((r) => `getLamportsEncoder(${r})`).addImports("solanaRpcTypes", "getLamportsEncoder"),
-          looseType: fragment(lamportsType, lamportsImport),
-          strictType: fragment(lamportsType, lamportsImport)
-        };
+          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 manifest = typeManifest();
-        manifest.value = visit5(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
-        return manifest;
+        const innerValue = visit8(node.value, self).value;
+        return typeManifest({
+          value: fragment`${use("some", "solanaOptions")}(${innerValue})`
+        });
       },
       visitStringType(stringType) {
         const [encoder, decoder] = (() => {
@@ -2365,57 +2954,63 @@ function getTypeManifestVisitor(input) {
               throw new Error(`Unsupported string encoding: ${stringType.encoding}`);
           }
         })();
-        return {
-          decoder: fragment(`${decoder}()`).addImports("solanaCodecsStrings", decoder),
-          encoder: fragment(`${encoder}()`).addImports("solanaCodecsStrings", encoder),
-          isEnum: false,
-          looseType: fragment("string"),
-          strictType: fragment("string"),
-          value: fragment("")
-        };
+        return typeManifest({
+          decoder: fragment`${use(decoder, "solanaCodecsStrings")}()`,
+          encoder: fragment`${use(encoder, "solanaCodecsStrings")}()`,
+          looseType: fragment`string`,
+          strictType: fragment`string`
+        });
       },
       visitStringValue(node) {
-        const manifest = typeManifest();
-        manifest.value.setRender(JSON.stringify(node.string));
-        return manifest;
+        return typeManifest({
+          value: fragment`${JSON.stringify(node.string)}`
+        });
       },
       visitStructFieldType(structFieldType, { self }) {
-        const name = camelCase10(structFieldType.name);
-        const childManifest = visit5(structFieldType.type, self);
-        const structFieldDocs = parseDocs2(structFieldType.docs);
-        const docblock = structFieldDocs.length > 0 ? `
-${jsDocblock(structFieldDocs)}` : "";
-        const originalLooseType = childManifest.looseType.render;
-        childManifest.strictType.mapRender((r) => `${docblock}${name}: ${r}; `);
-        childManifest.looseType.mapRender((r) => `${docblock}${name}: ${r}; `);
-        childManifest.encoder.mapRender((r) => `['${name}', ${r}]`);
-        childManifest.decoder.mapRender((r) => `['${name}', ${r}]`);
+        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: 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;
         }
         if (structFieldType.defaultValueStrategy !== "omitted") {
-          childManifest.looseType.setRender(`${docblock}${name}?: ${originalLooseType}; `);
-          return childManifest;
+          return typeManifest({
+            ...childManifest,
+            looseType: fragment`${docs}${name}?: ${originalChildManifest.looseType}; `
+          });
         }
-        childManifest.looseType = fragment("");
-        return childManifest;
+        return typeManifest({ ...childManifest, looseType: fragment`` });
       },
       visitStructFieldValue(node, { self }) {
-        const manifest = typeManifest();
-        manifest.value = visit5(node.value, self).value.mapRender((r) => `${node.name}: ${r}`);
-        return manifest;
+        const innerValue = visit8(node.value, self).value;
+        return typeManifest({
+          value: fragment`${node.name}: ${innerValue}`
+        });
       },
       visitStructType(structType, { self }) {
         const optionalFields = structType.fields.filter((f) => !!f.defaultValue);
-        const mergedManifest = mergeManifests(
-          structType.fields.map((field) => visit5(field, self)),
-          {
-            mergeCodecs: (renders) => `([${renders.join(", ")}])`,
-            mergeTypes: (renders) => `{ ${renders.join("")} }`
-          }
+        const mergedManifest = pipe15(
+          mergeTypeManifests(
+            structType.fields.map((field) => visit8(field, self)),
+            {
+              mergeCodecs: (renders) => `([${renders.join(", ")}])`,
+              mergeTypes: (renders) => `{ ${renders.join("")} }`
+            }
+          ),
+          (manifest) => typeManifest({
+            ...manifest,
+            decoder: fragment`${use("getStructDecoder", "solanaCodecsDataStructures")}${manifest.decoder}`,
+            encoder: fragment`${use("getStructEncoder", "solanaCodecsDataStructures")}${manifest.encoder}`
+          })
         );
-        mergedManifest.encoder.mapRender((r) => `getStructEncoder${r}`).addImports("solanaCodecsDataStructures", "getStructEncoder");
-        mergedManifest.decoder.mapRender((r) => `getStructDecoder${r}`).addImports("solanaCodecsDataStructures", "getStructDecoder");
         if (optionalFields.length === 0) {
           return mergedManifest;
         }
@@ -2425,63 +3020,75 @@ ${jsDocblock(structFieldDocs)}` : "";
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
         const fieldDiscriminators = discriminators.filter(isNodeFilter6("fieldDiscriminatorNode"));
-        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 { render: renderedValue, imports } = visit5(defaultValue, self).value;
-          mergedManifest.encoder.mergeImportsWith(imports);
-          return f.defaultValueStrategy === "omitted" ? `${key}: ${renderedValue}` : `${key}: value.${key} ?? ${renderedValue}`;
-        }).join(", ");
-        mergedManifest.encoder.mapRender((r) => `transformEncoder(${r}, (value) => ({ ...value, ${defaultValues} }))`).addImports("solanaCodecsCore", "transformEncoder");
-        return mergedManifest;
+        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: fragment`${use("transformEncoder", "solanaCodecsCore")}(${mergedManifest.encoder}, (value) => ({ ...value, ${defaultValues} }))`
+        });
       },
       visitStructValue(node, { self }) {
-        return mergeManifests(
-          node.fields.map((field) => visit5(field, self)),
+        return mergeTypeManifests(
+          node.fields.map((field) => visit8(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visit5(item, self));
-        const mergedManifest = mergeManifests(items, {
+        const items = tupleType.items.map((item) => visit8(item, self));
+        const mergedManifest = mergeTypeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
         });
-        mergedManifest.encoder.mapRender((render2) => `getTupleEncoder(${render2})`).addImports("solanaCodecsDataStructures", "getTupleEncoder");
-        mergedManifest.decoder.mapRender((render2) => `getTupleDecoder(${render2})`).addImports("solanaCodecsDataStructures", "getTupleDecoder");
-        return mergedManifest;
+        return typeManifest({
+          ...mergedManifest,
+          decoder: fragment`${use("getTupleDecoder", "solanaCodecsDataStructures")}(${mergedManifest.decoder})`,
+          encoder: fragment`${use("getTupleEncoder", "solanaCodecsDataStructures")}(${mergedManifest.encoder})`
+        });
       },
       visitTupleValue(node, { self }) {
-        return mergeManifests(
-          node.items.map((v) => visit5(v, self)),
+        return mergeTypeManifests(
+          node.items.map((v) => visit8(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = visit5(node.item, self);
-        childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
-        childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
-        const encoderOptions = ["prefix: null"];
-        const decoderOptions = ["prefix: null"];
+        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);
-          childManifest.encoder.mergeImportsWith(zeroValueManifest.value);
-          childManifest.decoder.mergeImportsWith(zeroValueManifest.value);
-          encoderOptions.push(`noneValue: ${zeroValueManifest.value.render}`);
-          decoderOptions.push(`noneValue: ${zeroValueManifest.value.render}`);
+          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(", ")} }` : "";
-        childManifest.encoder.mapRender((r) => `getOptionEncoder(${r + encoderOptionsAsString})`).addImports("solanaOptions", "getOptionEncoder");
-        childManifest.decoder.mapRender((r) => `getOptionDecoder(${r + decoderOptionsAsString})`).addImports("solanaOptions", "getOptionDecoder");
-        return childManifest;
+        const encoderOptionsFragment = mergeFragments(
+          encoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        const decoderOptionsFragment = mergeFragments(
+          decoderOptions,
+          (cs) => cs.length > 0 ? `, { ${cs.join(", ")} }` : ""
+        );
+        return typeManifest({
+          ...childManifest,
+          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}>`
+        });
       }
     }),
     (visitor) => recordNodeStackVisitor(visitor, stack)
@@ -2490,290 +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);
-  prefixManifest.encoder.mapRender((r) => `size: ${r}`);
-  prefixManifest.decoder.mapRender((r) => `size: ${r}`);
-  return prefixManifest;
-}
-
-// 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
+  const prefixManifest = visit8(count.prefix, visitor);
+  return {
+    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(join3("pages", template), context, renderOptions);
+  const asPage = (fragment2, dependencyMap = {}) => {
+    if (!fragment2) return void 0;
+    return getPageFragment(fragment2, {
+      ...renderScope,
+      dependencyMap: { ...renderScope.dependencyMap, ...dependencyMap }
+    });
   };
-  return pipe2(
-    staticVisitor2(() => new 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 new RenderMap().add(
-          `accounts/${camelCase12(node.name)}.ts`,
-          render2("accountsPage.njk", {
-            accountDiscriminatorConstantsFragment,
-            accountFetchHelpersFragment,
-            accountPdaHelpersFragment,
-            accountSizeHelpersFragment,
-            accountTypeFragment,
-            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 new RenderMap().add(
-          `types/${camelCase12(node.name)}.ts`,
-          render2("definedTypesPage.njk", {
-            imports: imports.toString({
-              ...dependencyMap,
-              generatedTypes: "."
-            }),
-            typeDiscriminatedUnionHelpersFragment,
-            typeWithCodecFragment
+        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 new RenderMap().add(
-          `instructions/${camelCase12(node.name)}.ts`,
-          render2("instructionsPage.njk", {
-            imports: imports.toString(dependencyMap, useGranularImports),
-            instruction: node,
-            instructionDataFragment,
-            instructionDiscriminatorConstantsFragment,
-            instructionExtraArgsFragment,
-            instructionFunctionAsyncFragment,
-            instructionFunctionSyncFragment,
-            instructionParseFunctionFragment,
-            instructionTypeFragment
-          })
+        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("Account must be visited inside a program.");
-        }
-        const scope = { ...globalScope, pdaPath };
-        const pdaFunctionFragment = getPdaFunctionFragment(scope);
-        const imports = new ImportMap().mergeWith(pdaFunctionFragment);
-        return new RenderMap().add(
-          `pdas/${camelCase12(node.name)}.ts`,
-          render2("pdasPage.njk", {
-            imports: imports.toString(dependencyMap, useGranularImports),
-            pdaFunctionFragment
-          })
+        return createRenderMap(
+          `pdas/${camelCase14(node.name)}.ts`,
+          asPage(getPdaPageFragment({ ...renderScope, pdaPath: stack.getPath("pdaNode") }))
         );
       },
       visitProgram(node, { self }) {
@@ -2781,36 +3197,20 @@ function getRenderMapVisitor(options = {}) {
           ...getDefinedTypeNodesToExtract(node.accounts, customAccountData),
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
         ];
-        const scope = { ...globalScope, programNode: node };
-        const renderMap = new RenderMap().mergeWith(...node.pdas.map((p) => visit6(p, self))).mergeWith(...node.accounts.map((a) => visit6(a, self))).mergeWith(...node.definedTypes.map((t) => visit6(t, self))).mergeWith(...customDataDefinedType.map((t) => visit6(t, self)));
-        if (node.errors.length > 0) {
-          const programErrorsFragment = getProgramErrorsFragment(scope);
-          renderMap.add(
-            `errors/${camelCase12(node.name)}.ts`,
-            render2("errorsPage.njk", {
-              imports: new ImportMap().mergeWith(programErrorsFragment).toString(dependencyMap, useGranularImports),
-              programErrorsFragment
-            })
-          );
-        }
-        const programFragment = getProgramFragment(scope);
-        const programAccountsFragment = getProgramAccountsFragment(scope);
-        const programInstructionsFragment = getProgramInstructionsFragment(scope);
-        renderMap.add(
-          `programs/${camelCase12(node.name)}.ts`,
-          render2("programsPage.njk", {
-            imports: new ImportMap().mergeWith(programFragment, programAccountsFragment, programInstructionsFragment).toString(dependencyMap, useGranularImports),
-            programAccountsFragment,
-            programFragment,
-            programInstructionsFragment
-          })
-        );
-        renderMap.mergeWith(
-          ...getAllInstructionsWithSubs2(node, {
-            leavesOnly: !renderParentInstructions
-          }).map((ix) => visit6(ix, self))
-        );
-        return renderMap;
+        const scope = { ...renderScope, programNode: node };
+        return mergeRenderMaps([
+          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 }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
@@ -2819,88 +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
         };
-        const map = new RenderMap();
-        if (hasAnythingToExport) {
-          map.add(
-            "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) {
-          map.add("programs/index.ts", render2("programsIndex.njk", ctx));
-        }
-        if (programsWithErrorsToExport.length > 0) {
-          map.add("errors/index.ts", render2("errorsIndex.njk", ctx));
-        }
-        if (accountsToExport.length > 0) {
-          map.add("accounts/index.ts", render2("accountsIndex.njk", ctx));
-        }
-        if (pdasToExport.length > 0) {
-          map.add("pdas/index.ts", render2("pdasIndex.njk", ctx));
-        }
-        if (instructionsToExport.length > 0) {
-          map.add("instructions/index.ts", render2("instructionsIndex.njk", ctx));
-        }
-        if (definedTypesToExport.length > 0) {
-          map.add("types/index.ts", render2("definedTypesIndex.njk", ctx));
-        }
-        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...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
-import { deleteDirectory } from "@codama/renderers-core";
-import { rootNodeVisitor, visit as visit7 } from "@codama/visitors-core";
+// src/visitors/renderVisitor.ts
+import { deleteDirectory, mapRenderMapContentAsync, writeRenderMap } from "@codama/renderers-core";
+import { rootNodeVisitor, visit as visit10 } from "@codama/visitors-core";
 import * as estreePlugin from "prettier/plugins/estree";
 import * as typeScriptPlugin from "prettier/plugins/typescript";
 import { format } from "prettier/standalone";
@@ -2920,22 +3273,27 @@ function renderVisitor(path, options = {}) {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    const renderMap = visit7(root, getRenderMapVisitor(options));
+    let renderMap = visit10(root, getRenderMapVisitor(options));
     if (options.formatCode ?? true) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      await renderMap.mapContentAsync((code) => format(code, prettierOptions));
+      renderMap = await mapRenderMapContentAsync(renderMap, (code) => format(code, prettierOptions));
     }
-    renderMap.write(path);
+    writeRenderMap(renderMap, path);
   });
 }
 export {
   DEFAULT_NAME_TRANSFORMERS,
-  ImportMap,
+  addToImportMap,
+  createImportMap,
   renderVisitor as default,
   getNameApi,
   getRenderMapVisitor,
   getTypeManifestVisitor,
-  mergeManifests,
+  importMapToString,
+  mergeImportMaps,
+  mergeTypeManifests,
+  parseImportInput,
+  removeFromImportMap,
   renderVisitor,
   typeManifest
 };