@codama/renderers-js 1.3.3 → 1.3.5

package/dist/index.node.mjs

@@ -131,12 +131,6 @@ var ImportMap = class {
   }
 };
 
-// src/fragments/accountFetchHelpers.ts
-import { getLastNodeFromPath } from "@codama/visitors-core";
-
-// src/fragments/common.ts
-import { join as join2 } from "path";
-
 // src/utils/async.ts
 import {
   accountValueNode,
@@ -269,6 +263,74 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
   ];
 });
 
+// src/utils/fragment.ts
+import { joinPath } from "@codama/renderers-core";
+
+// src/utils/render.ts
+import { dirname as pathDirname, join } from "path";
+import { fileURLToPath } from "url";
+import { camelCase as camelCase2, kebabCase, pascalCase, snakeCase, titleCase } from "@codama/nodes";
+import nunjucks from "nunjucks";
+function jsDocblock(docs) {
+  if (docs.length <= 0) return "";
+  if (docs.length === 1) return `/** ${docs[0]} */
+`;
+  const lines = docs.map((doc) => ` * ${doc}`);
+  return `/**
+${lines.join("\n")}
+ */
+`;
+}
+var render = (template, context, options) => {
+  const dirname = true ? pathDirname(fileURLToPath(import.meta.url)) : __dirname;
+  const templates = false ? join(dirname, "..", "..", "public", "templates") : join(dirname, "templates");
+  const env = nunjucks.configure(templates, { autoescape: false, trimBlocks: true, ...options });
+  env.addFilter("pascalCase", pascalCase);
+  env.addFilter("camelCase", camelCase2);
+  env.addFilter("snakeCase", snakeCase);
+  env.addFilter("kebabCase", kebabCase);
+  env.addFilter("titleCase", titleCase);
+  env.addFilter("jsDocblock", jsDocblock);
+  return env.render(template, context);
+};
+
+// src/utils/fragment.ts
+function fragment(content) {
+  return Object.freeze({
+    content,
+    features: /* @__PURE__ */ new Set(),
+    imports: new ImportMap()
+  });
+}
+function fragmentFromTemplate(fragmentFile, context, options) {
+  return fragment(render(joinPath("fragments", fragmentFile), context, options));
+}
+function mergeFragments(fragments, mergeContent) {
+  return Object.freeze({
+    content: mergeContent(fragments.map((fragment2) => fragment2.content)),
+    features: new Set(fragments.flatMap((f) => [...f.features])),
+    imports: new ImportMap().mergeWith(...fragments.map((f) => f.imports))
+  });
+}
+function mergeFragmentImports(fragment2, importMaps) {
+  return Object.freeze({
+    ...fragment2,
+    imports: new ImportMap().mergeWith(fragment2.imports, ...importMaps)
+  });
+}
+function addFragmentImports(fragment2, module, imports) {
+  return Object.freeze({
+    ...fragment2,
+    imports: new ImportMap().mergeWith(fragment2.imports).add(module, imports)
+  });
+}
+function addFragmentFeatures(fragment2, features) {
+  return Object.freeze({
+    ...fragment2,
+    features: /* @__PURE__ */ new Set([...fragment2.features, ...features])
+  });
+}
+
 // src/utils/linkOverrides.ts
 import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
@@ -318,140 +380,99 @@ 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")}
- */
-`;
-}
-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);
-}
-function fragmentFromTemplate(fragmentFile, context, options) {
-  return fragment(render(join2("fragments", fragmentFile), context, options));
+// src/TypeManifest.ts
+function typeManifest(input = {}) {
+  return Object.freeze({
+    decoder: fragment(""),
+    encoder: fragment(""),
+    isEnum: false,
+    looseType: fragment(""),
+    strictType: fragment(""),
+    value: fragment(""),
+    ...input
+  });
 }
-function mergeFragments(fragments, mergeRenders) {
-  return new Fragment(
-    mergeRenders(fragments.map((f) => f.render)),
-    new ImportMap().mergeWith(...fragments),
-    new Set(fragments.flatMap((f) => [...f.features]))
-  );
+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)
+  });
 }
-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/getRenderMapVisitor.ts
+import { join as join2 } from "path";
+import { logWarn } from "@codama/errors";
+import {
+  camelCase as camelCase12,
+  definedTypeNode as definedTypeNode2,
+  getAllAccounts,
+  getAllDefinedTypes,
+  getAllInstructionsWithSubs as getAllInstructionsWithSubs2,
+  getAllPdas,
+  getAllPrograms,
+  resolveNestedTypeNode as resolveNestedTypeNode4,
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes5
+} from "@codama/nodes";
+import { addToRenderMap, mergeRenderMaps, renderMap } from "@codama/renderers-core";
+import {
+  extendVisitor as extendVisitor2,
+  findProgramNodeFromPath as findProgramNodeFromPath7,
+  getByteSizeVisitor,
+  getResolvedInstructionInputsVisitor,
+  LinkableDictionary as LinkableDictionary3,
+  NodeStack as NodeStack2,
+  pipe as pipe25,
+  recordLinkablesOnFirstVisitVisitor,
+  recordNodeStackVisitor as recordNodeStackVisitor2,
+  staticVisitor as staticVisitor2,
+  visit as visit6
+} from "@codama/visitors-core";
 
 // src/fragments/accountFetchHelpers.ts
+import { getLastNodeFromPath, pipe } from "@codama/visitors-core";
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
   const accountNode = getLastNodeFromPath(accountPath);
   const 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"
-  ]);
+  const accountTypeFragment = hasCustomData ? typeManifest2.strictType : fragment(nameApi.dataType(accountNode.name));
+  const decoderFunctionFragment = hasCustomData ? typeManifest2.decoder : fragment(`${nameApi.decoderFunction(accountNode.name)}()`);
+  return pipe(
+    fragmentFromTemplate("accountFetchHelpers.njk", {
+      accountType: accountTypeFragment.content,
+      decodeFunction: nameApi.accountDecodeFunction(accountNode.name),
+      decoderFunction: decoderFunctionFragment.content,
+      fetchAllFunction: nameApi.accountFetchAllFunction(accountNode.name),
+      fetchAllMaybeFunction: nameApi.accountFetchAllMaybeFunction(accountNode.name),
+      fetchFunction: nameApi.accountFetchFunction(accountNode.name),
+      fetchMaybeFunction: nameApi.accountFetchMaybeFunction(accountNode.name)
+    }),
+    (f) => mergeFragmentImports(f, [accountTypeFragment.imports, decoderFunctionFragment.imports]),
+    (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/accountPdaHelpers.ts
 import { isNodeFilter } from "@codama/nodes";
-import { findProgramNodeFromPath, getLastNodeFromPath as getLastNodeFromPath2 } from "@codama/visitors-core";
+import { findProgramNodeFromPath, 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);
@@ -460,27 +481,33 @@ function getAccountPdaHelpersFragment(scope) {
   if (!pdaNode) {
     return fragment("");
   }
-  const accountTypeFragment = customAccountData.has(accountNode.name) ? typeManifest2.strictType.clone() : fragment(nameApi.dataType(accountNode.name));
+  const accountTypeFragment = customAccountData.has(accountNode.name) ? typeManifest2.strictType : fragment(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"
-  ]);
+  return pipe2(
+    fragmentFromTemplate("accountPdaHelpers.njk", {
+      accountType: accountTypeFragment.content,
+      fetchFromSeedsFunction: nameApi.accountFetchFromSeedsFunction(accountNode.name),
+      fetchFunction: nameApi.accountFetchFunction(accountNode.name),
+      fetchMaybeFromSeedsFunction: nameApi.accountFetchMaybeFromSeedsFunction(accountNode.name),
+      fetchMaybeFunction: nameApi.accountFetchMaybeFunction(accountNode.name),
+      findPdaFunction,
+      hasVariableSeeds,
+      pdaSeedsType,
+      program: programNode
+    }),
+    (f) => mergeFragmentImports(f, [accountTypeFragment.imports]),
+    (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
@@ -502,52 +529,65 @@ import { resolveNestedTypeNode } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath4 } from "@codama/visitors-core";
 
 // src/fragments/type.ts
+import { pipe as pipe3 } from "@codama/visitors-core";
 function getTypeFragment(scope) {
   const { name, manifest, nameApi, docs = [] } = scope;
-  const typeFragment = fragmentFromTemplate("type.njk", {
-    docs,
-    looseName: nameApi.dataArgsType(name),
-    manifest,
-    strictName: nameApi.dataType(name)
-  });
-  if (!manifest.isEnum) {
-    typeFragment.mergeImportsWith(manifest.strictType, manifest.looseType);
-  }
-  return typeFragment;
+  return pipe3(
+    fragmentFromTemplate("type.njk", {
+      docs,
+      looseName: nameApi.dataArgsType(name),
+      manifest,
+      strictName: nameApi.dataType(name)
+    }),
+    (f) => !manifest.isEnum ? mergeFragmentImports(f, [manifest.strictType.imports, manifest.looseType.imports]) : f
+  );
 }
 
+// src/fragments/typeCodec.ts
+import { pipe as pipe6 } from "@codama/visitors-core";
+
 // src/fragments/typeDecoder.ts
 import { isDataEnum, isNode as isNode3 } from "@codama/nodes";
+import { pipe as pipe4 } from "@codama/visitors-core";
 function getTypeDecoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const decoderType = typeof scope.size === "number" ? "FixedSizeDecoder" : "Decoder";
   const useTypeCast = isNode3(node, "enumTypeNode") && isDataEnum(node) && typeof scope.size === "number";
-  return 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}`);
+  return pipe4(
+    fragmentFromTemplate("typeDecoder.njk", {
+      decoderFunction: nameApi.decoderFunction(name),
+      decoderType,
+      docs,
+      looseName: nameApi.dataArgsType(name),
+      manifest,
+      strictName: nameApi.dataType(name),
+      useTypeCast
+    }),
+    (f) => mergeFragmentImports(f, [manifest.decoder.imports]),
+    (f) => addFragmentImports(f, "solanaCodecsCore", [`type ${decoderType}`])
+  );
 }
 
 // src/fragments/typeEncoder.ts
 import { isDataEnum as isDataEnum2, isNode as isNode4 } from "@codama/nodes";
+import { pipe as pipe5 } from "@codama/visitors-core";
 function getTypeEncoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const encoderType = typeof scope.size === "number" ? "FixedSizeEncoder" : "Encoder";
   const useTypeCast = isNode4(node, "enumTypeNode") && isDataEnum2(node) && typeof scope.size === "number";
-  return 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}`);
+  return pipe5(
+    fragmentFromTemplate("typeEncoder.njk", {
+      docs,
+      encoderFunction: nameApi.encoderFunction(name),
+      encoderType,
+      looseName: nameApi.dataArgsType(name),
+      manifest,
+      strictName: nameApi.dataType(name),
+      useTypeCast
+    }),
+    (f) => mergeFragmentImports(f, [manifest.encoder.imports]),
+    (f) => addFragmentImports(f, "solanaCodecsCore", [`type ${encoderType}`])
+  );
 }
 
 // src/fragments/typeCodec.ts
@@ -558,16 +598,19 @@ function getTypeCodecFragment(scope) {
     [
       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"])
+      pipe6(
+        fragmentFromTemplate("typeCodec.njk", {
+          codecFunction: nameApi.codecFunction(name),
+          codecType,
+          decoderFunction: nameApi.decoderFunction(name),
+          docs: scope.codecDocs,
+          encoderFunction: nameApi.encoderFunction(name),
+          looseName: nameApi.dataArgsType(name),
+          manifest,
+          strictName: nameApi.dataType(name)
+        }),
+        (f) => addFragmentImports(f, "solanaCodecsCore", [`type ${codecType}`, "combineCodec"])
+      )
     ],
     (renders) => renders.join("\n\n")
   );
@@ -605,24 +648,28 @@ import {
   isNode as isNode5,
   isNodeFilter as isNodeFilter2
 } from "@codama/nodes";
-import { visit } from "@codama/visitors-core";
+import { mapFragmentContent } from "@codama/renderers-core";
+import { pipe as pipe7, visit } 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 pipe7(
+    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 [];
+      }),
+      (c) => c.join(" && ")
+    ),
+    (f) => mapFragmentContent(f, (c) => `if (${c}) { ${scope.ifTrue}; }`)
+  );
 }
 function getSizeConditionFragment(discriminator, scope) {
   const { dataName } = scope;
@@ -631,7 +678,11 @@ function getSizeConditionFragment(discriminator, scope) {
 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");
+  return pipe7(
+    constant,
+    (f) => mapFragmentContent(f, (c) => `containsBytes(${dataName}, ${c}, ${discriminator.offset})`),
+    (f) => addFragmentImports(f, "solanaCodecsCore", ["containsBytes"])
+  );
 }
 function getFieldConditionFragment(discriminator, scope) {
   const field = scope.struct.fields.find((f) => f.name === discriminator.name);
@@ -657,18 +708,33 @@ function getFieldConditionFragment(discriminator, scope) {
 
 // src/fragments/instructionAccountMeta.ts
 import { pascalCase as pascalCase2 } from "@codama/nodes";
+import { pipe as pipe8 } from "@codama/visitors-core";
 function getInstructionAccountMetaFragment(instructionAccountNode) {
   const typeParam = `TAccount${pascalCase2(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
-    return fragment(`WritableSignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type WritableSignerAccount"]).addImports("solanaSigners", ["type AccountSignerMeta"]);
+    return pipe8(
+      fragment(`WritableSignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaInstructions", ["type WritableSignerAccount"]),
+      (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta"])
+    );
   }
   if (instructionAccountNode.isSigner === true) {
-    return fragment(`ReadonlySignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type ReadonlySignerAccount"]).addImports("solanaSigners", ["type AccountSignerMeta"]);
+    return pipe8(
+      fragment(`ReadonlySignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaInstructions", ["type ReadonlySignerAccount"]),
+      (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta"])
+    );
   }
   if (instructionAccountNode.isWritable) {
-    return fragment(`WritableAccount<${typeParam}>`).addImports("solanaInstructions", "type WritableAccount");
+    return pipe8(
+      fragment(`WritableAccount<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaInstructions", ["type WritableAccount"])
+    );
   }
-  return fragment(`ReadonlyAccount<${typeParam}>`).addImports("solanaInstructions", "type ReadonlyAccount");
+  return pipe8(
+    fragment(`ReadonlyAccount<${typeParam}>`),
+    (f) => addFragmentImports(f, "solanaInstructions", ["type ReadonlyAccount"])
+  );
 }
 
 // src/fragments/instructionAccountTypeParam.ts
@@ -676,7 +742,8 @@ import { pascalCase as pascalCase3 } from "@codama/nodes";
 import {
   findInstructionNodeFromPath,
   findProgramNodeFromPath as findProgramNodeFromPath2,
-  getLastNodeFromPath as getLastNodeFromPath5
+  getLastNodeFromPath as getLastNodeFromPath5,
+  pipe as pipe9
 } from "@codama/visitors-core";
 function getInstructionAccountTypeParamFragment(scope) {
   const { instructionAccountPath, allowAccountMeta, linkables } = scope;
@@ -690,10 +757,16 @@ function getInstructionAccountTypeParamFragment(scope) {
     imports.add("solanaInstructions", "type AccountMeta");
   }
   if (instructionNode.optionalAccountStrategy === "omitted" && instructionAccountNode.isOptional) {
-    return fragment(`${typeParam} extends string${accountMeta} | undefined = undefined`, imports);
+    return pipe9(
+      fragment(`${typeParam} extends string${accountMeta} | undefined = undefined`),
+      (f) => mergeFragmentImports(f, [imports])
+    );
   }
   const defaultAddress = getDefaultAddress(instructionAccountNode.defaultValue, programNode.publicKey, linkables);
-  return fragment(`${typeParam} extends string${accountMeta} = ${defaultAddress}`, imports);
+  return pipe9(
+    fragment(`${typeParam} extends string${accountMeta} = ${defaultAddress}`),
+    (f) => mergeFragmentImports(f, [imports])
+  );
 }
 function getDefaultAddress(defaultValue, programId, linkables) {
   switch (defaultValue?.kind) {
@@ -711,19 +784,20 @@ 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 { mapFragmentContent as mapFragmentContent2 } from "@codama/renderers-core";
+import { getLastNodeFromPath as getLastNodeFromPath6, pipe as pipe10 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
   const { byteDeltas } = getLastNodeFromPath6(scope.instructionPath);
-  const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
+  const fragments = (byteDeltas ?? []).flatMap((c) => getByteDeltaFragment(c, scope));
   if (fragments.length === 0) return fragment("");
   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 = (() => {
+  let bytesFragment = (() => {
     if (isNode6(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
@@ -740,10 +814,14 @@ function getByteDeltaFragment(byteDelta, scope) {
   })();
   if (bytesFragment === null) return [];
   if (byteDelta.withHeader) {
-    bytesFragment.mapRender((r) => `${r} + BASE_ACCOUNT_SIZE`).addImports("solanaAccounts", "BASE_ACCOUNT_SIZE");
+    bytesFragment = pipe10(
+      bytesFragment,
+      (f) => mapFragmentContent2(f, (c) => `${c} + BASE_ACCOUNT_SIZE`),
+      (f) => addFragmentImports(f, "solanaAccounts", ["BASE_ACCOUNT_SIZE"])
+    );
   }
   if (byteDelta.subtract) {
-    bytesFragment.mapRender((r) => `- (${r})`);
+    bytesFragment = pipe10(bytesFragment, (f) => mapFragmentContent2(f, (c) => `- (${c})`));
   }
   return [bytesFragment];
 }
@@ -759,7 +837,8 @@ function getArgumentValueNodeFragment(byteDelta) {
 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 module = scope.getImportFrom(byteDelta.value);
+  return pipe10(fragment(`${functionName}()`), (f) => addFragmentImports(f, module, [functionName]));
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
   assertIsNode(byteDelta.value, "resolverValueNode");
@@ -767,7 +846,12 @@ function getResolverValueNodeFragment(byteDelta, scope) {
   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 module = scope.getImportFrom(byteDelta.value);
+  return pipe10(
+    fragment(`${awaitKeyword}${functionName}(resolverScope)`),
+    (f) => addFragmentImports(f, module, [functionName]),
+    (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+  );
 }
 
 // src/fragments/instructionData.ts
@@ -796,10 +880,11 @@ import {
   isNodeFilter as isNodeFilter3,
   VALUE_NODES
 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent3 } from "@codama/renderers-core";
 import { visit as visit2 } from "@codama/visitors-core";
 function getDiscriminatorConstantsFragment(scope) {
   const fragments = scope.discriminatorNodes.map((node) => getDiscriminatorConstantFragment(node, scope)).filter(Boolean);
-  return mergeFragments(fragments, (r) => r.join("\n\n"));
+  return mergeFragments(fragments, (c) => c.join("\n\n"));
 }
 function getDiscriminatorConstantFragment(discriminatorNode, scope) {
   switch (discriminatorNode.kind) {
@@ -837,15 +922,18 @@ function getConstantFragment(scope) {
   const constantFunction = nameApi.constantFunction(name);
   return mergeFragments(
     [
-      value.mapRender((r) => `export const ${constantName} = ${r};`),
-      encoder.mapRender((r) => `export function ${constantFunction}() { return ${r}.encode(${constantName}); }`)
+      mapFragmentContent3(value, (c) => `export const ${constantName} = ${c};`),
+      mapFragmentContent3(
+        encoder,
+        (c) => `export function ${constantFunction}() { return ${c}.encode(${constantName}); }`
+      )
     ],
-    (r) => r.join("\n\n")
+    (c) => c.join("\n\n")
   );
 }
 
 // src/fragments/instructionExtraArgs.ts
-import { getLastNodeFromPath as getLastNodeFromPath8 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath8, pipe as pipe11 } from "@codama/visitors-core";
 function getInstructionExtraArgsFragment(scope) {
   const { instructionPath, extraArgsManifest, nameApi } = scope;
   const instructionNode = getLastNodeFromPath8(instructionPath);
@@ -853,27 +941,34 @@ function getInstructionExtraArgsFragment(scope) {
     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);
+  return pipe11(
+    fragmentFromTemplate("instructionExtraArgs.njk", {
+      looseName: nameApi.dataArgsType(instructionExtraName),
+      manifest: extraArgsManifest,
+      strictName: nameApi.dataType(instructionExtraName)
+    }),
+    (f) => mergeFragmentImports(f, [extraArgsManifest.looseType.imports])
+  );
 }
 
 // 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 getLastNodeFromPath12
+  getLastNodeFromPath as getLastNodeFromPath12,
+  pipe as pipe15
 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputResolved.ts
 import { camelCase as camelCase6, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent5 } from "@codama/renderers-core";
 import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputDefault.ts
 import { camelCase as camelCase5, isNode as isNode8 } from "@codama/nodes";
-import { visit as visit3 } from "@codama/visitors-core";
+import { mapFragmentContent as mapFragmentContent4, setFragmentContent } from "@codama/renderers-core";
+import { pipe as pipe12, visit as visit3 } from "@codama/visitors-core";
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
   if (!input.defaultValue) {
@@ -903,33 +998,48 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
     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 pipe12(
+          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 pipe12(
+          defaultFragment(`expectSome(accounts.${name}.value)`),
+          (f) => addFragmentImports(f, "shared", ["expectSome"])
+        );
       }
-      return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
+      return pipe12(
+        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 ? pipe12(
+          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")
+              pipe12(
+                fragment(`getAddressEncoder().encode(${pdaProgram.content})`),
+                (f) => mergeFragmentImports(f, [pdaProgram.imports]),
+                (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)
+              pipe12(
+                fragment(`${typeManifest2.encoder.content}.encode(${valueManifest2.value.content})`),
+                (f) => mergeFragmentImports(f, [
+                  typeManifest2.encoder.imports,
+                  valueManifest2.value.imports
+                ])
+              )
             ];
           }
           if (isNode8(seed, "variablePdaSeedNode")) {
@@ -938,62 +1048,92 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
             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")
+                pipe12(
+                  fragment(
+                    `${typeManifest2.encoder.content}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`
+                  ),
+                  (f) => mergeFragmentImports(f, [typeManifest2.encoder.imports]),
+                  (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")
+                pipe12(
+                  fragment(
+                    `${typeManifest2.encoder.content}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`
+                  ),
+                  (f) => mergeFragmentImports(f, [typeManifest2.encoder.imports]),
+                  (f) => addFragmentImports(f, "shared", ["expectSome"])
+                )
               ];
             }
             const valueManifest2 = visit3(valueSeed, typeManifestVisitor);
             return [
-              fragment(
-                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
-              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
+              pipe12(
+                fragment(`${typeManifest2.encoder.content}.encode(${valueManifest2.value.content})`),
+                (f) => mergeFragmentImports(f, [
+                  typeManifest2.encoder.imports,
+                  valueManifest2.value.imports
+                ])
+              )
             ];
           }
           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 pipe12(
+          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 pipe12(
+            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 pipe12(
+            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 pipe12(
+          visit3(seed.value, typeManifestVisitor).value,
+          (f) => mapFragmentContent4(f, (c) => `${seed.name}: ${c}`)
+        );
       });
-      const pdaSeedsFragment = mergeFragments(pdaSeeds, (renders) => renders.join(", ")).mapRender((r) => `{ ${r} }`);
+      const pdaSeedsFragment = pipe12(
+        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 pipe12(
+        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 pipe12(
+        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 pipe12(
+        defaultFragment(programAddress, false),
+        (f) => addFragmentImports(f, getImportFrom(defaultValue), [programAddress])
+      );
     case "programIdValueNode":
       if (optionalAccountStrategy === "programId" && input.kind === "instructionAccountNode" && input.isOptional) {
         return fragment("");
@@ -1003,18 +1143,23 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
     case "payerValueNode":
       return fragment("");
     case "accountBumpValueNode":
-      return defaultFragment(
-        `expectProgramDerivedAddress(accounts.${camelCase5(defaultValue.name)}.value)[1]`
-      ).addImports("shared", "expectProgramDerivedAddress");
+      return pipe12(
+        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 pipe12(
+        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 pipe12(
+        defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
+        (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
+        (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+      );
     case "conditionalValueNode":
       const ifTrueRenderer = renderNestedInstructionDefault({
         ...scope,
@@ -1027,18 +1172,23 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       if (!ifTrueRenderer && !ifFalseRenderer) {
         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 = pipe12(
+          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;
@@ -1046,30 +1196,32 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
         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);
+          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);
+      return pipe12(valueManifest, (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content));
   }
 }
 function renderNestedInstructionDefault(scope) {
@@ -1090,14 +1242,15 @@ function getInstructionInputResolvedFragment(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}
 }`
       )
     ];
@@ -1105,10 +1258,7 @@ ${r}
   if (resolvedInputFragments.length === 0) {
     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
@@ -1119,8 +1269,10 @@ import {
   parseDocs,
   pascalCase as pascalCase4
 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent6 } from "@codama/renderers-core";
 import {
-  getLastNodeFromPath as getLastNodeFromPath10
+  getLastNodeFromPath as getLastNodeFromPath10,
+  pipe as pipe13
 } from "@codama/visitors-core";
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
@@ -1130,21 +1282,25 @@ function getInstructionInputTypeFragment(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"]);
+  return pipe13(
+    fragmentFromTemplate("instructionInputType.njk", {
+      accountsFragment: accountsFragment.content,
+      customDataArgumentsFragment: customDataArgumentsFragment.content,
+      dataArgumentsFragment: dataArgumentsFragment.content,
+      extraArgumentsFragment: extraArgumentsFragment.content,
+      instruction: instructionNode,
+      instructionInputType,
+      remainingAccountsFragment: remainingAccountsFragment.content
+    }),
+    (f) => mergeFragmentImports(f, [
+      accountsFragment.imports,
+      dataArgumentsFragment.imports,
+      customDataArgumentsFragment.imports,
+      extraArgumentsFragment.imports,
+      remainingAccountsFragment.imports
+    ]),
+    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+  );
 }
 function getAccountsFragment(scope) {
   const { instructionPath, resolvedInputs, useAsync, asyncResolvers } = scope;
@@ -1157,29 +1313,42 @@ function getAccountsFragment(scope) {
     const accountDocs = parseDocs(account.docs);
     const docblock = accountDocs.length > 0 ? jsDocblock(accountDocs) : "";
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return getAccountTypeFragment2(resolvedAccount).mapRender(
-      (r) => `${docblock}${camelCase7(account.name)}${optionalSign}: ${r};`
+    return mapFragmentContent6(
+      getAccountTypeFragment2(resolvedAccount),
+      (c) => `${docblock}${camelCase7(account.name)}${optionalSign}: ${c};`
     );
   });
-  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"
-    ]);
+    return pipe13(
+      fragment(`ProgramDerivedAddress<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaAddresses", ["type ProgramDerivedAddress"])
+    );
   }
   if (account.isPda && account.isSigner === "either") {
-    return fragment(`ProgramDerivedAddress<${typeParam}> | TransactionSigner<${typeParam}>`).addImports("solanaAddresses", ["type ProgramDerivedAddress"]).addImports("solanaSigners", ["type TransactionSigner"]);
+    return pipe13(
+      fragment(`ProgramDerivedAddress<${typeParam}> | TransactionSigner<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaAddresses", ["type ProgramDerivedAddress"]),
+      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
+    );
   }
   if (account.isSigner === "either") {
-    return fragment(`Address<${typeParam}> | TransactionSigner<${typeParam}>`).addImports("solanaAddresses", ["type Address"]).addImports("solanaSigners", ["type TransactionSigner"]);
+    return pipe13(
+      fragment(`Address<${typeParam}> | TransactionSigner<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]),
+      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
+    );
   }
   if (account.isSigner) {
-    return fragment(`TransactionSigner<${typeParam}>`).addImports("solanaSigners", ["type TransactionSigner"]);
+    return pipe13(
+      fragment(`TransactionSigner<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
+    );
   }
-  return fragment(`Address<${typeParam}>`).addImports("solanaAddresses", ["type Address"]);
+  return pipe13(fragment(`Address<${typeParam}>`), (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]));
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
@@ -1188,7 +1357,11 @@ function getDataArgumentsFragments(scope) {
   if (customData) {
     return [
       fragment(""),
-      fragment(nameApi.dataArgsType(customData.importAs)).mergeImportsWith(scope.dataArgsManifest.looseType).mapRender((r) => `${r} & `)
+      pipe13(
+        fragment(nameApi.dataArgsType(customData.importAs)),
+        (f) => mergeFragmentImports(f, [scope.dataArgsManifest.looseType.imports]),
+        (f) => mapFragmentContent6(f, (c) => `${c} & `)
+      )
     ];
   }
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
@@ -1197,7 +1370,7 @@ function getDataArgumentsFragments(scope) {
     const argFragment = getArgumentFragment(arg, fragment(dataArgsType), scope.resolvedInputs, scope.renamedArgs);
     return argFragment ? [argFragment] : [];
   });
-  return [mergeFragments(fragments, (r) => r.join("\n")), fragment("")];
+  return [mergeFragments(fragments, (c) => c.join("\n")), fragment("")];
 }
 function getExtraArgumentsFragment(scope) {
   const { instructionPath, nameApi } = scope;
@@ -1208,7 +1381,7 @@ function getExtraArgumentsFragment(scope) {
     const argFragment = getArgumentFragment(arg, fragment(extraArgsType), scope.resolvedInputs, scope.renamedArgs);
     return argFragment ? [argFragment] : [];
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
@@ -1217,7 +1390,10 @@ 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 mapFragmentContent6(
+    argsType,
+    (c) => `${camelCase7(renamedName)}${optionalSign}: ${c}["${camelCase7(arg.name)}"];`
+  );
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
@@ -1228,16 +1404,25 @@ 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(" | "));
-      }
-      return isSigner ? signerFragment : addressFragment;
-    })().mapRender((r) => `${camelCase7(name)}${optionalSign}: Array<${r}>;`);
+    const signerFragment = pipe13(
+      fragment(`TransactionSigner`),
+      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
+    );
+    const addressFragment = pipe13(
+      fragment(`Address`),
+      (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+    );
+    return mapFragmentContent6(
+      (() => {
+        if (isSigner === "either") {
+          return mergeFragments([signerFragment, addressFragment], (c) => c.join(" | "));
+        }
+        return isSigner ? signerFragment : addressFragment;
+      })(),
+      (c) => `${camelCase7(name)}${optionalSign}: Array<${c}>;`
+    );
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 
 // src/fragments/instructionRemainingAccounts.ts
@@ -1247,16 +1432,19 @@ import {
   getAllInstructionArguments as getAllInstructionArguments2,
   isNode as isNode11
 } from "@codama/nodes";
-import { getLastNodeFromPath as getLastNodeFromPath11 } from "@codama/visitors-core";
+import { getLastNodeFromPath as getLastNodeFromPath11, pipe as pipe14 } from "@codama/visitors-core";
 function getInstructionRemainingAccountsFragment(scope) {
   const { remainingAccounts } = getLastNodeFromPath11(scope.instructionPath);
-  const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
+  const fragments = (remainingAccounts ?? []).flatMap((a) => getRemainingAccountsFragment2(a, 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"]);
+  return pipe14(
+    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 = (() => {
@@ -1285,22 +1473,27 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   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 pipe14(
+      fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`),
+      (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"])
     );
   }
   if (isSigner === "either") {
-    return fragment(
-      `${argumentArray}.map((addressOrSigner) => (isTransactionSigner(addressOrSigner)
+    return pipe14(
+      fragment(
+        `${argumentArray}.map((addressOrSigner) => (isTransactionSigner(addressOrSigner)
 ? { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner }
 : { address: addressOrSigner, role: ${role} }
 ))`
-    ).addImports("solanaInstructions", ["AccountRole"]).addImports("shared", ["isTransactionSigner"]);
+      ),
+      (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"]),
+      (f) => addFragmentImports(f, "shared", ["isTransactionSigner"])
+    );
   }
-  return fragment(
-    `${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`
-  ).addImports("solanaInstructions", ["AccountRole"]);
+  return pipe14(
+    fragment(`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`),
+    (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"])
+  );
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
   assertIsNode2(remainingAccounts.value, "resolverValueNode");
@@ -1308,7 +1501,12 @@ function getResolverValueNodeFragment2(remainingAccounts, scope) {
   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 module = scope.getImportFrom(remainingAccounts.value);
+  return pipe14(
+    fragment(`${awaitKeyword}${functionName}(resolverScope)`),
+    (f) => addFragmentImports(f, module, [functionName]),
+    (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+  );
 }
 
 // src/fragments/instructionFunction.ts
@@ -1350,13 +1548,11 @@ function getInstructionFunctionFragment(scope) {
   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)
+  const encoderFunction = customData ? dataArgsManifest.encoder.content : `${nameApi.encoderFunction(instructionDataName)}()`;
+  const argsTypeFragment = pipe15(
+    fragment(customData ? dataArgsManifest.looseType.content : nameApi.dataArgsType(instructionDataName)),
+    customData ? (f) => mergeFragmentImports(f, [dataArgsManifest.looseType.imports, dataArgsManifest.encoder.imports]) : (f) => f
   );
-  if (customData) {
-    argsTypeFragment.mergeImportsWith(dataArgsManifest.looseType, dataArgsManifest.encoder);
-  }
   const functionName = useAsync ? nameApi.instructionAsyncFunction(instructionNode.name) : nameApi.instructionSyncFunction(instructionNode.name);
   const typeParamsFragment = getTypeParams(instructionNode, programAddressConstant);
   const instructionTypeFragment = getInstructionType(scope);
@@ -1368,11 +1564,11 @@ function getInstructionFunctionFragment(scope) {
   const byteDeltaFragment = getInstructionByteDeltaFragment(scope);
   const resolvedFragment = 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 hasRemainingAccounts = remainingAccountsFragment.content !== "";
+  const hasByteDeltas = byteDeltaFragment.content !== "";
+  const hasResolver = resolvedFragment.features.has("instruction:resolverScopeVariable");
   const getReturnType = (instructionType) => {
     let returnType = instructionType;
     if (hasByteDeltas) {
@@ -1380,50 +1576,55 @@ function getInstructionFunctionFragment(scope) {
     }
     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"]);
-  }
-  return functionFragment;
+  return pipe15(
+    fragmentFromTemplate("instructionFunction.njk", {
+      argsTypeFragment: argsTypeFragment.content,
+      encoderFunction,
+      functionName,
+      getReturnType,
+      hasAccounts,
+      hasAnyArgs,
+      hasByteDeltas,
+      hasData,
+      hasDataArgs,
+      hasExtraArgs,
+      hasInput,
+      hasLegacyOptionalAccounts,
+      hasRemainingAccounts,
+      hasResolver,
+      inputTypeCallFragment: inputTypeCallFragment.content,
+      inputTypeFragment: inputTypeFragment.content,
+      instruction: instructionNode,
+      instructionTypeFragment: instructionTypeFragment.content,
+      programAddressConstant,
+      renamedArgs: renamedArgsText,
+      resolvedFragment: resolvedFragment.content,
+      typeParamsFragment: typeParamsFragment.content,
+      useAsync
+    }),
+    (f) => mergeFragmentImports(f, [
+      typeParamsFragment.imports,
+      instructionTypeFragment.imports,
+      inputTypeFragment.imports,
+      inputTypeCallFragment.imports,
+      resolvedFragment.imports,
+      argsTypeFragment.imports
+    ]),
+    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
+    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]),
+    (f) => hasAccounts ? addFragmentImports(f, "solanaInstructions", ["type AccountMeta"]) : f,
+    (f) => hasAccounts ? addFragmentImports(f, "shared", ["getAccountMetaFactory", "type ResolvedAccount"]) : f,
+    (f) => hasByteDeltas ? addFragmentImports(f, "shared", ["type InstructionWithByteDelta"]) : f
+  );
 }
 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]);
+  return pipe15(
+    fragment(typeParams.filter((x) => !!x).join(", ")),
+    (f) => mapFragmentContent7(f, (c) => `<${c}>`),
+    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant])
+  );
 }
 function getInstructionType(scope) {
   const { instructionPath, nameApi } = scope;
@@ -1435,16 +1636,20 @@ function getInstructionType(scope) {
     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"]);
+      return pipe15(
+        fragment(
+          `typeof input["${camelName}"] extends TransactionSigner<${typeParam}> ? ${signerRole}<${typeParam}> & AccountSignerMeta<${typeParam}> : ${typeParam}`
+        ),
+        (f) => addFragmentImports(f, "solanaInstructions", [`type ${signerRole}`]),
+        (f) => addFragmentImports(f, "solanaSigners", ["type AccountSignerMeta"])
+      );
     }
     return fragment(typeParam);
   });
-  return mergeFragments(
-    [programAddressFragment, ...accountTypeParamsFragments],
-    (renders) => renders.join(", ")
-  ).mapRender((r) => `${instructionTypeName}<${r}>`);
+  return pipe15(
+    mergeFragments([programAddressFragment, ...accountTypeParamsFragments], (c) => c.join(", ")),
+    (f) => mapFragmentContent7(f, (c) => `${instructionTypeName}<${c}>`)
+  );
 }
 function getInputTypeCall(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
@@ -1456,7 +1661,7 @@ function getInputTypeCall(scope) {
 }
 
 // src/fragments/instructionParseFunction.ts
-import { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath13 } from "@codama/visitors-core";
+import { findProgramNodeFromPath as findProgramNodeFromPath4, getLastNodeFromPath as getLastNodeFromPath13, pipe as pipe16 } from "@codama/visitors-core";
 function getInstructionParseFunctionFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
   const instructionNode = getLastNodeFromPath13(instructionPath);
@@ -1468,30 +1673,40 @@ function getInstructionParseFunctionFragment(scope) {
   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 dataTypeFragment = customData ? pipe16(
+    fragment(dataArgsManifest.strictType.content),
+    (f) => mergeFragmentImports(f, [dataArgsManifest.strictType.imports, dataArgsManifest.decoder.imports])
+  ) : fragment(nameApi.dataType(instructionDataName));
+  const decoderFunction = customData ? dataArgsManifest.decoder.content : `${nameApi.decoderFunction(instructionDataName)}()`;
+  return pipe16(
+    fragmentFromTemplate("instructionParseFunction.njk", {
+      dataTypeFragment: dataTypeFragment.content,
+      decoderFunction,
+      hasAccounts,
+      hasData,
+      hasOptionalAccounts,
+      instruction: instructionNode,
+      instructionParseFunction: nameApi.instructionParseFunction(instructionNode.name),
+      instructionParsedType: nameApi.instructionParsedType(instructionNode.name),
+      minimumNumberOfAccounts,
+      programAddressConstant
+    }),
+    (f) => mergeFragmentImports(f, [dataTypeFragment.imports]),
+    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
+    (f) => addFragmentImports(f, "solanaInstructions", ["type Instruction"]),
+    hasAccounts ? (f) => addFragmentImports(f, "solanaInstructions", ["type InstructionWithAccounts", "type AccountMeta"]) : (f) => f,
+    hasData ? (f) => addFragmentImports(
+      addFragmentImports(f, "solanaInstructions", ["type InstructionWithData"]),
+      "solanaCodecsCore",
+      ["type ReadonlyUint8Array"]
+    ) : (f) => f
   );
-  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"] : []);
 }
 
 // src/fragments/instructionType.ts
 import { pascalCase as pascalCase6 } from "@codama/nodes";
-import { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath14 } from "@codama/visitors-core";
+import { mapFragmentContent as mapFragmentContent8 } from "@codama/renderers-core";
+import { findProgramNodeFromPath as findProgramNodeFromPath5, getLastNodeFromPath as getLastNodeFromPath14, pipe as pipe17 } from "@codama/visitors-core";
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
   const instructionNode = getLastNodeFromPath14(instructionPath);
@@ -1515,37 +1730,42 @@ function getInstructionTypeFragment(scope) {
   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(", ")
+    (c) => c.join(", ")
+  );
+  const fragment2 = pipe17(
+    fragmentFromTemplate("instructionType.njk", {
+      accountMetas: accountMetasFragment.content,
+      accountTypeParams: accountTypeParamsFragment.content,
+      dataType,
+      hasAccounts,
+      hasData,
+      instruction: instructionNode,
+      instructionType: nameApi.instructionType(instructionNode.name),
+      programAddressConstant
+    }),
+    (f) => mergeFragmentImports(f, [accountTypeParamsFragment.imports, accountMetasFragment.imports]),
+    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
+    (f) => addFragmentImports(f, "solanaInstructions", [
+      "type AccountMeta",
+      "type Instruction",
+      "type InstructionWithAccounts",
+      ...hasData ? ["type InstructionWithData"] : []
+    ])
   );
-  const 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;
 }
 
 // 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 { findProgramNodeFromPath as findProgramNodeFromPath6, getLastNodeFromPath as getLastNodeFromPath15, pipe as pipe18, visit as visit4 } from "@codama/visitors-core";
 function getPdaFunctionFragment(scope) {
   const { pdaPath, typeManifestVisitor, nameApi } = scope;
   const pdaNode = getLastNodeFromPath15(pdaPath);
@@ -1568,31 +1788,46 @@ function getPdaFunctionFragment(scope) {
     return { ...seed, typeManifest: seedManifest, valueManifest };
   });
   const hasVariableSeeds = pdaNode.seeds.filter(isNodeFilter5("variablePdaSeedNode")).length > 0;
-  return fragmentFromTemplate("pdaFunction.njk", {
-    findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
-    hasVariableSeeds,
-    pdaSeedsType: nameApi.pdaSeedsType(pdaNode.name),
-    programAddress: pdaNode.programId ?? programNode.publicKey,
-    seeds
-  }).mergeImportsWith(imports).addImports("solanaAddresses", ["type Address", "getProgramDerivedAddress", "type ProgramDerivedAddress"]);
+  return pipe18(
+    fragmentFromTemplate("pdaFunction.njk", {
+      findPdaFunction: nameApi.pdaFindFunction(pdaNode.name),
+      hasVariableSeeds,
+      pdaDocs: pdaNode.docs,
+      pdaSeedsType: nameApi.pdaSeedsType(pdaNode.name),
+      programAddress: pdaNode.programId ?? programNode.publicKey,
+      seeds
+    }),
+    (f) => mergeFragmentImports(f, [imports]),
+    (f) => addFragmentImports(f, "solanaAddresses", [
+      "type Address",
+      "getProgramDerivedAddress",
+      "type ProgramDerivedAddress"
+    ])
+  );
 }
 
 // src/fragments/program.ts
+import { pipe as pipe19 } from "@codama/visitors-core";
 function getProgramFragment(scope) {
   const { programNode, nameApi } = scope;
-  return fragmentFromTemplate("program.njk", {
-    program: programNode,
-    programAddressConstant: nameApi.programAddressConstant(programNode.name)
-  }).addImports("solanaAddresses", ["type Address"]);
+  return pipe19(
+    fragmentFromTemplate("program.njk", {
+      program: programNode,
+      programAddressConstant: nameApi.programAddressConstant(programNode.name)
+    }),
+    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+  );
 }
 
 // src/fragments/programAccounts.ts
 import { resolveNestedTypeNode as resolveNestedTypeNode2 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent9 } from "@codama/renderers-core";
+import { pipe as pipe20 } from "@codama/visitors-core";
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return fragment("");
   return mergeFragments(
     [getProgramAccountsEnumFragment(scope), getProgramAccountsIdentifierFunctionFragment(scope)],
-    (r) => `${r.join("\n\n")}
+    (c) => `${c.join("\n\n")}
 `
   );
 }
@@ -1613,42 +1848,53 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
   if (!hasAccountDiscriminators) return fragment("");
   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 pipe20(
+    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)
+        });
+      }),
+      (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
+import { pipe as pipe21 } from "@codama/visitors-core";
 function getProgramErrorsFragment(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 pipe21(
+    fragmentFromTemplate("programErrors.njk", {
+      errors: programNode.errors,
+      escapeProgramErrorMessage: (message) => message.replace(/`/g, "\\`"),
+      getProgramErrorConstant: (name) => nameApi.programErrorConstantPrefix(programNode.name) + nameApi.programErrorConstant(name),
+      programAddressConstant,
+      programErrorMessagesMap: nameApi.programErrorMessagesMap(programNode.name),
+      programErrorUnion: nameApi.programErrorUnion(programNode.name),
+      programGetErrorMessageFunction: nameApi.programGetErrorMessageFunction(programNode.name),
+      programIsErrorFunction: nameApi.programIsErrorFunction(programNode.name)
+    }),
+    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant]),
+    (f) => addFragmentImports(f, "solanaPrograms", ["isProgramError"]),
+    (f) => addFragmentImports(f, "solanaErrors", ["type SolanaError", "type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM"]),
+    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+  );
 }
 
 // src/fragments/programInstructions.ts
@@ -1656,6 +1902,8 @@ import {
   getAllInstructionsWithSubs,
   structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3
 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent10 } from "@codama/renderers-core";
+import { pipe as pipe22 } from "@codama/visitors-core";
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return fragment("");
   const allInstructions = getAllInstructionsWithSubs(scope.programNode, {
@@ -1669,7 +1917,7 @@ function getProgramInstructionsFragment(scope) {
       getProgramInstructionsIdentifierFunctionFragment(scopeWithInstructions),
       getProgramInstructionsParsedUnionTypeFragment(scopeWithInstructions)
     ],
-    (r) => `${r.join("\n\n")}
+    (c) => `${c.join("\n\n")}
 `
   );
 }
@@ -1703,15 +1951,20 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         struct: structTypeNodeFromInstructionArgumentNodes3(instruction.arguments)
       });
     }),
-    (r) => r.join("\n")
+    (c) => c.join("\n")
   );
-  return discriminatorsFragment.mapRender(
-    (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
+  return pipe22(
+    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,94 +1974,48 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
   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}`);
+    return pipe22(
+      fragment(
+        `| { instructionType: ${programInstructionsEnum}.${instructionEnumVariant} } & ${parsedInstructionType}<TProgram>`
+      ),
+      (f) => addFragmentImports(f, "generatedInstructions", [`type ${parsedInstructionType}`])
+    );
   });
   return mergeFragments(
     [
       fragment(`export type ${programInstructionsType}<TProgram extends string = '${programAddress}'> =`),
       ...typeVariants
     ],
-    (r) => r.join("\n")
+    (c) => c.join("\n")
   );
 }
 
 // src/fragments/typeDiscriminatedUnionHelpers.ts
 import { isDataEnum as isDataEnum3, isNode as isNode14 } from "@codama/nodes";
+import { pipe as pipe23 } from "@codama/visitors-core";
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
   const isDiscriminatedUnion = isNode14(typeNode, "enumTypeNode") && isDataEnum3(typeNode);
   if (!isDiscriminatedUnion) {
     return fragment("");
   }
-  return 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"
-  ]);
-}
-
-// 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)
-  };
+  return pipe23(
+    fragmentFromTemplate("typeDiscriminatedUnionHelpers.njk", {
+      discriminatedUnionDiscriminator: nameApi.discriminatedUnionDiscriminator(name),
+      discriminatedUnionFunction: nameApi.discriminatedUnionFunction(name),
+      getVariant: (variant) => nameApi.discriminatedUnionVariant(variant),
+      isDiscriminatedUnionFunction: nameApi.isDiscriminatedUnionFunction(name),
+      looseName: nameApi.dataArgsType(name),
+      strictName: nameApi.dataType(name),
+      typeNode
+    }),
+    (f) => addFragmentImports(f, "solanaCodecsDataStructures", [
+      "type GetDiscriminatedUnionVariantContent",
+      "type GetDiscriminatedUnionVariant"
+    ])
+  );
 }
 
-// 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/getTypeManifestVisitor.ts
 import {
   camelCase as camelCase10,
@@ -1823,11 +2030,12 @@ import {
   structTypeNode,
   structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
 } from "@codama/nodes";
+import { mapFragmentContent as mapFragmentContent11, setFragmentContent as setFragmentContent2 } from "@codama/renderers-core";
 import {
   extendVisitor,
   findLastNodeFromPath,
   NodeStack,
-  pipe,
+  pipe as pipe24,
   recordNodeStackVisitor,
   staticVisitor,
   visit as visit5
@@ -1836,27 +2044,17 @@ 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 pipe24(
+    staticVisitor(() => typeManifest(), {
+      keys: [
+        ...REGISTERED_TYPE_NODE_KINDS,
+        ...REGISTERED_VALUE_NODE_KINDS,
+        "definedTypeLinkNode",
+        "definedTypeNode",
+        "accountNode",
+        "instructionNode"
+      ]
+    }),
     (visitor) => extendVisitor(visitor, {
       visitAccount(account, { self }) {
         parentName = {
@@ -1873,17 +2071,29 @@ function getTypeManifestVisitor(input) {
       },
       visitArrayType(arrayType, { self }) {
         const childManifest = visit5(arrayType.item, self);
-        childManifest.looseType.mapRender((r) => `Array<${r}>`);
-        childManifest.strictType.mapRender((r) => `Array<${r}>`);
         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.content ? `, { ${sizeManifest.encoder.content} }` : "";
+        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        return typeManifest({
+          ...childManifest,
+          decoder: pipe24(
+            childManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getArrayDecoder(${c + decoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.decoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getArrayDecoder"])
+          ),
+          encoder: pipe24(
+            childManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getArrayEncoder(${c + encoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.encoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getArrayEncoder"])
+          ),
+          looseType: mapFragmentContent11(childManifest.looseType, (c) => `Array<${c}>`),
+          strictType: mapFragmentContent11(childManifest.strictType, (c) => `Array<${c}>`)
+        });
       },
       visitArrayValue(node, { self }) {
-        return mergeManifests(
+        return mergeTypeManifests(
           node.items.map((v) => visit5(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
@@ -1898,62 +2108,61 @@ function getTypeManifestVisitor(input) {
           const size = visit5(booleanType.size, self);
           encoderImports.mergeWith(size.encoder);
           decoderImports.mergeWith(size.decoder);
-          sizeEncoder = `{ size: ${size.encoder.render} }`;
-          sizeDecoder = `{ size: ${size.decoder.render} }`;
+          sizeEncoder = `{ size: ${size.encoder.content} }`;
+          sizeDecoder = `{ size: ${size.decoder.content} }`;
         }
-        return {
-          decoder: fragment(`getBooleanDecoder(${sizeDecoder})`, decoderImports),
-          encoder: fragment(`getBooleanEncoder(${sizeEncoder})`, encoderImports),
-          isEnum: false,
+        return typeManifest({
+          decoder: pipe24(
+            fragment(`getBooleanDecoder(${sizeDecoder})`),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: pipe24(
+            fragment(`getBooleanEncoder(${sizeEncoder})`),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          ),
           looseType: fragment("boolean"),
-          strictType: fragment("boolean"),
-          value: fragment("")
-        };
+          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"
+        const readonlyUint8Array = pipe24(
+          fragment("ReadonlyUint8Array"),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
+        );
+        return typeManifest({
+          decoder: pipe24(
+            fragment(`getBytesDecoder()`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getBytesDecoder"])
           ),
-          strictType: fragment("ReadonlyUint8Array").addImports(
-            "solanaCodecsCore",
-            "type ReadonlyUint8Array"
+          encoder: pipe24(
+            fragment(`getBytesEncoder()`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getBytesEncoder"])
           ),
-          value: fragment("")
-        };
+          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 {
-          ...typeManifest(),
+        return typeManifest({
           value: mergeFragments(
             [visit5(node.type, self).encoder, visit5(node.value, self).value],
             ([encoderFunction, value]) => `${encoderFunction}.encode(${value})`
           )
-        };
+        });
       },
       visitDateTimeType(dateTimeType, { self }) {
         return visit5(dateTimeType.number, self);
@@ -1973,33 +2182,41 @@ 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: pipe24(
+            fragment(`${decoderFunction}()`),
+            (f) => addFragmentImports(f, importFrom, [decoderFunction])
+          ),
+          encoder: pipe24(
+            fragment(`${encoderFunction}()`),
+            (f) => addFragmentImports(f, importFrom, [encoderFunction])
+          ),
+          looseType: pipe24(
+            fragment(looseName),
+            (f) => addFragmentImports(f, importFrom, [`type ${looseName}`])
+          ),
+          strictType: pipe24(
+            fragment(strictName),
+            (f) => addFragmentImports(f, importFrom, [`type ${strictName}`])
+          )
+        });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
         const discriminator = nameApi.discriminatedUnionDiscriminator(camelCase10(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
-        return {
-          decoder: fragment(`['${name}', getUnitDecoder()]`).addImports(
-            "solanaCodecsDataStructures",
-            "getUnitDecoder"
+        return typeManifest({
+          decoder: pipe24(
+            fragment(`['${name}', getUnitDecoder()]`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getUnitDecoder"])
           ),
-          encoder: fragment(`['${name}', getUnitEncoder()]`).addImports(
-            "solanaCodecsDataStructures",
-            "getUnitEncoder"
+          encoder: pipe24(
+            fragment(`['${name}', getUnitEncoder()]`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getUnitEncoder"])
           ),
-          isEnum: false,
           looseType: fragment(`{ ${kindAttribute} }`),
-          strictType: fragment(`{ ${kindAttribute} }`),
-          value: fragment("")
-        };
+          strictType: fragment(`{ ${kindAttribute} }`)
+        });
       },
       visitEnumStructVariantType(enumStructVariantType, { self }) {
         const currentParentName = parentName;
@@ -2011,11 +2228,19 @@ function getTypeManifestVisitor(input) {
         parentName = null;
         const structManifest = visit5(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: pipe24(structManifest.decoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
+          encoder: pipe24(structManifest.encoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
+          looseType: pipe24(
+            structManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          ),
+          strictType: pipe24(
+            structManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          )
+        });
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
@@ -2033,11 +2258,19 @@ function getTypeManifestVisitor(input) {
         parentName = null;
         const structManifest = visit5(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: pipe24(structManifest.decoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
+          encoder: pipe24(structManifest.encoder, (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)),
+          looseType: pipe24(
+            structManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          ),
+          strictType: pipe24(
+            structManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          )
+        });
       },
       visitEnumType(enumType, { self }) {
         const currentParentName = parentName;
@@ -2050,8 +2283,8 @@ function getTypeManifestVisitor(input) {
           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}`);
+          encoderOptions.push(`size: ${sizeManifest.encoder.content}`);
+          decoderOptions.push(`size: ${sizeManifest.decoder.content}`);
         }
         const discriminator = nameApi.discriminatedUnionDiscriminator(
           camelCase10(currentParentName?.strict ?? "")
@@ -2069,31 +2302,50 @@ function getTypeManifestVisitor(input) {
             );
           }
           const variantNames = enumType.variants.map(({ name }) => nameApi.enumVariant(name));
-          return {
-            decoder: fragment(
-              `getEnumDecoder(${currentParentName.strict + decoderOptionsAsString})`,
-              decoderImports.add("solanaCodecsDataStructures", "getEnumDecoder")
+          return typeManifest({
+            decoder: pipe24(
+              fragment(`getEnumDecoder(${currentParentName.strict + decoderOptionsAsString})`),
+              (f) => mergeFragmentImports(f, [decoderImports]),
+              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getEnumDecoder"])
             ),
-            encoder: fragment(
-              `getEnumEncoder(${currentParentName.strict + encoderOptionsAsString})`,
-              encoderImports.add("solanaCodecsDataStructures", "getEnumEncoder")
+            encoder: pipe24(
+              fragment(`getEnumEncoder(${currentParentName.strict + encoderOptionsAsString})`),
+              (f) => mergeFragmentImports(f, [encoderImports]),
+              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getEnumEncoder"])
             ),
             isEnum: true,
             looseType: fragment(`{ ${variantNames.join(", ")} }`),
-            strictType: fragment(`{ ${variantNames.join(", ")} }`),
-            value: fragment("")
-          };
+            strictType: fragment(`{ ${variantNames.join(", ")} }`)
+          });
         }
-        const mergedManifest = mergeManifests(
+        const mergedManifest = mergeTypeManifests(
           enumType.variants.map((variant) => visit5(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: pipe24(
+            mergedManifest.decoder,
+            (f) => mapFragmentContent11(
+              f,
+              (c) => `getDiscriminatedUnionDecoder([${c}]${decoderOptionsAsString})`
+            ),
+            (f) => mergeFragmentImports(f, [decoderImports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getDiscriminatedUnionDecoder"])
+          ),
+          encoder: pipe24(
+            mergedManifest.encoder,
+            (f) => mapFragmentContent11(
+              f,
+              (c) => `getDiscriminatedUnionEncoder([${c}]${encoderOptionsAsString})`
+            ),
+            (f) => mergeFragmentImports(f, [encoderImports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getDiscriminatedUnionEncoder"])
+          )
+        });
       },
       visitEnumValue(node, { self }) {
         const manifest = typeManifest();
@@ -2104,40 +2356,108 @@ 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: pipe24(
+              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: pipe24(
+              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: pipe24(
+            visit5(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;
+        return typeManifest({
+          ...manifest,
+          decoder: pipe24(
+            manifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `fixDecoderSize(${c}, ${node.size})`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["fixDecoderSize"])
+          ),
+          encoder: pipe24(
+            manifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `fixEncoderSize(${c}, ${node.size})`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["fixEncoderSize"])
+          )
+        });
       },
       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 prefixEncoders = pipe24(
+          mergeFragments(prefixes, (contents) => contents.map((c) => `getConstantEncoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
+        );
+        const prefixDecoders = pipe24(
+          mergeFragments(prefixes, (contents) => contents.map((c) => `getConstantDecoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
+        );
+        return typeManifest({
+          ...manifest,
+          decoder: pipe24(
+            mergeFragments(
+              [manifest.decoder, prefixDecoders],
+              ([child, prefixes2]) => `getHiddenPrefixDecoder(${child}, [${prefixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenPrefixDecoder"])
+          ),
+          encoder: pipe24(
+            mergeFragments(
+              [manifest.encoder, prefixEncoders],
+              ([child, prefixes2]) => `getHiddenPrefixEncoder(${child}, [${prefixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenPrefixEncoder"])
+          )
+        });
       },
       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 suffixEncoders = pipe24(
+          mergeFragments(suffixes, (contents) => contents.map((c) => `getConstantEncoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
+        );
+        const suffixDecoders = pipe24(
+          mergeFragments(suffixes, (contents) => contents.map((c) => `getConstantDecoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
+        );
+        return typeManifest({
+          ...manifest,
+          decoder: pipe24(
+            mergeFragments(
+              [manifest.decoder, suffixDecoders],
+              ([child, suffixes2]) => `getHiddenSuffixDecoder(${child}, [${suffixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenSuffixDecoder"])
+          ),
+          encoder: pipe24(
+            mergeFragments(
+              [manifest.encoder, suffixEncoders],
+              ([child, suffixes2]) => `getHiddenSuffixEncoder(${child}, [${suffixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenSuffixEncoder"])
+          )
+        });
       },
       visitInstruction(instruction, { self }) {
         const instructionDataName = nameApi.instructionDataType(instruction.name);
@@ -2152,34 +2472,44 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeManifests([visit5(node.key, self), visit5(node.value, self)], {
+        return mergeTypeManifests([visit5(node.key, self), visit5(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 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.content ? `, { ${sizeManifest.encoder.content} }` : "";
+        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        return typeManifest({
+          ...mergedManifest,
+          decoder: pipe24(
+            mergedManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getMapDecoder(${c}${decoderOptions})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getMapDecoder"])
+          ),
+          encoder: pipe24(
+            mergedManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getMapEncoder(${c}${encoderOptions})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getMapEncoder"])
+          )
+        });
       },
       visitMapValue(node, { self }) {
         const entryFragments = node.entries.map((entry) => visit5(entry, self));
-        return mergeManifests(entryFragments, {
+        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: pipe24(fragment("none()"), (f) => addFragmentImports(f, "solanaOptions", ["none"]))
+        });
       },
       visitNumberType(numberType) {
         const encoderFunction = nameApi.encoderFunction(numberType.format);
@@ -2193,33 +2523,37 @@ function getTypeManifestVisitor(input) {
           decoderImports.add("solanaCodecsNumbers", "Endian");
           endianness = "{ endian: Endian.Big }";
         }
-        return {
-          decoder: fragment(`${decoderFunction}(${endianness})`, decoderImports),
-          encoder: fragment(`${encoderFunction}(${endianness})`, encoderImports),
-          isEnum: false,
+        return typeManifest({
+          decoder: pipe24(
+            fragment(`${decoderFunction}(${endianness})`),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: pipe24(
+            fragment(`${encoderFunction}(${endianness})`),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          ),
           looseType: fragment(isBigNumber ? "number | bigint" : "number"),
-          strictType: fragment(isBigNumber ? "bigint" : "number"),
-          value: fragment("")
-        };
+          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 encoderOptions = [];
         const decoderOptions = [];
+        const encoderImports = new ImportMap();
+        const decoderImports = new ImportMap();
         const optionPrefix = resolveNestedTypeNode3(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}`);
+          encoderImports.mergeWith(prefixManifest.encoder);
+          decoderImports.mergeWith(prefixManifest.decoder);
+          encoderOptions.push(`prefix: ${prefixManifest.encoder.content}`);
+          decoderOptions.push(`prefix: ${prefixManifest.decoder.content}`);
         }
         if (optionType.fixed) {
           encoderOptions.push(`noneValue: "zeroes"`);
@@ -2227,16 +2561,48 @@ function getTypeManifestVisitor(input) {
         }
         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: pipe24(
+            childManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"]),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: pipe24(
+            childManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"]),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          ),
+          looseType: pipe24(
+            childManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `OptionOrNullable<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
+          ),
+          strictType: pipe24(
+            childManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `Option<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
+          )
+        });
       },
       visitPostOffsetType(node, { self }) {
         const manifest = visit5(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: pipe24(
+              manifest.decoder,
+              (f) => mapFragmentContent11(f, (c) => `padRightDecoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padRightDecoder"])
+            ),
+            encoder: pipe24(
+              manifest.encoder,
+              (f) => mapFragmentContent11(f, (c) => `padRightEncoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padRightEncoder"])
+            )
+          });
         }
         const fn = (() => {
           switch (node.strategy) {
@@ -2249,16 +2615,36 @@ 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: pipe24(
+            manifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `offsetDecoder(${c}, { postOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetDecoder"])
+          ),
+          encoder: pipe24(
+            manifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `offsetEncoder(${c}, { postOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetEncoder"])
+          )
+        });
       },
       visitPreOffsetType(node, { self }) {
         const manifest = visit5(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: pipe24(
+              manifest.decoder,
+              (f) => mapFragmentContent11(f, (c) => `padLeftDecoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padLeftDecoder"])
+            ),
+            encoder: pipe24(
+              manifest.encoder,
+              (f) => mapFragmentContent11(f, (c) => `padLeftEncoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padLeftEncoder"])
+            )
+          });
         }
         const fn = (() => {
           switch (node.strategy) {
@@ -2269,58 +2655,122 @@ 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: pipe24(
+            manifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `offsetDecoder(${c}, { preOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetDecoder"])
+          ),
+          encoder: pipe24(
+            manifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `offsetEncoder(${c}, { preOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetEncoder"])
+          )
+        });
       },
       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("")
-        };
+        const addressFragment = pipe24(
+          fragment("Address"),
+          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+        );
+        return typeManifest({
+          decoder: pipe24(
+            fragment("getAddressDecoder()"),
+            (f) => addFragmentImports(f, "solanaAddresses", ["getAddressDecoder"])
+          ),
+          encoder: pipe24(
+            fragment("getAddressEncoder()"),
+            (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
+          ),
+          looseType: addressFragment,
+          strictType: addressFragment
+        });
       },
       visitPublicKeyValue(node) {
-        const manifest = typeManifest();
-        manifest.value.setRender(`address("${node.publicKey}")`).addImports("solanaAddresses", "address");
-        return manifest;
+        return typeManifest({
+          value: pipe24(
+            fragment(`address("${node.publicKey}")`),
+            (f) => addFragmentImports(f, "solanaAddresses", ["address"])
+          )
+        });
       },
       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 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: pipe24(
+            childManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"])
+          ),
+          encoder: pipe24(
+            childManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"])
+          ),
+          looseType: pipe24(
+            childManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `OptionOrNullable<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
+          ),
+          strictType: pipe24(
+            childManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `Option<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
+          )
+        });
       },
       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;
+        return typeManifest({
+          ...manifest,
+          decoder: pipe24(
+            mergeFragments(
+              [manifest.decoder, sentinel],
+              ([child, sentinel2]) => `addDecoderSentinel(${child}, ${sentinel2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addDecoderSentinel"])
+          ),
+          encoder: pipe24(
+            mergeFragments(
+              [manifest.encoder, sentinel],
+              ([child, sentinel2]) => `addEncoderSentinel(${child}, ${sentinel2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addEncoderSentinel"])
+          )
+        });
       },
       visitSetType(setType, { self }) {
         const childManifest = visit5(setType.item, self);
-        childManifest.strictType.mapRender((r) => `Set<${r}>`);
-        childManifest.looseType.mapRender((r) => `Set<${r}>`);
         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.content ? `, { ${sizeManifest.encoder.content} }` : "";
+        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        return typeManifest({
+          ...childManifest,
+          decoder: pipe24(
+            childManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getSetDecoder(${c + decoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.decoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getSetDecoder"])
+          ),
+          encoder: pipe24(
+            childManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getSetEncoder(${c + encoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.encoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getSetEncoder"])
+          ),
+          looseType: pipe24(childManifest.looseType, (f) => mapFragmentContent11(f, (c) => `Set<${c}>`)),
+          strictType: pipe24(childManifest.strictType, (f) => mapFragmentContent11(f, (c) => `Set<${c}>`))
+        });
       },
       visitSetValue(node, { self }) {
-        return mergeManifests(
+        return mergeTypeManifests(
           node.items.map((v) => visit5(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
@@ -2328,26 +2778,54 @@ function getTypeManifestVisitor(input) {
       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;
+        return typeManifest({
+          ...manifest,
+          decoder: pipe24(
+            mergeFragments(
+              [manifest.decoder, prefix.decoder],
+              ([decoder, prefix2]) => `addDecoderSizePrefix(${decoder}, ${prefix2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addDecoderSizePrefix"])
+          ),
+          encoder: pipe24(
+            mergeFragments(
+              [manifest.encoder, prefix.encoder],
+              ([encoder, prefix2]) => `addEncoderSizePrefix(${encoder}, ${prefix2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addEncoderSizePrefix"])
+          )
+        });
       },
       visitSolAmountType({ number }, { self }) {
         const numberManifest = visit5(number, self);
-        const lamportsType = "Lamports";
-        const lamportsImport = new ImportMap().add("solanaRpcTypes", "type Lamports");
-        return {
+        const lamportFragment = pipe24(
+          fragment("Lamports"),
+          (f) => addFragmentImports(f, "solanaRpcTypes", ["type Lamports"])
+        );
+        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: pipe24(
+            numberManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getLamportsDecoder(${c})`),
+            (f) => addFragmentImports(f, "solanaRpcTypes", ["getLamportsDecoder"])
+          ),
+          encoder: pipe24(
+            numberManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getLamportsEncoder(${c})`),
+            (f) => addFragmentImports(f, "solanaRpcTypes", ["getLamportsEncoder"])
+          ),
+          looseType: lamportFragment,
+          strictType: lamportFragment
+        });
       },
       visitSomeValue(node, { self }) {
-        const manifest = typeManifest();
-        manifest.value = visit5(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
-        return manifest;
+        return typeManifest({
+          value: pipe24(
+            visit5(node.value, self).value,
+            (f) => mapFragmentContent11(f, (c) => `some(${c})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["some"])
+          )
+        });
       },
       visitStringType(stringType) {
         const [encoder, decoder] = (() => {
@@ -2364,57 +2842,99 @@ 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,
+        return typeManifest({
+          decoder: pipe24(
+            fragment(`${decoder}()`),
+            (f) => addFragmentImports(f, "solanaCodecsStrings", [decoder])
+          ),
+          encoder: pipe24(
+            fragment(`${encoder}()`),
+            (f) => addFragmentImports(f, "solanaCodecsStrings", [encoder])
+          ),
           looseType: fragment("string"),
-          strictType: fragment("string"),
-          value: fragment("")
-        };
+          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 originalChildManifest = 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 originalLooseType = originalChildManifest.looseType.content;
+        const childManifest = typeManifest({
+          ...originalChildManifest,
+          decoder: pipe24(
+            originalChildManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)
+          ),
+          encoder: pipe24(
+            originalChildManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `['${name}', ${c}]`)
+          ),
+          looseType: pipe24(
+            originalChildManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `${docblock}${name}: ${c}; `)
+          ),
+          strictType: pipe24(
+            originalChildManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `${docblock}${name}: ${c}; `)
+          )
+        });
         if (!structFieldType.defaultValue) {
           return childManifest;
         }
         if (structFieldType.defaultValueStrategy !== "omitted") {
-          childManifest.looseType.setRender(`${docblock}${name}?: ${originalLooseType}; `);
-          return childManifest;
+          return typeManifest({
+            ...childManifest,
+            looseType: pipe24(
+              childManifest.looseType,
+              (f) => setFragmentContent2(f, `${docblock}${name}?: ${originalLooseType}; `)
+            )
+          });
         }
-        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;
+        return typeManifest({
+          value: pipe24(
+            visit5(node.value, self).value,
+            (f) => mapFragmentContent11(f, (c) => `${node.name}: ${c}`)
+          )
+        });
       },
       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 = pipe24(
+          mergeTypeManifests(
+            structType.fields.map((field) => visit5(field, self)),
+            {
+              mergeCodecs: (renders) => `([${renders.join(", ")}])`,
+              mergeTypes: (renders) => `{ ${renders.join("")} }`
+            }
+          ),
+          (manifest) => typeManifest({
+            ...manifest,
+            decoder: pipe24(
+              manifest.decoder,
+              (f) => mapFragmentContent11(f, (c) => `getStructDecoder${c}`),
+              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getStructDecoder"])
+            ),
+            encoder: pipe24(
+              manifest.encoder,
+              (f) => mapFragmentContent11(f, (c) => `getStructEncoder${c}`),
+              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getStructEncoder"])
+            )
+          })
         );
-        mergedManifest.encoder.mapRender((r) => `getStructEncoder${r}`).addImports("solanaCodecsDataStructures", "getStructEncoder");
-        mergedManifest.decoder.mapRender((r) => `getStructDecoder${r}`).addImports("solanaCodecsDataStructures", "getStructDecoder");
         if (optionalFields.length === 0) {
           return mergedManifest;
         }
@@ -2424,6 +2944,7 @@ ${jsDocblock(structFieldDocs)}` : "";
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
         const fieldDiscriminators = discriminators.filter(isNodeFilter6("fieldDiscriminatorNode"));
+        const encoderImports = new ImportMap();
         const defaultValues = optionalFields.map((f) => {
           const key = camelCase10(f.name);
           if (fieldDiscriminators.some((d) => d.name === f.name)) {
@@ -2431,56 +2952,98 @@ ${jsDocblock(structFieldDocs)}` : "";
             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);
+          const { content: renderedValue, imports } = visit5(defaultValue, self).value;
+          encoderImports.mergeWith(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;
+        return typeManifest({
+          ...mergedManifest,
+          encoder: pipe24(
+            mergedManifest.encoder,
+            (f) => mapFragmentContent11(
+              f,
+              (c) => `transformEncoder(${c}, (value) => ({ ...value, ${defaultValues} }))`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["transformEncoder"]),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          )
+        });
       },
       visitStructValue(node, { self }) {
-        return mergeManifests(
+        return mergeTypeManifests(
           node.fields.map((field) => visit5(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
         const items = tupleType.items.map((item) => visit5(item, self));
-        const mergedManifest = mergeManifests(items, {
+        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: pipe24(
+            mergedManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getTupleDecoder(${c})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getTupleDecoder"])
+          ),
+          encoder: pipe24(
+            mergedManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getTupleEncoder(${c})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getTupleEncoder"])
+          )
+        });
       },
       visitTupleValue(node, { self }) {
-        return mergeManifests(
+        return mergeTypeManifests(
           node.items.map((v) => visit5(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 encoderImports = new ImportMap();
+        const decoderImports = new ImportMap();
         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}`);
+          encoderImports.mergeWith(zeroValueManifest.value);
+          decoderImports.mergeWith(zeroValueManifest.value);
+          encoderOptions.push(`noneValue: ${zeroValueManifest.value.content}`);
+          decoderOptions.push(`noneValue: ${zeroValueManifest.value.content}`);
         } else {
           encoderOptions.push(`noneValue: "zeroes"`);
           decoderOptions.push(`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;
+        return typeManifest({
+          ...childManifest,
+          decoder: pipe24(
+            childManifest.decoder,
+            (f) => mapFragmentContent11(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"]),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: pipe24(
+            childManifest.encoder,
+            (f) => mapFragmentContent11(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"]),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          ),
+          looseType: pipe24(
+            childManifest.looseType,
+            (f) => mapFragmentContent11(f, (c) => `OptionOrNullable<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
+          ),
+          strictType: pipe24(
+            childManifest.strictType,
+            (f) => mapFragmentContent11(f, (c) => `Option<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
+          )
+        });
       }
     }),
     (visitor) => recordNodeStackVisitor(visitor, stack)
@@ -2504,9 +3067,10 @@ function getArrayLikeSizeOption(count, visitor) {
     return { decoder: fragment(""), encoder: fragment("") };
   }
   const prefixManifest = visit5(count.prefix, visitor);
-  prefixManifest.encoder.mapRender((r) => `size: ${r}`);
-  prefixManifest.decoder.mapRender((r) => `size: ${r}`);
-  return prefixManifest;
+  return {
+    decoder: pipe24(prefixManifest.decoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`)),
+    encoder: pipe24(prefixManifest.encoder, (f) => mapFragmentContent11(f, (c) => `size: ${c}`))
+  };
 }
 
 // src/nameTransformers.ts
@@ -2614,10 +3178,10 @@ function getRenderMapVisitor(options = {}) {
     typeManifestVisitor
   };
   const render2 = (template, context, renderOptions) => {
-    return render(join3("pages", template), context, renderOptions);
+    return render(join2("pages", template), context, renderOptions);
   };
-  return pipe2(
-    staticVisitor2(() => new RenderMap(), {
+  return pipe25(
+    staticVisitor2(() => renderMap(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
     (v) => extendVisitor2(v, {
@@ -2650,14 +3214,15 @@ function getRenderMapVisitor(options = {}) {
           accountSizeHelpersFragment,
           accountPdaHelpersFragment
         );
-        return new RenderMap().add(
+        return addToRenderMap(
+          renderMap(),
           `accounts/${camelCase12(node.name)}.ts`,
           render2("accountsPage.njk", {
-            accountDiscriminatorConstantsFragment,
-            accountFetchHelpersFragment,
-            accountPdaHelpersFragment,
-            accountSizeHelpersFragment,
-            accountTypeFragment,
+            accountDiscriminatorConstantsFragment: accountDiscriminatorConstantsFragment.content,
+            accountFetchHelpersFragment: accountFetchHelpersFragment.content,
+            accountPdaHelpersFragment: accountPdaHelpersFragment.content,
+            accountSizeHelpersFragment: accountSizeHelpersFragment.content,
+            accountTypeFragment: accountTypeFragment.content,
             imports: imports.toString(dependencyMap, useGranularImports)
           })
         );
@@ -2684,15 +3249,13 @@ function getRenderMapVisitor(options = {}) {
           nameApi.decoderFunction(node.name),
           nameApi.codecFunction(node.name)
         ]);
-        return new RenderMap().add(
+        return addToRenderMap(
+          renderMap(),
           `types/${camelCase12(node.name)}.ts`,
           render2("definedTypesPage.njk", {
-            imports: imports.toString({
-              ...dependencyMap,
-              generatedTypes: "."
-            }),
-            typeDiscriminatedUnionHelpersFragment,
-            typeWithCodecFragment
+            imports: imports.toString({ ...dependencyMap, generatedTypes: "." }),
+            typeDiscriminatedUnionHelpersFragment: typeDiscriminatedUnionHelpersFragment.content,
+            typeWithCodecFragment: typeWithCodecFragment.content
           })
         );
       },
@@ -2744,34 +3307,36 @@ function getRenderMapVisitor(options = {}) {
           instructionFunctionSyncFragment,
           instructionParseFunctionFragment
         );
-        return new RenderMap().add(
+        return addToRenderMap(
+          renderMap(),
           `instructions/${camelCase12(node.name)}.ts`,
           render2("instructionsPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
             instruction: node,
-            instructionDataFragment,
-            instructionDiscriminatorConstantsFragment,
-            instructionExtraArgsFragment,
-            instructionFunctionAsyncFragment,
-            instructionFunctionSyncFragment,
-            instructionParseFunctionFragment,
-            instructionTypeFragment
+            instructionDataFragment: instructionDataFragment.content,
+            instructionDiscriminatorConstantsFragment: instructionDiscriminatorConstantsFragment.content,
+            instructionExtraArgsFragment: instructionExtraArgsFragment.content,
+            instructionFunctionAsyncFragment: instructionFunctionAsyncFragment.content,
+            instructionFunctionSyncFragment: instructionFunctionSyncFragment.content,
+            instructionParseFunctionFragment: instructionParseFunctionFragment.content,
+            instructionTypeFragment: instructionTypeFragment.content
           })
         );
       },
       visitPda(node) {
         const pdaPath = stack.getPath("pdaNode");
         if (!findProgramNodeFromPath7(pdaPath)) {
-          throw new Error("Account must be visited inside a program.");
+          throw new Error("PDA must be visited inside a program.");
         }
         const scope = { ...globalScope, pdaPath };
         const pdaFunctionFragment = getPdaFunctionFragment(scope);
         const imports = new ImportMap().mergeWith(pdaFunctionFragment);
-        return new RenderMap().add(
+        return addToRenderMap(
+          renderMap(),
           `pdas/${camelCase12(node.name)}.ts`,
           render2("pdasPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
-            pdaFunctionFragment
+            pdaFunctionFragment: pdaFunctionFragment.content
           })
         );
       },
@@ -2781,35 +3346,42 @@ function getRenderMapVisitor(options = {}) {
           ...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)));
+        let renders = mergeRenderMaps([
+          ...node.pdas.map((p) => visit6(p, self)),
+          ...node.accounts.map((a) => visit6(a, self)),
+          ...node.definedTypes.map((t) => visit6(t, self)),
+          ...customDataDefinedType.map((t) => visit6(t, self))
+        ]);
         if (node.errors.length > 0) {
           const programErrorsFragment = getProgramErrorsFragment(scope);
-          renderMap.add(
+          renders = addToRenderMap(
+            renders,
             `errors/${camelCase12(node.name)}.ts`,
             render2("errorsPage.njk", {
               imports: new ImportMap().mergeWith(programErrorsFragment).toString(dependencyMap, useGranularImports),
-              programErrorsFragment
+              programErrorsFragment: programErrorsFragment.content
             })
           );
         }
         const programFragment = getProgramFragment(scope);
         const programAccountsFragment = getProgramAccountsFragment(scope);
         const programInstructionsFragment = getProgramInstructionsFragment(scope);
-        renderMap.add(
+        renders = addToRenderMap(
+          renders,
           `programs/${camelCase12(node.name)}.ts`,
           render2("programsPage.njk", {
             imports: new ImportMap().mergeWith(programFragment, programAccountsFragment, programInstructionsFragment).toString(dependencyMap, useGranularImports),
-            programAccountsFragment,
-            programFragment,
-            programInstructionsFragment
+            programAccountsFragment: programAccountsFragment.content,
+            programFragment: programFragment.content,
+            programInstructionsFragment: programInstructionsFragment.content
           })
         );
-        renderMap.mergeWith(
+        return mergeRenderMaps([
+          renders,
           ...getAllInstructionsWithSubs2(node, {
             leavesOnly: !renderParentInstructions
           }).map((ix) => visit6(ix, self))
-        );
-        return renderMap;
+        ]);
       },
       visitRoot(node, { self }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
@@ -2832,9 +3404,10 @@ function getRenderMapVisitor(options = {}) {
           programsWithErrorsToExport,
           root: node
         };
-        const map = new RenderMap();
+        let renders = renderMap();
         if (hasAnythingToExport) {
-          map.add(
+          renders = addToRenderMap(
+            renders,
             "shared/index.ts",
             render2("sharedPage.njk", {
               ...ctx,
@@ -2855,24 +3428,32 @@ function getRenderMapVisitor(options = {}) {
           );
         }
         if (programsToExport.length > 0) {
-          map.add("programs/index.ts", render2("programsIndex.njk", ctx));
+          renders = addToRenderMap(renders, "programs/index.ts", render2("programsIndex.njk", ctx));
         }
         if (programsWithErrorsToExport.length > 0) {
-          map.add("errors/index.ts", render2("errorsIndex.njk", ctx));
+          renders = addToRenderMap(renders, "errors/index.ts", render2("errorsIndex.njk", ctx));
         }
         if (accountsToExport.length > 0) {
-          map.add("accounts/index.ts", render2("accountsIndex.njk", ctx));
+          renders = addToRenderMap(renders, "accounts/index.ts", render2("accountsIndex.njk", ctx));
         }
         if (pdasToExport.length > 0) {
-          map.add("pdas/index.ts", render2("pdasIndex.njk", ctx));
+          renders = addToRenderMap(renders, "pdas/index.ts", render2("pdasIndex.njk", ctx));
         }
         if (instructionsToExport.length > 0) {
-          map.add("instructions/index.ts", render2("instructionsIndex.njk", ctx));
+          renders = addToRenderMap(
+            renders,
+            "instructions/index.ts",
+            render2("instructionsIndex.njk", ctx)
+          );
         }
         if (definedTypesToExport.length > 0) {
-          map.add("types/index.ts", render2("definedTypesIndex.njk", ctx));
+          renders = addToRenderMap(renders, "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 pipe25(
+          renders,
+          (r) => addToRenderMap(r, "index.ts", render2("rootIndex.njk", ctx)),
+          (r) => mergeRenderMaps([r, ...getAllPrograms(node).map((p) => visit6(p, self))])
+        );
       }
     }),
     (v) => recordNodeStackVisitor2(v, stack),
@@ -2898,7 +3479,7 @@ function getRenamedArgsMap(instruction) {
 }
 
 // src/renderVisitor.ts
-import { deleteDirectory } from "@codama/renderers-core";
+import { deleteDirectory, mapRenderMapContentAsync, writeRenderMap } from "@codama/renderers-core";
 import { rootNodeVisitor, visit as visit7 } from "@codama/visitors-core";
 import * as estreePlugin from "prettier/plugins/estree";
 import * as typeScriptPlugin from "prettier/plugins/typescript";
@@ -2919,12 +3500,12 @@ function renderVisitor(path, options = {}) {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    const renderMap = visit7(root, getRenderMapVisitor(options));
+    let renderMap2 = visit7(root, getRenderMapVisitor(options));
     if (options.formatCode ?? true) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      await renderMap.mapContentAsync((code) => format(code, prettierOptions));
+      renderMap2 = await mapRenderMapContentAsync(renderMap2, (code) => format(code, prettierOptions));
     }
-    renderMap.write(path);
+    writeRenderMap(renderMap2, path);
   });
 }
 export {
@@ -2934,7 +3515,7 @@ export {
   getNameApi,
   getRenderMapVisitor,
   getTypeManifestVisitor,
-  mergeManifests,
+  mergeTypeManifests,
   renderVisitor,
   typeManifest
 };