@codama/renderers-js 1.3.3 → 1.3.5

package/dist/index.node.cjs

@@ -36,7 +36,7 @@ __export(index_exports, {
   getNameApi: () => getNameApi,
   getRenderMapVisitor: () => getRenderMapVisitor,
   getTypeManifestVisitor: () => getTypeManifestVisitor,
-  mergeManifests: () => mergeManifests,
+  mergeTypeManifests: () => mergeTypeManifests,
   renderVisitor: () => renderVisitor,
   typeManifest: () => typeManifest
 });
@@ -175,12 +175,6 @@ var ImportMap = class {
   }
 };
 
-// src/fragments/accountFetchHelpers.ts
-var import_visitors_core2 = require("@codama/visitors-core");
-
-// src/fragments/common.ts
-var import_node_path2 = require("path");
-
 // src/utils/async.ts
 var import_nodes = require("@codama/nodes");
 var import_visitors_core = require("@codama/visitors-core");
@@ -303,6 +297,74 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
   ];
 });
 
+// src/utils/fragment.ts
+var import_renderers_core = require("@codama/renderers-core");
+
+// src/utils/render.ts
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_nodes3 = require("@codama/nodes");
+var import_nunjucks = __toESM(require("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 = false ? pathDirname(fileURLToPath(import_meta.url)) : __dirname;
+  const templates = false ? (0, import_node_path.join)(dirname, "..", "..", "public", "templates") : (0, import_node_path.join)(dirname, "templates");
+  const env = import_nunjucks.default.configure(templates, { autoescape: false, trimBlocks: true, ...options });
+  env.addFilter("pascalCase", import_nodes3.pascalCase);
+  env.addFilter("camelCase", import_nodes3.camelCase);
+  env.addFilter("snakeCase", import_nodes3.snakeCase);
+  env.addFilter("kebabCase", import_nodes3.kebabCase);
+  env.addFilter("titleCase", import_nodes3.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((0, import_renderers_core.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, module2, imports) {
+  return Object.freeze({
+    ...fragment2,
+    imports: new ImportMap().mergeWith(fragment2.imports).add(module2, imports)
+  });
+}
+function addFragmentFeatures(fragment2, features) {
+  return Object.freeze({
+    ...fragment2,
+    features: /* @__PURE__ */ new Set([...fragment2.features, ...features])
+  });
+}
+
 // src/utils/linkOverrides.ts
 var import_errors = require("@codama/errors");
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
@@ -352,135 +414,72 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
   };
 }
 
-// src/utils/render.ts
-var import_node_path = require("path");
-var import_node_url = require("url");
-var import_nodes3 = require("@codama/nodes");
-var import_nunjucks = __toESM(require("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 = false ? pathDirname(fileURLToPath(import_meta.url)) : __dirname;
-  const templates = false ? (0, import_node_path.join)(dirname, "..", "..", "public", "templates") : (0, import_node_path.join)(dirname, "templates");
-  const env = import_nunjucks.default.configure(templates, { autoescape: false, trimBlocks: true, ...options });
-  env.addFilter("pascalCase", import_nodes3.pascalCase);
-  env.addFilter("camelCase", import_nodes3.camelCase);
-  env.addFilter("snakeCase", import_nodes3.snakeCase);
-  env.addFilter("kebabCase", import_nodes3.kebabCase);
-  env.addFilter("titleCase", import_nodes3.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((0, import_node_path2.join)("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(module2, imports) {
-    this.imports.add(module2, imports);
-    return this;
-  }
-  removeImports(module2, imports) {
-    this.imports.remove(module2, imports);
-    return this;
-  }
-  mergeImportsWith(...others) {
-    this.imports.mergeWith(...others);
-    return this;
-  }
-  addImportAlias(module2, name, alias) {
-    this.imports.addAlias(module2, 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
+var import_node_path2 = require("path");
+var import_errors2 = require("@codama/errors");
+var import_nodes26 = require("@codama/nodes");
+var import_renderers_core13 = require("@codama/renderers-core");
+var import_visitors_core31 = require("@codama/visitors-core");
 
 // src/fragments/accountFetchHelpers.ts
+var import_visitors_core2 = require("@codama/visitors-core");
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
   const accountNode = (0, import_visitors_core2.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 (0, import_visitors_core2.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
@@ -494,27 +493,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((0, import_nodes4.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 (0, import_visitors_core3.pipe)(
+    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
@@ -533,55 +538,68 @@ function getAccountSizeHelpersFragment(scope) {
 
 // src/fragments/accountType.ts
 var import_nodes7 = require("@codama/nodes");
-var import_visitors_core5 = require("@codama/visitors-core");
+var import_visitors_core9 = require("@codama/visitors-core");
 
 // src/fragments/type.ts
+var import_visitors_core5 = require("@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 (0, import_visitors_core5.pipe)(
+    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
+var import_visitors_core8 = require("@codama/visitors-core");
+
 // src/fragments/typeDecoder.ts
 var import_nodes5 = require("@codama/nodes");
+var import_visitors_core6 = require("@codama/visitors-core");
 function getTypeDecoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const decoderType = typeof scope.size === "number" ? "FixedSizeDecoder" : "Decoder";
   const useTypeCast = (0, import_nodes5.isNode)(node, "enumTypeNode") && (0, import_nodes5.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 (0, import_visitors_core6.pipe)(
+    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
 var import_nodes6 = require("@codama/nodes");
+var import_visitors_core7 = require("@codama/visitors-core");
 function getTypeEncoderFragment(scope) {
   const { name, node, manifest, nameApi, docs = [] } = scope;
   const encoderType = typeof scope.size === "number" ? "FixedSizeEncoder" : "Encoder";
   const useTypeCast = (0, import_nodes6.isNode)(node, "enumTypeNode") && (0, import_nodes6.isDataEnum)(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 (0, import_visitors_core7.pipe)(
+    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
@@ -592,16 +610,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"])
+      (0, import_visitors_core8.pipe)(
+        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")
   );
@@ -618,7 +639,7 @@ function getTypeWithCodecFragment(scope) {
 // src/fragments/accountType.ts
 function getAccountTypeFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
-  const accountNode = (0, import_visitors_core5.getLastNodeFromPath)(accountPath);
+  const accountNode = (0, import_visitors_core9.getLastNodeFromPath)(accountPath);
   if (customAccountData.has(accountNode.name)) {
     return fragment("");
   }
@@ -633,24 +654,28 @@ function getAccountTypeFragment(scope) {
 
 // src/fragments/discriminatorCondition.ts
 var import_nodes8 = require("@codama/nodes");
-var import_visitors_core6 = require("@codama/visitors-core");
+var import_renderers_core2 = require("@codama/renderers-core");
+var import_visitors_core10 = require("@codama/visitors-core");
 var import_codecs_strings2 = require("@solana/codecs-strings");
 function getDiscriminatorConditionFragment(scope) {
-  return mergeFragments(
-    scope.discriminators.flatMap((discriminator) => {
-      if ((0, import_nodes8.isNode)(discriminator, "sizeDiscriminatorNode")) {
-        return [getSizeConditionFragment(discriminator, scope)];
-      }
-      if ((0, import_nodes8.isNode)(discriminator, "constantDiscriminatorNode")) {
-        return [getByteConditionFragment(discriminator, scope)];
-      }
-      if ((0, import_nodes8.isNode)(discriminator, "fieldDiscriminatorNode")) {
-        return [getFieldConditionFragment(discriminator, scope)];
-      }
-      return [];
-    }),
-    (r) => r.join(" && ")
-  ).mapRender((r) => `if (${r}) { ${scope.ifTrue}; }`);
+  return (0, import_visitors_core10.pipe)(
+    mergeFragments(
+      scope.discriminators.flatMap((discriminator) => {
+        if ((0, import_nodes8.isNode)(discriminator, "sizeDiscriminatorNode")) {
+          return [getSizeConditionFragment(discriminator, scope)];
+        }
+        if ((0, import_nodes8.isNode)(discriminator, "constantDiscriminatorNode")) {
+          return [getByteConditionFragment(discriminator, scope)];
+        }
+        if ((0, import_nodes8.isNode)(discriminator, "fieldDiscriminatorNode")) {
+          return [getFieldConditionFragment(discriminator, scope)];
+        }
+        return [];
+      }),
+      (c) => c.join(" && ")
+    ),
+    (f) => (0, import_renderers_core2.mapFragmentContent)(f, (c) => `if (${c}) { ${scope.ifTrue}; }`)
+  );
 }
 function getSizeConditionFragment(discriminator, scope) {
   const { dataName } = scope;
@@ -658,8 +683,12 @@ function getSizeConditionFragment(discriminator, scope) {
 }
 function getByteConditionFragment(discriminator, scope) {
   const { dataName, typeManifestVisitor } = scope;
-  const constant = (0, import_visitors_core6.visit)(discriminator.constant, typeManifestVisitor).value;
-  return constant.mapRender((r) => `containsBytes(${dataName}, ${r}, ${discriminator.offset})`).addImports("solanaCodecsCore", "containsBytes");
+  const constant = (0, import_visitors_core10.visit)(discriminator.constant, typeManifestVisitor).value;
+  return (0, import_visitors_core10.pipe)(
+    constant,
+    (f) => (0, import_renderers_core2.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);
@@ -685,28 +714,43 @@ function getFieldConditionFragment(discriminator, scope) {
 
 // src/fragments/instructionAccountMeta.ts
 var import_nodes9 = require("@codama/nodes");
+var import_visitors_core11 = require("@codama/visitors-core");
 function getInstructionAccountMetaFragment(instructionAccountNode) {
   const typeParam = `TAccount${(0, import_nodes9.pascalCase)(instructionAccountNode.name)}`;
   if (instructionAccountNode.isSigner === true && instructionAccountNode.isWritable) {
-    return fragment(`WritableSignerAccount<${typeParam}> & AccountSignerMeta<${typeParam}>`).addImports("solanaInstructions", ["type WritableSignerAccount"]).addImports("solanaSigners", ["type AccountSignerMeta"]);
+    return (0, import_visitors_core11.pipe)(
+      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 (0, import_visitors_core11.pipe)(
+      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 (0, import_visitors_core11.pipe)(
+      fragment(`WritableAccount<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaInstructions", ["type WritableAccount"])
+    );
   }
-  return fragment(`ReadonlyAccount<${typeParam}>`).addImports("solanaInstructions", "type ReadonlyAccount");
+  return (0, import_visitors_core11.pipe)(
+    fragment(`ReadonlyAccount<${typeParam}>`),
+    (f) => addFragmentImports(f, "solanaInstructions", ["type ReadonlyAccount"])
+  );
 }
 
 // src/fragments/instructionAccountTypeParam.ts
 var import_nodes10 = require("@codama/nodes");
-var import_visitors_core7 = require("@codama/visitors-core");
+var import_visitors_core12 = require("@codama/visitors-core");
 function getInstructionAccountTypeParamFragment(scope) {
   const { instructionAccountPath, allowAccountMeta, linkables } = scope;
-  const instructionAccountNode = (0, import_visitors_core7.getLastNodeFromPath)(instructionAccountPath);
-  const instructionNode = (0, import_visitors_core7.findInstructionNodeFromPath)(instructionAccountPath);
-  const programNode = (0, import_visitors_core7.findProgramNodeFromPath)(instructionAccountPath);
+  const instructionAccountNode = (0, import_visitors_core12.getLastNodeFromPath)(instructionAccountPath);
+  const instructionNode = (0, import_visitors_core12.findInstructionNodeFromPath)(instructionAccountPath);
+  const programNode = (0, import_visitors_core12.findProgramNodeFromPath)(instructionAccountPath);
   const typeParam = `TAccount${(0, import_nodes10.pascalCase)(instructionAccountNode.name)}`;
   const accountMeta = allowAccountMeta ? " | AccountMeta<string>" : "";
   const imports = new ImportMap();
@@ -714,10 +758,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 (0, import_visitors_core12.pipe)(
+      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 (0, import_visitors_core12.pipe)(
+    fragment(`${typeParam} extends string${accountMeta} = ${defaultAddress}`),
+    (f) => mergeFragmentImports(f, [imports])
+  );
 }
 function getDefaultAddress(defaultValue, programId, linkables) {
   switch (defaultValue?.kind) {
@@ -735,19 +785,20 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 
 // src/fragments/instructionByteDelta.ts
 var import_nodes11 = require("@codama/nodes");
-var import_visitors_core8 = require("@codama/visitors-core");
+var import_renderers_core3 = require("@codama/renderers-core");
+var import_visitors_core13 = require("@codama/visitors-core");
 function getInstructionByteDeltaFragment(scope) {
-  const { byteDeltas } = (0, import_visitors_core8.getLastNodeFromPath)(scope.instructionPath);
-  const fragments = (byteDeltas ?? []).flatMap((r) => getByteDeltaFragment(r, scope));
+  const { byteDeltas } = (0, import_visitors_core13.getLastNodeFromPath)(scope.instructionPath);
+  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 ((0, import_nodes11.isNode)(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
@@ -764,10 +815,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 = (0, import_visitors_core13.pipe)(
+      bytesFragment,
+      (f) => (0, import_renderers_core3.mapFragmentContent)(f, (c) => `${c} + BASE_ACCOUNT_SIZE`),
+      (f) => addFragmentImports(f, "solanaAccounts", ["BASE_ACCOUNT_SIZE"])
+    );
   }
   if (byteDelta.subtract) {
-    bytesFragment.mapRender((r) => `- (${r})`);
+    bytesFragment = (0, import_visitors_core13.pipe)(bytesFragment, (f) => (0, import_renderers_core3.mapFragmentContent)(f, (c) => `- (${c})`));
   }
   return [bytesFragment];
 }
@@ -783,7 +838,8 @@ function getArgumentValueNodeFragment(byteDelta) {
 function getAccountLinkNodeFragment(byteDelta, scope) {
   (0, import_nodes11.assertIsNode)(byteDelta.value, "accountLinkNode");
   const functionName = scope.nameApi.accountGetSizeFunction(byteDelta.value.name);
-  return fragment(`${functionName}()`).addImports(scope.getImportFrom(byteDelta.value), functionName);
+  const module2 = scope.getImportFrom(byteDelta.value);
+  return (0, import_visitors_core13.pipe)(fragment(`${functionName}()`), (f) => addFragmentImports(f, module2, [functionName]));
 }
 function getResolverValueNodeFragment(byteDelta, scope) {
   (0, import_nodes11.assertIsNode)(byteDelta.value, "resolverValueNode");
@@ -791,15 +847,20 @@ 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 module2 = scope.getImportFrom(byteDelta.value);
+  return (0, import_visitors_core13.pipe)(
+    fragment(`${awaitKeyword}${functionName}(resolverScope)`),
+    (f) => addFragmentImports(f, module2, [functionName]),
+    (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+  );
 }
 
 // src/fragments/instructionData.ts
 var import_nodes12 = require("@codama/nodes");
-var import_visitors_core9 = require("@codama/visitors-core");
+var import_visitors_core14 = require("@codama/visitors-core");
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = (0, import_visitors_core9.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
   if (instructionNode.arguments.length === 0 || customInstructionData.has(instructionNode.name)) {
     return fragment("");
   }
@@ -815,10 +876,11 @@ function getInstructionDataFragment(scope) {
 
 // src/fragments/discriminatorConstants.ts
 var import_nodes13 = require("@codama/nodes");
-var import_visitors_core10 = require("@codama/visitors-core");
+var import_renderers_core4 = require("@codama/renderers-core");
+var import_visitors_core15 = require("@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) {
@@ -835,8 +897,8 @@ function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
   const index = discriminatorNodes.filter((0, import_nodes13.isNodeFilter)("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
   const name = (0, import_nodes13.camelCase)(`${prefix}_discriminator${suffix}`);
-  const encoder = (0, import_visitors_core10.visit)(discriminatorNode.constant.type, typeManifestVisitor).encoder;
-  const value = (0, import_visitors_core10.visit)(discriminatorNode.constant.value, typeManifestVisitor).value;
+  const encoder = (0, import_visitors_core15.visit)(discriminatorNode.constant.type, typeManifestVisitor).encoder;
+  const value = (0, import_visitors_core15.visit)(discriminatorNode.constant.value, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
@@ -846,8 +908,8 @@ function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
     return null;
   }
   const name = (0, import_nodes13.camelCase)(`${prefix}_${discriminatorNode.name}`);
-  const encoder = (0, import_visitors_core10.visit)(field.type, typeManifestVisitor).encoder;
-  const value = (0, import_visitors_core10.visit)(field.defaultValue, typeManifestVisitor).value;
+  const encoder = (0, import_visitors_core15.visit)(field.type, typeManifestVisitor).encoder;
+  const value = (0, import_visitors_core15.visit)(field.defaultValue, typeManifestVisitor).value;
   return getConstantFragment({ ...scope, encoder, name, value });
 }
 function getConstantFragment(scope) {
@@ -856,40 +918,49 @@ 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}); }`)
+      (0, import_renderers_core4.mapFragmentContent)(value, (c) => `export const ${constantName} = ${c};`),
+      (0, import_renderers_core4.mapFragmentContent)(
+        encoder,
+        (c) => `export function ${constantFunction}() { return ${c}.encode(${constantName}); }`
+      )
     ],
-    (r) => r.join("\n\n")
+    (c) => c.join("\n\n")
   );
 }
 
 // src/fragments/instructionExtraArgs.ts
-var import_visitors_core11 = require("@codama/visitors-core");
+var import_visitors_core16 = require("@codama/visitors-core");
 function getInstructionExtraArgsFragment(scope) {
   const { instructionPath, extraArgsManifest, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core11.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(instructionPath);
   if ((instructionNode.extraArguments ?? []).length === 0) {
     return fragment("");
   }
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
-  return fragmentFromTemplate("instructionExtraArgs.njk", {
-    looseName: nameApi.dataArgsType(instructionExtraName),
-    manifest: extraArgsManifest,
-    strictName: nameApi.dataType(instructionExtraName)
-  }).mergeImportsWith(extraArgsManifest.looseType);
+  return (0, import_visitors_core16.pipe)(
+    fragmentFromTemplate("instructionExtraArgs.njk", {
+      looseName: nameApi.dataArgsType(instructionExtraName),
+      manifest: extraArgsManifest,
+      strictName: nameApi.dataType(instructionExtraName)
+    }),
+    (f) => mergeFragmentImports(f, [extraArgsManifest.looseType.imports])
+  );
 }
 
 // src/fragments/instructionFunction.ts
 var import_nodes18 = require("@codama/nodes");
-var import_visitors_core16 = require("@codama/visitors-core");
+var import_renderers_core8 = require("@codama/renderers-core");
+var import_visitors_core21 = require("@codama/visitors-core");
 
 // src/fragments/instructionInputResolved.ts
 var import_nodes15 = require("@codama/nodes");
-var import_visitors_core13 = require("@codama/visitors-core");
+var import_renderers_core6 = require("@codama/renderers-core");
+var import_visitors_core18 = require("@codama/visitors-core");
 
 // src/fragments/instructionInputDefault.ts
 var import_nodes14 = require("@codama/nodes");
-var import_visitors_core12 = require("@codama/visitors-core");
+var import_renderers_core5 = require("@codama/renderers-core");
+var import_visitors_core17 = require("@codama/visitors-core");
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
   if (!input.defaultValue) {
@@ -919,97 +990,142 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
     case "accountValueNode":
       const name = (0, import_nodes14.camelCase)(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
-        return defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`).addImports(
-          "shared",
-          "expectTransactionSigner"
+        return (0, import_visitors_core17.pipe)(
+          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 (0, import_visitors_core17.pipe)(
+          defaultFragment(`expectSome(accounts.${name}.value)`),
+          (f) => addFragmentImports(f, "shared", ["expectSome"])
+        );
       }
-      return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
+      return (0, import_visitors_core17.pipe)(
+        defaultFragment(`expectAddress(accounts.${name}.value)`),
+        (f) => addFragmentImports(f, "shared", ["expectAddress"])
+      );
     case "pdaValueNode":
       if ((0, import_nodes14.isNode)(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 ? (0, import_visitors_core17.pipe)(
+          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 ((0, import_nodes14.isNode)(seed, "constantPdaSeedNode") && (0, import_nodes14.isNode)(seed.value, "programIdValueNode")) {
             return [
-              fragment(`getAddressEncoder().encode(${pdaProgram.render})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
+              (0, import_visitors_core17.pipe)(
+                fragment(`getAddressEncoder().encode(${pdaProgram.content})`),
+                (f) => mergeFragmentImports(f, [pdaProgram.imports]),
+                (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
+              )
             ];
           }
           if ((0, import_nodes14.isNode)(seed, "constantPdaSeedNode") && !(0, import_nodes14.isNode)(seed.value, "programIdValueNode")) {
-            const typeManifest2 = (0, import_visitors_core12.visit)(seed.type, typeManifestVisitor);
-            const valueManifest2 = (0, import_visitors_core12.visit)(seed.value, typeManifestVisitor);
+            const typeManifest2 = (0, import_visitors_core17.visit)(seed.type, typeManifestVisitor);
+            const valueManifest2 = (0, import_visitors_core17.visit)(seed.value, typeManifestVisitor);
             return [
-              fragment(
-                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
-              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
+              (0, import_visitors_core17.pipe)(
+                fragment(`${typeManifest2.encoder.content}.encode(${valueManifest2.value.content})`),
+                (f) => mergeFragmentImports(f, [
+                  typeManifest2.encoder.imports,
+                  valueManifest2.value.imports
+                ])
+              )
             ];
           }
           if ((0, import_nodes14.isNode)(seed, "variablePdaSeedNode")) {
-            const typeManifest2 = (0, import_visitors_core12.visit)(seed.type, typeManifestVisitor);
+            const typeManifest2 = (0, import_visitors_core17.visit)(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
             if ((0, import_nodes14.isNode)(valueSeed, "accountValueNode")) {
               return [
-                fragment(
-                  `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${(0, import_nodes14.camelCase)(valueSeed.name)}.value))`
-                ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
+                (0, import_visitors_core17.pipe)(
+                  fragment(
+                    `${typeManifest2.encoder.content}.encode(expectAddress(accounts.${(0, import_nodes14.camelCase)(valueSeed.name)}.value))`
+                  ),
+                  (f) => mergeFragmentImports(f, [typeManifest2.encoder.imports]),
+                  (f) => addFragmentImports(f, "shared", ["expectAddress"])
+                )
               ];
             }
             if ((0, import_nodes14.isNode)(valueSeed, "argumentValueNode")) {
               return [
-                fragment(
-                  `${typeManifest2.encoder.render}.encode(expectSome(args.${(0, import_nodes14.camelCase)(valueSeed.name)}))`
-                ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectSome")
+                (0, import_visitors_core17.pipe)(
+                  fragment(
+                    `${typeManifest2.encoder.content}.encode(expectSome(args.${(0, import_nodes14.camelCase)(valueSeed.name)}))`
+                  ),
+                  (f) => mergeFragmentImports(f, [typeManifest2.encoder.imports]),
+                  (f) => addFragmentImports(f, "shared", ["expectSome"])
+                )
               ];
             }
-            const valueManifest2 = (0, import_visitors_core12.visit)(valueSeed, typeManifestVisitor);
+            const valueManifest2 = (0, import_visitors_core17.visit)(valueSeed, typeManifestVisitor);
             return [
-              fragment(
-                `${typeManifest2.encoder.render}.encode(${valueManifest2.value.render})`
-              ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
+              (0, import_visitors_core17.pipe)(
+                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 (0, import_visitors_core17.pipe)(
+          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) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => defaultFragment(c).content)
+        );
       }
       const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
         if ((0, import_nodes14.isNode)(seed.value, "accountValueNode")) {
-          return fragment(
-            `${seed.name}: expectAddress(accounts.${(0, import_nodes14.camelCase)(seed.value.name)}.value)`
-          ).addImports("shared", "expectAddress");
+          return (0, import_visitors_core17.pipe)(
+            fragment(`${seed.name}: expectAddress(accounts.${(0, import_nodes14.camelCase)(seed.value.name)}.value)`),
+            (f) => addFragmentImports(f, "shared", ["expectAddress"])
+          );
         }
         if ((0, import_nodes14.isNode)(seed.value, "argumentValueNode")) {
-          return fragment(`${seed.name}: expectSome(args.${(0, import_nodes14.camelCase)(seed.value.name)})`).addImports(
-            "shared",
-            "expectSome"
+          return (0, import_visitors_core17.pipe)(
+            fragment(`${seed.name}: expectSome(args.${(0, import_nodes14.camelCase)(seed.value.name)})`),
+            (f) => addFragmentImports(f, "shared", ["expectSome"])
           );
         }
-        return (0, import_visitors_core12.visit)(seed.value, typeManifestVisitor).value.mapRender((r) => `${seed.name}: ${r}`);
+        return (0, import_visitors_core17.pipe)(
+          (0, import_visitors_core17.visit)(seed.value, typeManifestVisitor).value,
+          (f) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => `${seed.name}: ${c}`)
+        );
       });
-      const pdaSeedsFragment = mergeFragments(pdaSeeds, (renders) => renders.join(", ")).mapRender((r) => `{ ${r} }`);
+      const pdaSeedsFragment = (0, import_visitors_core17.pipe)(
+        mergeFragments(pdaSeeds, (renders) => renders.join(", ")),
+        (f) => (0, import_renderers_core5.mapFragmentContent)(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 module2 = getImportFrom(defaultValue.pda);
+      return (0, import_visitors_core17.pipe)(
+        defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`),
+        (f) => mergeFragmentImports(f, [pdaSeedsFragment.imports]),
+        (f) => addFragmentImports(f, module2, [pdaFunction])
+      );
     case "publicKeyValueNode":
-      return defaultFragment(`'${defaultValue.publicKey}' as Address<'${defaultValue.publicKey}'>`).addImports(
-        "solanaAddresses",
-        "type Address"
+      return (0, import_visitors_core17.pipe)(
+        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 (0, import_visitors_core17.pipe)(
+        defaultFragment(programAddress, false),
+        (f) => addFragmentImports(f, getImportFrom(defaultValue), [programAddress])
+      );
     case "programIdValueNode":
       if (optionalAccountStrategy === "programId" && input.kind === "instructionAccountNode" && input.isOptional) {
         return fragment("");
@@ -1019,18 +1135,23 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
     case "payerValueNode":
       return fragment("");
     case "accountBumpValueNode":
-      return defaultFragment(
-        `expectProgramDerivedAddress(accounts.${(0, import_nodes14.camelCase)(defaultValue.name)}.value)[1]`
-      ).addImports("shared", "expectProgramDerivedAddress");
+      return (0, import_visitors_core17.pipe)(
+        defaultFragment(`expectProgramDerivedAddress(accounts.${(0, import_nodes14.camelCase)(defaultValue.name)}.value)[1]`),
+        (f) => addFragmentImports(f, "shared", ["expectProgramDerivedAddress"])
+      );
     case "argumentValueNode":
-      return defaultFragment(`expectSome(args.${(0, import_nodes14.camelCase)(defaultValue.name)})`).addImports(
-        "shared",
-        "expectSome"
+      return (0, import_visitors_core17.pipe)(
+        defaultFragment(`expectSome(args.${(0, import_nodes14.camelCase)(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 (0, import_visitors_core17.pipe)(
+        defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
+        (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
+        (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+      );
     case "conditionalValueNode":
       const ifTrueRenderer = renderNestedInstructionDefault({
         ...scope,
@@ -1043,49 +1164,56 @@ 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 ((0, import_nodes14.isNode)(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
-        conditionalFragment.addImports(getImportFrom(defaultValue.condition), conditionalResolverFunction).addFeatures(["instruction:resolverScopeVariable"]);
+        const module3 = getImportFrom(defaultValue.condition);
+        conditionalFragment = (0, import_visitors_core17.pipe)(
+          conditionalFragment,
+          (f) => addFragmentImports(f, module3, [conditionalResolverFunction]),
+          (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+        );
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
         const comparedInputName = (0, import_nodes14.isNode)(defaultValue.condition, "accountValueNode") ? `accounts.${(0, import_nodes14.camelCase)(defaultValue.condition.name)}.value` : `args.${(0, import_nodes14.camelCase)(defaultValue.condition.name)}`;
         if (defaultValue.value) {
-          const comparedValue = (0, import_visitors_core12.visit)(defaultValue.value, typeManifestVisitor).value;
-          conditionalFragment.mergeImportsWith(comparedValue).mergeFeaturesWith(comparedValue);
+          const comparedValue = (0, import_visitors_core17.visit)(defaultValue.value, typeManifestVisitor).value;
+          conditionalFragment = mergeFragments([conditionalFragment, comparedValue], (c) => c[0]);
           const operator = negatedCondition ? "!==" : "===";
-          condition = `${comparedInputName} ${operator} ${comparedValue.render}`;
+          condition = `${comparedInputName} ${operator} ${comparedValue.content}`;
         } else {
           condition = negatedCondition ? `!${comparedInputName}` : comparedInputName;
         }
       }
       if (ifTrueRenderer && ifFalseRenderer) {
-        return conditionalFragment.setRender(
+        return (0, import_renderers_core5.setFragmentContent)(
+          conditionalFragment,
           `if (${condition}) {
-${ifTrueRenderer.render}
+${ifTrueRenderer.content}
 } else {
-${ifFalseRenderer.render}
+${ifFalseRenderer.content}
 }`
         );
       }
-      return conditionalFragment.setRender(
+      return (0, import_renderers_core5.setFragmentContent)(
+        conditionalFragment,
         `if (${condition}) {
-${ifTrueRenderer ? ifTrueRenderer.render : ifFalseRenderer?.render}
+${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
 }`
       );
     default:
-      const valueManifest = (0, import_visitors_core12.visit)(defaultValue, typeManifestVisitor).value;
-      return defaultFragment(valueManifest.render).mergeImportsWith(valueManifest);
+      const valueManifest = (0, import_visitors_core17.visit)(defaultValue, typeManifestVisitor).value;
+      return (0, import_visitors_core17.pipe)(valueManifest, (f) => (0, import_renderers_core5.mapFragmentContent)(f, (c) => defaultFragment(c).content));
   }
 }
 function renderNestedInstructionDefault(scope) {
@@ -1099,21 +1227,22 @@ function renderNestedInstructionDefault(scope) {
 
 // src/fragments/instructionInputResolved.ts
 function getInstructionInputResolvedFragment(scope) {
-  const instructionNode = (0, import_visitors_core13.getLastNodeFromPath)(scope.instructionPath);
+  const instructionNode = (0, import_visitors_core18.getLastNodeFromPath)(scope.instructionPath);
   const resolvedInputFragments = scope.resolvedInputs.flatMap((input) => {
     const inputFragment = getInstructionInputDefaultFragment({
       ...scope,
       input,
       optionalAccountStrategy: (0, import_nodes15.parseOptionalAccountStrategy)(instructionNode.optionalAccountStrategy)
     });
-    if (!inputFragment.render) return [];
+    if (!inputFragment.content) return [];
     const camelName = (0, import_nodes15.camelCase)(input.name);
     return [
-      inputFragment.mapRender(
-        (r) => (0, import_nodes15.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
-${r}
+      (0, import_renderers_core6.mapFragmentContent)(
+        inputFragment,
+        (c) => (0, import_nodes15.isNode)(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+${c}
 }` : `if (!accounts.${camelName}.value) {
-${r}
+${c}
 }`
       )
     ];
@@ -1121,42 +1250,44 @@ ${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
 var import_nodes16 = require("@codama/nodes");
-var import_visitors_core14 = require("@codama/visitors-core");
+var import_renderers_core7 = require("@codama/renderers-core");
+var import_visitors_core19 = require("@codama/visitors-core");
 function getInstructionInputTypeFragment(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core19.getLastNodeFromPath)(instructionPath);
   const instructionInputType = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   const accountsFragment = getAccountsFragment(scope);
   const [dataArgumentsFragment, customDataArgumentsFragment] = getDataArgumentsFragments(scope);
   const extraArgumentsFragment = getExtraArgumentsFragment(scope);
   const remainingAccountsFragment = getRemainingAccountsFragment(instructionNode);
-  return fragmentFromTemplate("instructionInputType.njk", {
-    accountsFragment,
-    customDataArgumentsFragment,
-    dataArgumentsFragment,
-    extraArgumentsFragment,
-    instruction: instructionNode,
-    instructionInputType,
-    remainingAccountsFragment
-  }).mergeImportsWith(
-    accountsFragment,
-    dataArgumentsFragment,
-    customDataArgumentsFragment,
-    extraArgumentsFragment,
-    remainingAccountsFragment
-  ).addImports("solanaAddresses", ["type Address"]);
+  return (0, import_visitors_core19.pipe)(
+    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;
-  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core19.getLastNodeFromPath)(instructionPath);
   const fragments = instructionNode.accounts.map((account) => {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
@@ -1165,38 +1296,55 @@ function getAccountsFragment(scope) {
     const accountDocs = (0, import_nodes16.parseDocs)(account.docs);
     const docblock = accountDocs.length > 0 ? jsDocblock(accountDocs) : "";
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
-    return getAccountTypeFragment2(resolvedAccount).mapRender(
-      (r) => `${docblock}${(0, import_nodes16.camelCase)(account.name)}${optionalSign}: ${r};`
+    return (0, import_renderers_core7.mapFragmentContent)(
+      getAccountTypeFragment2(resolvedAccount),
+      (c) => `${docblock}${(0, import_nodes16.camelCase)(account.name)}${optionalSign}: ${c};`
     );
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 function getAccountTypeFragment2(account) {
   const typeParam = `TAccount${(0, import_nodes16.pascalCase)(account.name)}`;
   if (account.isPda && account.isSigner === false) {
-    return fragment(`ProgramDerivedAddress<${typeParam}>`).addImports("solanaAddresses", [
-      "type ProgramDerivedAddress"
-    ]);
+    return (0, import_visitors_core19.pipe)(
+      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 (0, import_visitors_core19.pipe)(
+      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 (0, import_visitors_core19.pipe)(
+      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 (0, import_visitors_core19.pipe)(
+      fragment(`TransactionSigner<${typeParam}>`),
+      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
+    );
   }
-  return fragment(`Address<${typeParam}>`).addImports("solanaAddresses", ["type Address"]);
+  return (0, import_visitors_core19.pipe)(fragment(`Address<${typeParam}>`), (f) => addFragmentImports(f, "solanaAddresses", ["type Address"]));
 }
 function getDataArgumentsFragments(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core19.getLastNodeFromPath)(instructionPath);
   const customData = scope.customInstructionData.get(instructionNode.name);
   if (customData) {
     return [
       fragment(""),
-      fragment(nameApi.dataArgsType(customData.importAs)).mergeImportsWith(scope.dataArgsManifest.looseType).mapRender((r) => `${r} & `)
+      (0, import_visitors_core19.pipe)(
+        fragment(nameApi.dataArgsType(customData.importAs)),
+        (f) => mergeFragmentImports(f, [scope.dataArgsManifest.looseType.imports]),
+        (f) => (0, import_renderers_core7.mapFragmentContent)(f, (c) => `${c} & `)
+      )
     ];
   }
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
@@ -1205,18 +1353,18 @@ 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;
-  const instructionNode = (0, import_visitors_core14.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core19.getLastNodeFromPath)(instructionPath);
   const instructionExtraName = nameApi.instructionExtraType(instructionNode.name);
   const extraArgsType = nameApi.dataArgsType(instructionExtraName);
   const fragments = (instructionNode.extraArguments ?? []).flatMap((arg) => {
     const argFragment = getArgumentFragment(arg, fragment(extraArgsType), scope.resolvedInputs, scope.renamedArgs);
     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(
@@ -1225,7 +1373,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) => `${(0, import_nodes16.camelCase)(renamedName)}${optionalSign}: ${r}["${(0, import_nodes16.camelCase)(arg.name)}"];`);
+  return (0, import_renderers_core7.mapFragmentContent)(
+    argsType,
+    (c) => `${(0, import_nodes16.camelCase)(renamedName)}${optionalSign}: ${c}["${(0, import_nodes16.camelCase)(arg.name)}"];`
+  );
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
@@ -1236,30 +1387,42 @@ 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) => `${(0, import_nodes16.camelCase)(name)}${optionalSign}: Array<${r}>;`);
+    const signerFragment = (0, import_visitors_core19.pipe)(
+      fragment(`TransactionSigner`),
+      (f) => addFragmentImports(f, "solanaSigners", ["type TransactionSigner"])
+    );
+    const addressFragment = (0, import_visitors_core19.pipe)(
+      fragment(`Address`),
+      (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+    );
+    return (0, import_renderers_core7.mapFragmentContent)(
+      (() => {
+        if (isSigner === "either") {
+          return mergeFragments([signerFragment, addressFragment], (c) => c.join(" | "));
+        }
+        return isSigner ? signerFragment : addressFragment;
+      })(),
+      (c) => `${(0, import_nodes16.camelCase)(name)}${optionalSign}: Array<${c}>;`
+    );
   });
-  return mergeFragments(fragments, (r) => r.join("\n"));
+  return mergeFragments(fragments, (c) => c.join("\n"));
 }
 
 // src/fragments/instructionRemainingAccounts.ts
 var import_nodes17 = require("@codama/nodes");
-var import_visitors_core15 = require("@codama/visitors-core");
+var import_visitors_core20 = require("@codama/visitors-core");
 function getInstructionRemainingAccountsFragment(scope) {
-  const { remainingAccounts } = (0, import_visitors_core15.getLastNodeFromPath)(scope.instructionPath);
-  const fragments = (remainingAccounts ?? []).flatMap((r) => getRemainingAccountsFragment2(r, scope));
+  const { remainingAccounts } = (0, import_visitors_core20.getLastNodeFromPath)(scope.instructionPath);
+  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 (0, import_visitors_core20.pipe)(
+    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 = (() => {
@@ -1275,7 +1438,7 @@ function getRemainingAccountsFragment2(remainingAccounts, scope) {
   return [remainingAccountsFragment];
 }
 function getArgumentValueNodeFragment2(remainingAccounts, scope) {
-  const instructionNode = (0, import_visitors_core15.getLastNodeFromPath)(scope.instructionPath);
+  const instructionNode = (0, import_visitors_core20.getLastNodeFromPath)(scope.instructionPath);
   (0, import_nodes17.assertIsNode)(remainingAccounts.value, "argumentValueNode");
   const argumentName = (0, import_nodes17.camelCase)(remainingAccounts.value.name);
   const isOptional = remainingAccounts.isOptional ?? false;
@@ -1288,22 +1451,27 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
   const allArguments = (0, import_nodes17.getAllInstructionArguments)(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 (0, import_visitors_core20.pipe)(
+      fragment(`${argumentArray}.map((address) => ({ address, role: ${role} }))`),
+      (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"])
     );
   }
   if (isSigner === "either") {
-    return fragment(
-      `${argumentArray}.map((addressOrSigner) => (isTransactionSigner(addressOrSigner)
+    return (0, import_visitors_core20.pipe)(
+      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 (0, import_visitors_core20.pipe)(
+    fragment(`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`),
+    (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole"])
+  );
 }
 function getResolverValueNodeFragment2(remainingAccounts, scope) {
   (0, import_nodes17.assertIsNode)(remainingAccounts.value, "resolverValueNode");
@@ -1311,7 +1479,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 module2 = scope.getImportFrom(remainingAccounts.value);
+  return (0, import_visitors_core20.pipe)(
+    fragment(`${awaitKeyword}${functionName}(resolverScope)`),
+    (f) => addFragmentImports(f, module2, [functionName]),
+    (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
+  );
 }
 
 // src/fragments/instructionFunction.ts
@@ -1326,8 +1499,8 @@ function getInstructionFunctionFragment(scope) {
     nameApi,
     customInstructionData
   } = scope;
-  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(instructionPath);
-  const programNode = (0, import_visitors_core16.findProgramNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core21.getLastNodeFromPath)(instructionPath);
+  const programNode = (0, import_visitors_core21.findProgramNodeFromPath)(instructionPath);
   if (useAsync && !hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers)) {
     return fragment("");
   }
@@ -1353,13 +1526,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 = (0, import_visitors_core21.pipe)(
+    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);
@@ -1371,11 +1542,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) {
@@ -1383,54 +1554,59 @@ 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 (0, import_visitors_core21.pipe)(
+    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${(0, import_nodes18.pascalCase)(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 (0, import_visitors_core21.pipe)(
+    fragment(typeParams.filter((x) => !!x).join(", ")),
+    (f) => (0, import_renderers_core8.mapFragmentContent)(f, (c) => `<${c}>`),
+    (f) => addFragmentImports(f, "generatedPrograms", [programAddressConstant])
+  );
 }
 function getInstructionType(scope) {
   const { instructionPath, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core21.getLastNodeFromPath)(instructionPath);
   const instructionTypeName = nameApi.instructionType(instructionNode.name);
   const programAddressFragment = fragment("TProgramAddress");
   const accountTypeParamsFragments = instructionNode.accounts.map((account) => {
@@ -1438,20 +1614,24 @@ function getInstructionType(scope) {
     const camelName = (0, import_nodes18.camelCase)(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 (0, import_visitors_core21.pipe)(
+        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 (0, import_visitors_core21.pipe)(
+    mergeFragments([programAddressFragment, ...accountTypeParamsFragments], (c) => c.join(", ")),
+    (f) => (0, import_renderers_core8.mapFragmentContent)(f, (c) => `${instructionTypeName}<${c}>`)
+  );
 }
 function getInputTypeCall(scope) {
   const { instructionPath, useAsync, nameApi } = scope;
-  const instructionNode = (0, import_visitors_core16.getLastNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core21.getLastNodeFromPath)(instructionPath);
   const inputTypeName = useAsync ? nameApi.instructionAsyncInputType(instructionNode.name) : nameApi.instructionSyncInputType(instructionNode.name);
   if (instructionNode.accounts.length === 0) return fragment(inputTypeName);
   const accountTypeParams = instructionNode.accounts.map((account) => `TAccount${(0, import_nodes18.pascalCase)(account.name)}`).join(", ");
@@ -1459,11 +1639,11 @@ function getInputTypeCall(scope) {
 }
 
 // src/fragments/instructionParseFunction.ts
-var import_visitors_core17 = require("@codama/visitors-core");
+var import_visitors_core22 = require("@codama/visitors-core");
 function getInstructionParseFunctionFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
-  const instructionNode = (0, import_visitors_core17.getLastNodeFromPath)(instructionPath);
-  const programNode = (0, import_visitors_core17.findProgramNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core22.getLastNodeFromPath)(instructionPath);
+  const programNode = (0, import_visitors_core22.findProgramNodeFromPath)(instructionPath);
   const customData = customInstructionData.get(instructionNode.name);
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasOptionalAccounts = instructionNode.accounts.some((account) => account.isOptional);
@@ -1471,34 +1651,44 @@ 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 ? (0, import_visitors_core22.pipe)(
+    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 (0, import_visitors_core22.pipe)(
+    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
 var import_nodes19 = require("@codama/nodes");
-var import_visitors_core18 = require("@codama/visitors-core");
+var import_renderers_core9 = require("@codama/renderers-core");
+var import_visitors_core23 = require("@codama/visitors-core");
 function getInstructionTypeFragment(scope) {
   const { instructionPath, nameApi, customInstructionData } = scope;
-  const instructionNode = (0, import_visitors_core18.getLastNodeFromPath)(instructionPath);
-  const programNode = (0, import_visitors_core18.findProgramNodeFromPath)(instructionPath);
+  const instructionNode = (0, import_visitors_core23.getLastNodeFromPath)(instructionPath);
+  const programNode = (0, import_visitors_core23.findProgramNodeFromPath)(instructionPath);
   const hasAccounts = instructionNode.accounts.length > 0;
   const customData = customInstructionData.get(instructionNode.name);
   const hasData = !!customData || instructionNode.arguments.length > 0;
@@ -1518,45 +1708,50 @@ function getInstructionTypeFragment(scope) {
   const usesLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted";
   const accountMetasFragment = mergeFragments(
     instructionNode.accounts.map(
-      (account) => getInstructionAccountMetaFragment(account).mapRender((r) => {
+      (account) => (0, import_renderers_core9.mapFragmentContent)(getInstructionAccountMetaFragment(account), (c) => {
         const typeParam = `TAccount${(0, import_nodes19.pascalCase)(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 = (0, import_visitors_core23.pipe)(
+    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
 var import_nodes20 = require("@codama/nodes");
-var import_visitors_core19 = require("@codama/visitors-core");
+var import_visitors_core24 = require("@codama/visitors-core");
 function getPdaFunctionFragment(scope) {
   const { pdaPath, typeManifestVisitor, nameApi } = scope;
-  const pdaNode = (0, import_visitors_core19.getLastNodeFromPath)(pdaPath);
-  const programNode = (0, import_visitors_core19.findProgramNodeFromPath)(pdaPath);
+  const pdaNode = (0, import_visitors_core24.getLastNodeFromPath)(pdaPath);
+  const programNode = (0, import_visitors_core24.findProgramNodeFromPath)(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
     if ((0, import_nodes20.isNode)(seed, "variablePdaSeedNode")) {
-      const seedManifest2 = (0, import_visitors_core19.visit)(seed.type, typeManifestVisitor);
+      const seedManifest2 = (0, import_visitors_core24.visit)(seed.type, typeManifestVisitor);
       imports.mergeWith(seedManifest2.looseType, seedManifest2.encoder);
       return { ...seed, typeManifest: seedManifest2 };
     }
@@ -1564,38 +1759,53 @@ function getPdaFunctionFragment(scope) {
       imports.add("solanaAddresses", "getAddressEncoder");
       return seed;
     }
-    const seedManifest = (0, import_visitors_core19.visit)(seed.type, typeManifestVisitor);
+    const seedManifest = (0, import_visitors_core24.visit)(seed.type, typeManifestVisitor);
     imports.mergeWith(seedManifest.encoder);
-    const valueManifest = (0, import_visitors_core19.visit)(seed.value, typeManifestVisitor).value;
+    const valueManifest = (0, import_visitors_core24.visit)(seed.value, typeManifestVisitor).value;
     imports.mergeWith(valueManifest.imports);
     return { ...seed, typeManifest: seedManifest, valueManifest };
   });
   const hasVariableSeeds = pdaNode.seeds.filter((0, import_nodes20.isNodeFilter)("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 (0, import_visitors_core24.pipe)(
+    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
+var import_visitors_core25 = require("@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 (0, import_visitors_core25.pipe)(
+    fragmentFromTemplate("program.njk", {
+      program: programNode,
+      programAddressConstant: nameApi.programAddressConstant(programNode.name)
+    }),
+    (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+  );
 }
 
 // src/fragments/programAccounts.ts
 var import_nodes21 = require("@codama/nodes");
+var import_renderers_core10 = require("@codama/renderers-core");
+var import_visitors_core26 = require("@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")}
 `
   );
 }
@@ -1616,46 +1826,59 @@ 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: (0, import_nodes21.resolveNestedTypeNode)(account.data)
-      });
-    }),
-    (r) => r.join("\n")
-  );
-  return discriminatorsFragment.mapRender(
-    (discriminators) => `export function ${programAccountsIdentifierFunction}(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programAccountsEnum} {
+  return (0, import_visitors_core26.pipe)(
+    mergeFragments(
+      accountsWithDiscriminators.map((account) => {
+        const variant = nameApi.programAccountsEnumVariant(account.name);
+        return getDiscriminatorConditionFragment({
+          ...scope,
+          dataName: "data",
+          discriminators: account.discriminators ?? [],
+          ifTrue: `return ${programAccountsEnum}.${variant};`,
+          struct: (0, import_nodes21.resolveNestedTypeNode)(account.data)
+        });
+      }),
+      (c) => c.join("\n")
+    ),
+    (f) => (0, import_renderers_core10.mapFragmentContent)(
+      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
+var import_visitors_core27 = require("@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 (0, import_visitors_core27.pipe)(
+    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
 var import_nodes22 = require("@codama/nodes");
+var import_renderers_core11 = require("@codama/renderers-core");
+var import_visitors_core28 = require("@codama/visitors-core");
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return fragment("");
   const allInstructions = (0, import_nodes22.getAllInstructionsWithSubs)(scope.programNode, {
@@ -1669,7 +1892,7 @@ function getProgramInstructionsFragment(scope) {
       getProgramInstructionsIdentifierFunctionFragment(scopeWithInstructions),
       getProgramInstructionsParsedUnionTypeFragment(scopeWithInstructions)
     ],
-    (r) => `${r.join("\n\n")}
+    (c) => `${c.join("\n\n")}
 `
   );
 }
@@ -1703,15 +1926,20 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         struct: (0, import_nodes22.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments)
       });
     }),
-    (r) => r.join("\n")
+    (c) => c.join("\n")
   );
-  return discriminatorsFragment.mapRender(
-    (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
+  return (0, import_visitors_core28.pipe)(
+    discriminatorsFragment,
+    (f) => (0, import_renderers_core11.mapFragmentContent)(
+      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,128 +1949,107 @@ 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 (0, import_visitors_core28.pipe)(
+      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
 var import_nodes23 = require("@codama/nodes");
+var import_visitors_core29 = require("@codama/visitors-core");
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
   const isDiscriminatedUnion = (0, import_nodes23.isNode)(typeNode, "enumTypeNode") && (0, import_nodes23.isDataEnum)(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 (0, import_visitors_core29.pipe)(
+    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
-var import_node_path3 = require("path");
-var import_errors2 = require("@codama/errors");
-var import_nodes26 = require("@codama/nodes");
-var import_renderers_core = require("@codama/renderers-core");
-var import_visitors_core21 = require("@codama/visitors-core");
-
 // src/getTypeManifestVisitor.ts
 var import_nodes24 = require("@codama/nodes");
-var import_visitors_core20 = require("@codama/visitors-core");
+var import_renderers_core12 = require("@codama/renderers-core");
+var import_visitors_core30 = require("@codama/visitors-core");
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums, customAccountData, customInstructionData, getImportFrom } = input;
-  const stack = input.stack ?? new import_visitors_core20.NodeStack();
+  const stack = input.stack ?? new import_visitors_core30.NodeStack();
   let parentName = null;
-  return (0, import_visitors_core20.pipe)(
-    (0, import_visitors_core20.staticVisitor)(
-      () => ({
-        decoder: fragment(""),
-        encoder: fragment(""),
-        isEnum: false,
-        looseType: fragment(""),
-        strictType: fragment(""),
-        value: fragment("")
-      }),
-      {
-        keys: [
-          ...import_nodes24.REGISTERED_TYPE_NODE_KINDS,
-          ...import_nodes24.REGISTERED_VALUE_NODE_KINDS,
-          "definedTypeLinkNode",
-          "definedTypeNode",
-          "accountNode",
-          "instructionNode"
-        ]
-      }
-    ),
-    (visitor) => (0, import_visitors_core20.extendVisitor)(visitor, {
+  return (0, import_visitors_core30.pipe)(
+    (0, import_visitors_core30.staticVisitor)(() => typeManifest(), {
+      keys: [
+        ...import_nodes24.REGISTERED_TYPE_NODE_KINDS,
+        ...import_nodes24.REGISTERED_VALUE_NODE_KINDS,
+        "definedTypeLinkNode",
+        "definedTypeNode",
+        "accountNode",
+        "instructionNode"
+      ]
+    }),
+    (visitor) => (0, import_visitors_core30.extendVisitor)(visitor, {
       visitAccount(account, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(account.name),
           strict: nameApi.dataType(account.name)
         };
         const link = customAccountData.get(account.name)?.linkNode;
-        const manifest = link ? (0, import_visitors_core20.visit)(link, self) : (0, import_visitors_core20.visit)(account.data, self);
+        const manifest = link ? (0, import_visitors_core30.visit)(link, self) : (0, import_visitors_core30.visit)(account.data, self);
         parentName = null;
         return manifest;
       },
       visitAmountType(amountType, { self }) {
-        return (0, import_visitors_core20.visit)(amountType.number, self);
+        return (0, import_visitors_core30.visit)(amountType.number, self);
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = (0, import_visitors_core20.visit)(arrayType.item, self);
-        childManifest.looseType.mapRender((r) => `Array<${r}>`);
-        childManifest.strictType.mapRender((r) => `Array<${r}>`);
+        const childManifest = (0, import_visitors_core30.visit)(arrayType.item, self);
         const sizeManifest = getArrayLikeSizeOption(arrayType.count, self);
-        const encoderOptions = sizeManifest.encoder.render ? `, { ${sizeManifest.encoder.render} }` : "";
-        const decoderOptions = sizeManifest.decoder.render ? `, { ${sizeManifest.decoder.render} }` : "";
-        childManifest.encoder.mapRender((r) => `getArrayEncoder(${r + encoderOptions})`).mergeImportsWith(sizeManifest.encoder).addImports("solanaCodecsDataStructures", "getArrayEncoder");
-        childManifest.decoder.mapRender((r) => `getArrayDecoder(${r + decoderOptions})`).mergeImportsWith(sizeManifest.decoder).addImports("solanaCodecsDataStructures", "getArrayDecoder");
-        return childManifest;
+        const encoderOptions = sizeManifest.encoder.content ? `, { ${sizeManifest.encoder.content} }` : "";
+        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        return typeManifest({
+          ...childManifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            childManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getArrayDecoder(${c + decoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.decoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getArrayDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            childManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getArrayEncoder(${c + encoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.encoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getArrayEncoder"])
+          ),
+          looseType: (0, import_renderers_core12.mapFragmentContent)(childManifest.looseType, (c) => `Array<${c}>`),
+          strictType: (0, import_renderers_core12.mapFragmentContent)(childManifest.strictType, (c) => `Array<${c}>`)
+        });
       },
       visitArrayValue(node, { self }) {
-        return mergeManifests(
-          node.items.map((v) => (0, import_visitors_core20.visit)(v, self)),
+        return mergeTypeManifests(
+          node.items.map((v) => (0, import_visitors_core30.visit)(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
@@ -1853,75 +2060,74 @@ function getTypeManifestVisitor(input) {
         let sizeDecoder = "";
         const resolvedSize = (0, import_nodes24.resolveNestedTypeNode)(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
-          const size = (0, import_visitors_core20.visit)(booleanType.size, self);
+          const size = (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(
+            fragment(`getBooleanDecoder(${sizeDecoder})`),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            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 = (0, import_visitors_core30.pipe)(
+          fragment("ReadonlyUint8Array"),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
+        );
+        return typeManifest({
+          decoder: (0, import_visitors_core30.pipe)(
+            fragment(`getBytesDecoder()`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getBytesDecoder"])
           ),
-          strictType: fragment("ReadonlyUint8Array").addImports(
-            "solanaCodecsCore",
-            "type ReadonlyUint8Array"
+          encoder: (0, import_visitors_core30.pipe)(
+            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 ((0, import_nodes24.isNode)(node.type, "bytesTypeNode") && (0, import_nodes24.isNode)(node.value, "bytesValueNode")) {
-          return (0, import_visitors_core20.visit)(node.value, self);
+          return (0, import_visitors_core30.visit)(node.value, self);
         }
-        return {
-          ...typeManifest(),
+        return typeManifest({
           value: mergeFragments(
-            [(0, import_visitors_core20.visit)(node.type, self).encoder, (0, import_visitors_core20.visit)(node.value, self).value],
+            [(0, import_visitors_core30.visit)(node.type, self).encoder, (0, import_visitors_core30.visit)(node.value, self).value],
             ([encoderFunction, value]) => `${encoderFunction}.encode(${value})`
           )
-        };
+        });
       },
       visitDateTimeType(dateTimeType, { self }) {
-        return (0, import_visitors_core20.visit)(dateTimeType.number, self);
+        return (0, import_visitors_core30.visit)(dateTimeType.number, self);
       },
       visitDefinedType(definedType, { self }) {
         parentName = {
           loose: nameApi.dataArgsType(definedType.name),
           strict: nameApi.dataType(definedType.name)
         };
-        const manifest = (0, import_visitors_core20.visit)(definedType.type, self);
+        const manifest = (0, import_visitors_core30.visit)(definedType.type, self);
         parentName = null;
         return manifest;
       },
@@ -1931,33 +2137,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: (0, import_visitors_core30.pipe)(
+            fragment(`${decoderFunction}()`),
+            (f) => addFragmentImports(f, importFrom, [decoderFunction])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            fragment(`${encoderFunction}()`),
+            (f) => addFragmentImports(f, importFrom, [encoderFunction])
+          ),
+          looseType: (0, import_visitors_core30.pipe)(
+            fragment(looseName),
+            (f) => addFragmentImports(f, importFrom, [`type ${looseName}`])
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            fragment(strictName),
+            (f) => addFragmentImports(f, importFrom, [`type ${strictName}`])
+          )
+        });
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
         const discriminator = nameApi.discriminatedUnionDiscriminator((0, import_nodes24.camelCase)(parentName?.strict ?? ""));
         const name = nameApi.discriminatedUnionVariant(enumEmptyVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
-        return {
-          decoder: fragment(`['${name}', getUnitDecoder()]`).addImports(
-            "solanaCodecsDataStructures",
-            "getUnitDecoder"
+        return typeManifest({
+          decoder: (0, import_visitors_core30.pipe)(
+            fragment(`['${name}', getUnitDecoder()]`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getUnitDecoder"])
           ),
-          encoder: fragment(`['${name}', getUnitEncoder()]`).addImports(
-            "solanaCodecsDataStructures",
-            "getUnitEncoder"
+          encoder: (0, import_visitors_core30.pipe)(
+            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;
@@ -1967,13 +2181,21 @@ function getTypeManifestVisitor(input) {
         const name = nameApi.discriminatedUnionVariant(enumStructVariantType.name);
         const kindAttribute = `${discriminator}: "${name}"`;
         parentName = null;
-        const structManifest = (0, import_visitors_core20.visit)(enumStructVariantType.struct, self);
+        const structManifest = (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(structManifest.decoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `['${name}', ${c}]`)),
+          encoder: (0, import_visitors_core30.pipe)(structManifest.encoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `['${name}', ${c}]`)),
+          looseType: (0, import_visitors_core30.pipe)(
+            structManifest.looseType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            structManifest.strictType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          )
+        });
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
         const currentParentName = parentName;
@@ -1989,13 +2211,21 @@ function getTypeManifestVisitor(input) {
           })
         ]);
         parentName = null;
-        const structManifest = (0, import_visitors_core20.visit)(struct, self);
+        const structManifest = (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(structManifest.decoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `['${name}', ${c}]`)),
+          encoder: (0, import_visitors_core30.pipe)(structManifest.encoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `['${name}', ${c}]`)),
+          looseType: (0, import_visitors_core30.pipe)(
+            structManifest.looseType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            structManifest.strictType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `{ ${kindAttribute},${c.slice(1, -1)}}`)
+          )
+        });
       },
       visitEnumType(enumType, { self }) {
         const currentParentName = parentName;
@@ -2005,11 +2235,11 @@ function getTypeManifestVisitor(input) {
         const decoderOptions = [];
         const enumSize = (0, import_nodes24.resolveNestedTypeNode)(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
-          const sizeManifest = (0, import_visitors_core20.visit)(enumType.size, self);
+          const sizeManifest = (0, import_visitors_core30.visit)(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(
           (0, import_nodes24.camelCase)(currentParentName?.strict ?? "")
@@ -2027,31 +2257,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: (0, import_visitors_core30.pipe)(
+              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: (0, import_visitors_core30.pipe)(
+              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(
-          enumType.variants.map((variant) => (0, import_visitors_core20.visit)(variant, self)),
+        const mergedManifest = mergeTypeManifests(
+          enumType.variants.map((variant) => (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(
+            mergedManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(
+              f,
+              (c) => `getDiscriminatedUnionDecoder([${c}]${decoderOptionsAsString})`
+            ),
+            (f) => mergeFragmentImports(f, [decoderImports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getDiscriminatedUnionDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergedManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(
+              f,
+              (c) => `getDiscriminatedUnionEncoder([${c}]${encoderOptionsAsString})`
+            ),
+            (f) => mergeFragmentImports(f, [encoderImports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getDiscriminatedUnionEncoder"])
+          )
+        });
       },
       visitEnumValue(node, { self }) {
         const manifest = typeManifest();
@@ -2062,40 +2311,108 @@ function getTypeManifestVisitor(input) {
         const isScalar = enumNode && (0, import_nodes24.isNode)(enumNode, "enumTypeNode") ? (0, import_nodes24.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: (0, import_visitors_core30.pipe)(
+              manifest.value,
+              (f) => (0, import_renderers_core12.setFragmentContent)(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: (0, import_visitors_core30.pipe)(
+              manifest.value,
+              (f) => (0, import_renderers_core12.setFragmentContent)(f, `${enumFunction}('${variantName}')`),
+              (f) => addFragmentImports(f, importFrom, [enumFunction])
+            )
+          });
         }
-        manifest.value = (0, import_visitors_core20.visit)(node.value, self).value.mapRender((r) => `${enumFunction}('${variantName}', ${r})`).addImports(importFrom, enumFunction);
-        return manifest;
+        return typeManifest({
+          ...manifest,
+          value: (0, import_visitors_core30.pipe)(
+            (0, import_visitors_core30.visit)(node.value, self).value,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `${enumFunction}('${variantName}', ${c})`),
+            (f) => addFragmentImports(f, importFrom, [enumFunction])
+          )
+        });
       },
       visitFixedSizeType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
-        manifest.encoder.mapRender((r) => `fixEncoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixEncoderSize");
-        manifest.decoder.mapRender((r) => `fixDecoderSize(${r}, ${node.size})`).addImports("solanaCodecsCore", "fixDecoderSize");
-        return manifest;
+        const manifest = (0, import_visitors_core30.visit)(node.type, self);
+        return typeManifest({
+          ...manifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            manifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `fixDecoderSize(${c}, ${node.size})`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["fixDecoderSize"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            manifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `fixEncoderSize(${c}, ${node.size})`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["fixEncoderSize"])
+          )
+        });
       },
       visitHiddenPrefixType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
-        const prefixes = node.prefix.map((c) => (0, import_visitors_core20.visit)(c, self).value);
-        const prefixEncoders = fragment(prefixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...prefixes);
-        const prefixDecoders = fragment(prefixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...prefixes);
-        manifest.encoder.mapRender((r) => `getHiddenPrefixEncoder(${r}, [${prefixEncoders.render}])`).mergeImportsWith(prefixEncoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixEncoder");
-        manifest.decoder.mapRender((r) => `getHiddenPrefixDecoder(${r}, [${prefixDecoders.render}])`).mergeImportsWith(prefixDecoders).addImports("solanaCodecsDataStructures", "getHiddenPrefixDecoder");
-        return manifest;
+        const manifest = (0, import_visitors_core30.visit)(node.type, self);
+        const prefixes = node.prefix.map((c) => (0, import_visitors_core30.visit)(c, self).value);
+        const prefixEncoders = (0, import_visitors_core30.pipe)(
+          mergeFragments(prefixes, (contents) => contents.map((c) => `getConstantEncoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
+        );
+        const prefixDecoders = (0, import_visitors_core30.pipe)(
+          mergeFragments(prefixes, (contents) => contents.map((c) => `getConstantDecoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
+        );
+        return typeManifest({
+          ...manifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.decoder, prefixDecoders],
+              ([child, prefixes2]) => `getHiddenPrefixDecoder(${child}, [${prefixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenPrefixDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.encoder, prefixEncoders],
+              ([child, prefixes2]) => `getHiddenPrefixEncoder(${child}, [${prefixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenPrefixEncoder"])
+          )
+        });
       },
       visitHiddenSuffixType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
-        const suffixes = node.suffix.map((c) => (0, import_visitors_core20.visit)(c, self).value);
-        const suffixEncoders = fragment(suffixes.map((c) => `getConstantEncoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantEncoder").mergeImportsWith(...suffixes);
-        const suffixDecoders = fragment(suffixes.map((c) => `getConstantDecoder(${c.render})`).join(", ")).addImports("solanaCodecsCore", "getConstantDecoder").mergeImportsWith(...suffixes);
-        manifest.encoder.mapRender((r) => `getHiddenSuffixEncoder(${r}, [${suffixEncoders.render}])`).mergeImportsWith(suffixEncoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixEncoder");
-        manifest.decoder.mapRender((r) => `getHiddenSuffixDecoder(${r}, [${suffixDecoders.render}])`).mergeImportsWith(suffixDecoders).addImports("solanaCodecsDataStructures", "getHiddenSuffixDecoder");
-        return manifest;
+        const manifest = (0, import_visitors_core30.visit)(node.type, self);
+        const suffixes = node.suffix.map((c) => (0, import_visitors_core30.visit)(c, self).value);
+        const suffixEncoders = (0, import_visitors_core30.pipe)(
+          mergeFragments(suffixes, (contents) => contents.map((c) => `getConstantEncoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantEncoder"])
+        );
+        const suffixDecoders = (0, import_visitors_core30.pipe)(
+          mergeFragments(suffixes, (contents) => contents.map((c) => `getConstantDecoder(${c})`).join(", ")),
+          (f) => addFragmentImports(f, "solanaCodecsCore", ["getConstantDecoder"])
+        );
+        return typeManifest({
+          ...manifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.decoder, suffixDecoders],
+              ([child, suffixes2]) => `getHiddenSuffixDecoder(${child}, [${suffixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenSuffixDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.encoder, suffixEncoders],
+              ([child, suffixes2]) => `getHiddenSuffixEncoder(${child}, [${suffixes2}])`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getHiddenSuffixEncoder"])
+          )
+        });
       },
       visitInstruction(instruction, { self }) {
         const instructionDataName = nameApi.instructionDataType(instruction.name);
@@ -2105,39 +2422,49 @@ function getTypeManifestVisitor(input) {
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
         const struct = (0, import_nodes24.structTypeNodeFromInstructionArgumentNodes)(instruction.arguments);
-        const manifest = link ? (0, import_visitors_core20.visit)(link, self) : (0, import_visitors_core20.visit)(struct, self);
+        const manifest = link ? (0, import_visitors_core30.visit)(link, self) : (0, import_visitors_core30.visit)(struct, self);
         parentName = null;
         return manifest;
       },
       visitMapEntryValue(node, { self }) {
-        return mergeManifests([(0, import_visitors_core20.visit)(node.key, self), (0, import_visitors_core20.visit)(node.value, self)], {
+        return mergeTypeManifests([(0, import_visitors_core30.visit)(node.key, self), (0, import_visitors_core30.visit)(node.value, self)], {
           mergeValues: (renders) => `[${renders.join(", ")}]`
         });
       },
       visitMapType(mapType, { self }) {
-        const key = (0, import_visitors_core20.visit)(mapType.key, self);
-        const value = (0, import_visitors_core20.visit)(mapType.value, self);
-        const mergedManifest = mergeManifests([key, value], {
+        const key = (0, import_visitors_core30.visit)(mapType.key, self);
+        const value = (0, import_visitors_core30.visit)(mapType.value, self);
+        const mergedManifest = mergeTypeManifests([key, value], {
           mergeCodecs: ([k, v]) => `${k}, ${v}`,
           mergeTypes: ([k, v]) => `Map<${k}, ${v}>`
         });
         const sizeManifest = getArrayLikeSizeOption(mapType.count, self);
-        const encoderOptions = sizeManifest.encoder.render ? `, { ${sizeManifest.encoder.render} }` : "";
-        const decoderOptions = sizeManifest.decoder.render ? `, { ${sizeManifest.decoder.render} }` : "";
-        mergedManifest.encoder.mapRender((r) => `getMapEncoder(${r}${encoderOptions})`).addImports("solanaCodecsDataStructures", "getMapEncoder");
-        mergedManifest.decoder.mapRender((r) => `getMapDecoder(${r}${decoderOptions})`).addImports("solanaCodecsDataStructures", "getMapDecoder");
-        return mergedManifest;
+        const encoderOptions = sizeManifest.encoder.content ? `, { ${sizeManifest.encoder.content} }` : "";
+        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        return typeManifest({
+          ...mergedManifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            mergedManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getMapDecoder(${c}${decoderOptions})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getMapDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergedManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getMapEncoder(${c}${encoderOptions})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getMapEncoder"])
+          )
+        });
       },
       visitMapValue(node, { self }) {
-        const entryFragments = node.entries.map((entry) => (0, import_visitors_core20.visit)(entry, self));
-        return mergeManifests(entryFragments, {
+        const entryFragments = node.entries.map((entry) => (0, import_visitors_core30.visit)(entry, self));
+        return mergeTypeManifests(entryFragments, {
           mergeValues: (renders) => `new Map([${renders.join(", ")}])`
         });
       },
       visitNoneValue() {
-        const manifest = typeManifest();
-        manifest.value.setRender("none()").addImports("solanaOptions", "none");
-        return manifest;
+        return typeManifest({
+          value: (0, import_visitors_core30.pipe)(fragment("none()"), (f) => addFragmentImports(f, "solanaOptions", ["none"]))
+        });
       },
       visitNumberType(numberType) {
         const encoderFunction = nameApi.encoderFunction(numberType.format);
@@ -2151,33 +2478,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: (0, import_visitors_core30.pipe)(
+            fragment(`${decoderFunction}(${endianness})`),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            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 = (0, import_visitors_core20.visit)(optionType.item, self);
-        childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
-        childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
+        const childManifest = (0, import_visitors_core30.visit)(optionType.item, self);
         const encoderOptions = [];
         const decoderOptions = [];
+        const encoderImports = new ImportMap();
+        const decoderImports = new ImportMap();
         const optionPrefix = (0, import_nodes24.resolveNestedTypeNode)(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
-          const prefixManifest = (0, import_visitors_core20.visit)(optionType.prefix, self);
-          childManifest.encoder.mergeImportsWith(prefixManifest.encoder);
-          childManifest.decoder.mergeImportsWith(prefixManifest.decoder);
-          encoderOptions.push(`prefix: ${prefixManifest.encoder.render}`);
-          decoderOptions.push(`prefix: ${prefixManifest.decoder.render}`);
+          const prefixManifest = (0, import_visitors_core30.visit)(optionType.prefix, self);
+          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"`);
@@ -2185,16 +2516,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: (0, import_visitors_core30.pipe)(
+            childManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"]),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            childManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"]),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          ),
+          looseType: (0, import_visitors_core30.pipe)(
+            childManifest.looseType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `OptionOrNullable<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            childManifest.strictType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `Option<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
+          )
+        });
       },
       visitPostOffsetType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
+        const manifest = (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(
+              manifest.decoder,
+              (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `padRightDecoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padRightDecoder"])
+            ),
+            encoder: (0, import_visitors_core30.pipe)(
+              manifest.encoder,
+              (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `padRightEncoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padRightEncoder"])
+            )
+          });
         }
         const fn = (() => {
           switch (node.strategy) {
@@ -2207,16 +2570,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: (0, import_visitors_core30.pipe)(
+            manifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `offsetDecoder(${c}, { postOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            manifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `offsetEncoder(${c}, { postOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetEncoder"])
+          )
+        });
       },
       visitPreOffsetType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
+        const manifest = (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(
+              manifest.decoder,
+              (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `padLeftDecoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padLeftDecoder"])
+            ),
+            encoder: (0, import_visitors_core30.pipe)(
+              manifest.encoder,
+              (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `padLeftEncoder(${c}, ${node.offset})`),
+              (f) => addFragmentImports(f, "solanaCodecsCore", ["padLeftEncoder"])
+            )
+          });
         }
         const fn = (() => {
           switch (node.strategy) {
@@ -2227,85 +2610,177 @@ 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: (0, import_visitors_core30.pipe)(
+            manifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `offsetDecoder(${c}, { preOffset: ${fn} })`),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["offsetDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            manifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(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 = (0, import_visitors_core30.pipe)(
+          fragment("Address"),
+          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+        );
+        return typeManifest({
+          decoder: (0, import_visitors_core30.pipe)(
+            fragment("getAddressDecoder()"),
+            (f) => addFragmentImports(f, "solanaAddresses", ["getAddressDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            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: (0, import_visitors_core30.pipe)(
+            fragment(`address("${node.publicKey}")`),
+            (f) => addFragmentImports(f, "solanaAddresses", ["address"])
+          )
+        });
       },
       visitRemainderOptionType(node, { self }) {
-        const childManifest = (0, import_visitors_core20.visit)(node.item, self);
-        childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
-        childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
+        const childManifest = (0, import_visitors_core30.visit)(node.item, self);
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
         const encoderOptionsAsString = encoderOptions.length > 0 ? `, { ${encoderOptions.join(", ")} }` : "";
         const decoderOptionsAsString = decoderOptions.length > 0 ? `, { ${decoderOptions.join(", ")} }` : "";
-        childManifest.encoder.mapRender((r) => `getOptionEncoder(${r + encoderOptionsAsString})`).addImports("solanaOptions", "getOptionEncoder");
-        childManifest.decoder.mapRender((r) => `getOptionDecoder(${r + decoderOptionsAsString})`).addImports("solanaOptions", "getOptionDecoder");
-        return childManifest;
+        return typeManifest({
+          ...childManifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            childManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            childManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"])
+          ),
+          looseType: (0, import_visitors_core30.pipe)(
+            childManifest.looseType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `OptionOrNullable<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            childManifest.strictType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `Option<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
+          )
+        });
       },
       visitSentinelType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
-        const sentinel = (0, import_visitors_core20.visit)(node.sentinel, self).value;
-        manifest.encoder.mapRender((r) => `addEncoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addEncoderSentinel");
-        manifest.decoder.mapRender((r) => `addDecoderSentinel(${r}, ${sentinel.render})`).mergeImportsWith(sentinel).addImports("solanaCodecsCore", "addDecoderSentinel");
-        return manifest;
+        const manifest = (0, import_visitors_core30.visit)(node.type, self);
+        const sentinel = (0, import_visitors_core30.visit)(node.sentinel, self).value;
+        return typeManifest({
+          ...manifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.decoder, sentinel],
+              ([child, sentinel2]) => `addDecoderSentinel(${child}, ${sentinel2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addDecoderSentinel"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.encoder, sentinel],
+              ([child, sentinel2]) => `addEncoderSentinel(${child}, ${sentinel2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addEncoderSentinel"])
+          )
+        });
       },
       visitSetType(setType, { self }) {
-        const childManifest = (0, import_visitors_core20.visit)(setType.item, self);
-        childManifest.strictType.mapRender((r) => `Set<${r}>`);
-        childManifest.looseType.mapRender((r) => `Set<${r}>`);
+        const childManifest = (0, import_visitors_core30.visit)(setType.item, self);
         const sizeManifest = getArrayLikeSizeOption(setType.count, self);
-        const encoderOptions = sizeManifest.encoder.render ? `, { ${sizeManifest.encoder.render} }` : "";
-        const decoderOptions = sizeManifest.decoder.render ? `, { ${sizeManifest.decoder.render} }` : "";
-        childManifest.encoder.mergeImportsWith(sizeManifest.encoder).mapRender((r) => `getSetEncoder(${r + encoderOptions})`).addImports("solanaCodecsDataStructures", "getSetEncoder");
-        childManifest.decoder.mergeImportsWith(sizeManifest.decoder).mapRender((r) => `getSetDecoder(${r + decoderOptions})`).addImports("solanaCodecsDataStructures", "getSetDecoder");
-        return childManifest;
+        const encoderOptions = sizeManifest.encoder.content ? `, { ${sizeManifest.encoder.content} }` : "";
+        const decoderOptions = sizeManifest.decoder.content ? `, { ${sizeManifest.decoder.content} }` : "";
+        return typeManifest({
+          ...childManifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            childManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getSetDecoder(${c + decoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.decoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getSetDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            childManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getSetEncoder(${c + encoderOptions})`),
+            (f) => mergeFragmentImports(f, [sizeManifest.encoder.imports]),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getSetEncoder"])
+          ),
+          looseType: (0, import_visitors_core30.pipe)(childManifest.looseType, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `Set<${c}>`)),
+          strictType: (0, import_visitors_core30.pipe)(childManifest.strictType, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `Set<${c}>`))
+        });
       },
       visitSetValue(node, { self }) {
-        return mergeManifests(
-          node.items.map((v) => (0, import_visitors_core20.visit)(v, self)),
+        return mergeTypeManifests(
+          node.items.map((v) => (0, import_visitors_core30.visit)(v, self)),
           { mergeValues: (renders) => `new Set([${renders.join(", ")}])` }
         );
       },
       visitSizePrefixType(node, { self }) {
-        const manifest = (0, import_visitors_core20.visit)(node.type, self);
-        const prefix = (0, import_visitors_core20.visit)(node.prefix, self);
-        manifest.encoder.mapRender((r) => `addEncoderSizePrefix(${r}, ${prefix.encoder.render})`).mergeImportsWith(prefix.encoder).addImports("solanaCodecsCore", "addEncoderSizePrefix");
-        manifest.decoder.mapRender((r) => `addDecoderSizePrefix(${r}, ${prefix.decoder.render})`).mergeImportsWith(prefix.decoder).addImports("solanaCodecsCore", "addDecoderSizePrefix");
-        return manifest;
+        const manifest = (0, import_visitors_core30.visit)(node.type, self);
+        const prefix = (0, import_visitors_core30.visit)(node.prefix, self);
+        return typeManifest({
+          ...manifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.decoder, prefix.decoder],
+              ([decoder, prefix2]) => `addDecoderSizePrefix(${decoder}, ${prefix2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addDecoderSizePrefix"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergeFragments(
+              [manifest.encoder, prefix.encoder],
+              ([encoder, prefix2]) => `addEncoderSizePrefix(${encoder}, ${prefix2})`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["addEncoderSizePrefix"])
+          )
+        });
       },
       visitSolAmountType({ number }, { self }) {
-        const numberManifest = (0, import_visitors_core20.visit)(number, self);
-        const lamportsType = "Lamports";
-        const lamportsImport = new ImportMap().add("solanaRpcTypes", "type Lamports");
-        return {
+        const numberManifest = (0, import_visitors_core30.visit)(number, self);
+        const lamportFragment = (0, import_visitors_core30.pipe)(
+          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: (0, import_visitors_core30.pipe)(
+            numberManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getLamportsDecoder(${c})`),
+            (f) => addFragmentImports(f, "solanaRpcTypes", ["getLamportsDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            numberManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getLamportsEncoder(${c})`),
+            (f) => addFragmentImports(f, "solanaRpcTypes", ["getLamportsEncoder"])
+          ),
+          looseType: lamportFragment,
+          strictType: lamportFragment
+        });
       },
       visitSomeValue(node, { self }) {
-        const manifest = typeManifest();
-        manifest.value = (0, import_visitors_core20.visit)(node.value, self).value.mapRender((r) => `some(${r})`).addImports("solanaOptions", "some");
-        return manifest;
+        return typeManifest({
+          value: (0, import_visitors_core30.pipe)(
+            (0, import_visitors_core30.visit)(node.value, self).value,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `some(${c})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["some"])
+          )
+        });
       },
       visitStringType(stringType) {
         const [encoder, decoder] = (() => {
@@ -2322,66 +2797,109 @@ 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: (0, import_visitors_core30.pipe)(
+            fragment(`${decoder}()`),
+            (f) => addFragmentImports(f, "solanaCodecsStrings", [decoder])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            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 = (0, import_nodes24.camelCase)(structFieldType.name);
-        const childManifest = (0, import_visitors_core20.visit)(structFieldType.type, self);
+        const originalChildManifest = (0, import_visitors_core30.visit)(structFieldType.type, self);
         const structFieldDocs = (0, import_nodes24.parseDocs)(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: (0, import_visitors_core30.pipe)(
+            originalChildManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `['${name}', ${c}]`)
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            originalChildManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `['${name}', ${c}]`)
+          ),
+          looseType: (0, import_visitors_core30.pipe)(
+            originalChildManifest.looseType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `${docblock}${name}: ${c}; `)
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            originalChildManifest.strictType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(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: (0, import_visitors_core30.pipe)(
+              childManifest.looseType,
+              (f) => (0, import_renderers_core12.setFragmentContent)(f, `${docblock}${name}?: ${originalLooseType}; `)
+            )
+          });
         }
-        childManifest.looseType = fragment("");
-        return childManifest;
+        return typeManifest({
+          ...childManifest,
+          looseType: fragment("")
+        });
       },
       visitStructFieldValue(node, { self }) {
-        const manifest = typeManifest();
-        manifest.value = (0, import_visitors_core20.visit)(node.value, self).value.mapRender((r) => `${node.name}: ${r}`);
-        return manifest;
+        return typeManifest({
+          value: (0, import_visitors_core30.pipe)(
+            (0, import_visitors_core30.visit)(node.value, self).value,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `${node.name}: ${c}`)
+          )
+        });
       },
       visitStructType(structType, { self }) {
         const optionalFields = structType.fields.filter((f) => !!f.defaultValue);
-        const mergedManifest = mergeManifests(
-          structType.fields.map((field) => (0, import_visitors_core20.visit)(field, self)),
-          {
-            mergeCodecs: (renders) => `([${renders.join(", ")}])`,
-            mergeTypes: (renders) => `{ ${renders.join("")} }`
-          }
+        const mergedManifest = (0, import_visitors_core30.pipe)(
+          mergeTypeManifests(
+            structType.fields.map((field) => (0, import_visitors_core30.visit)(field, self)),
+            {
+              mergeCodecs: (renders) => `([${renders.join(", ")}])`,
+              mergeTypes: (renders) => `{ ${renders.join("")} }`
+            }
+          ),
+          (manifest) => typeManifest({
+            ...manifest,
+            decoder: (0, import_visitors_core30.pipe)(
+              manifest.decoder,
+              (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getStructDecoder${c}`),
+              (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getStructDecoder"])
+            ),
+            encoder: (0, import_visitors_core30.pipe)(
+              manifest.encoder,
+              (f) => (0, import_renderers_core12.mapFragmentContent)(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;
         }
         const parentPath = stack.getPath();
-        const instructionNode = (0, import_visitors_core20.findLastNodeFromPath)(parentPath, "instructionNode");
-        const accountNode = (0, import_visitors_core20.findLastNodeFromPath)(parentPath, "accountNode");
+        const instructionNode = (0, import_visitors_core30.findLastNodeFromPath)(parentPath, "instructionNode");
+        const accountNode = (0, import_visitors_core30.findLastNodeFromPath)(parentPath, "accountNode");
         const discriminatorPrefix = instructionNode ? instructionNode.name : accountNode?.name;
         const discriminators = (instructionNode ? instructionNode.discriminators : accountNode?.discriminators) ?? [];
         const fieldDiscriminators = discriminators.filter((0, import_nodes24.isNodeFilter)("fieldDiscriminatorNode"));
+        const encoderImports = new ImportMap();
         const defaultValues = optionalFields.map((f) => {
           const key = (0, import_nodes24.camelCase)(f.name);
           if (fieldDiscriminators.some((d) => d.name === f.name)) {
@@ -2389,59 +2907,101 @@ ${jsDocblock(structFieldDocs)}` : "";
             return f.defaultValueStrategy === "omitted" ? `${key}: ${constantName}` : `${key}: value.${key} ?? ${constantName}`;
           }
           const defaultValue = f.defaultValue;
-          const { render: renderedValue, imports } = (0, import_visitors_core20.visit)(defaultValue, self).value;
-          mergedManifest.encoder.mergeImportsWith(imports);
+          const { content: renderedValue, imports } = (0, import_visitors_core30.visit)(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: (0, import_visitors_core30.pipe)(
+            mergedManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(
+              f,
+              (c) => `transformEncoder(${c}, (value) => ({ ...value, ${defaultValues} }))`
+            ),
+            (f) => addFragmentImports(f, "solanaCodecsCore", ["transformEncoder"]),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          )
+        });
       },
       visitStructValue(node, { self }) {
-        return mergeManifests(
-          node.fields.map((field) => (0, import_visitors_core20.visit)(field, self)),
+        return mergeTypeManifests(
+          node.fields.map((field) => (0, import_visitors_core30.visit)(field, self)),
           { mergeValues: (renders) => `{ ${renders.join(", ")} }` }
         );
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => (0, import_visitors_core20.visit)(item, self));
-        const mergedManifest = mergeManifests(items, {
+        const items = tupleType.items.map((item) => (0, import_visitors_core30.visit)(item, self));
+        const mergedManifest = mergeTypeManifests(items, {
           mergeCodecs: (codecs) => `[${codecs.join(", ")}]`,
           mergeTypes: (types) => `readonly [${types.join(", ")}]`
         });
-        mergedManifest.encoder.mapRender((render2) => `getTupleEncoder(${render2})`).addImports("solanaCodecsDataStructures", "getTupleEncoder");
-        mergedManifest.decoder.mapRender((render2) => `getTupleDecoder(${render2})`).addImports("solanaCodecsDataStructures", "getTupleDecoder");
-        return mergedManifest;
+        return typeManifest({
+          ...mergedManifest,
+          decoder: (0, import_visitors_core30.pipe)(
+            mergedManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getTupleDecoder(${c})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getTupleDecoder"])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            mergedManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getTupleEncoder(${c})`),
+            (f) => addFragmentImports(f, "solanaCodecsDataStructures", ["getTupleEncoder"])
+          )
+        });
       },
       visitTupleValue(node, { self }) {
-        return mergeManifests(
-          node.items.map((v) => (0, import_visitors_core20.visit)(v, self)),
+        return mergeTypeManifests(
+          node.items.map((v) => (0, import_visitors_core30.visit)(v, self)),
           { mergeValues: (renders) => `[${renders.join(", ")}]` }
         );
       },
       visitZeroableOptionType(node, { self }) {
-        const childManifest = (0, import_visitors_core20.visit)(node.item, self);
-        childManifest.strictType.mapRender((r) => `Option<${r}>`).addImports("solanaOptions", "type Option");
-        childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
+        const childManifest = (0, import_visitors_core30.visit)(node.item, self);
         const encoderOptions = ["prefix: null"];
         const decoderOptions = ["prefix: null"];
+        const encoderImports = new ImportMap();
+        const decoderImports = new ImportMap();
         if (node.zeroValue) {
-          const zeroValueManifest = (0, import_visitors_core20.visit)(node.zeroValue, self);
-          childManifest.encoder.mergeImportsWith(zeroValueManifest.value);
-          childManifest.decoder.mergeImportsWith(zeroValueManifest.value);
-          encoderOptions.push(`noneValue: ${zeroValueManifest.value.render}`);
-          decoderOptions.push(`noneValue: ${zeroValueManifest.value.render}`);
+          const zeroValueManifest = (0, import_visitors_core30.visit)(node.zeroValue, self);
+          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: (0, import_visitors_core30.pipe)(
+            childManifest.decoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getOptionDecoder(${c + decoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionDecoder"]),
+            (f) => mergeFragmentImports(f, [decoderImports])
+          ),
+          encoder: (0, import_visitors_core30.pipe)(
+            childManifest.encoder,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `getOptionEncoder(${c + encoderOptionsAsString})`),
+            (f) => addFragmentImports(f, "solanaOptions", ["getOptionEncoder"]),
+            (f) => mergeFragmentImports(f, [encoderImports])
+          ),
+          looseType: (0, import_visitors_core30.pipe)(
+            childManifest.looseType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `OptionOrNullable<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type OptionOrNullable"])
+          ),
+          strictType: (0, import_visitors_core30.pipe)(
+            childManifest.strictType,
+            (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `Option<${c}>`),
+            (f) => addFragmentImports(f, "solanaOptions", ["type Option"])
+          )
+        });
       }
     }),
-    (visitor) => (0, import_visitors_core20.recordNodeStackVisitor)(visitor, stack)
+    (visitor) => (0, import_visitors_core30.recordNodeStackVisitor)(visitor, stack)
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
@@ -2461,10 +3021,11 @@ function getArrayLikeSizeOption(count, visitor) {
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: fragment(""), encoder: fragment("") };
   }
-  const prefixManifest = (0, import_visitors_core20.visit)(count.prefix, visitor);
-  prefixManifest.encoder.mapRender((r) => `size: ${r}`);
-  prefixManifest.decoder.mapRender((r) => `size: ${r}`);
-  return prefixManifest;
+  const prefixManifest = (0, import_visitors_core30.visit)(count.prefix, visitor);
+  return {
+    decoder: (0, import_visitors_core30.pipe)(prefixManifest.decoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `size: ${c}`)),
+    encoder: (0, import_visitors_core30.pipe)(prefixManifest.encoder, (f) => (0, import_renderers_core12.mapFragmentContent)(f, (c) => `size: ${c}`))
+  };
 }
 
 // src/nameTransformers.ts
@@ -2533,8 +3094,8 @@ var DEFAULT_NAME_TRANSFORMERS = {
 
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
-  const linkables = new import_visitors_core21.LinkableDictionary();
-  const stack = new import_visitors_core21.NodeStack();
+  const linkables = new import_visitors_core31.LinkableDictionary();
+  const stack = new import_visitors_core31.NodeStack();
   const nameTransformers = {
     ...DEFAULT_NAME_TRANSFORMERS,
     ...options.nameTransformers
@@ -2558,8 +3119,8 @@ function getRenderMapVisitor(options = {}) {
     nonScalarEnums,
     stack
   });
-  const resolvedInstructionInputVisitor = (0, import_visitors_core21.getResolvedInstructionInputsVisitor)();
-  const byteSizeVisitor = (0, import_visitors_core21.getByteSizeVisitor)(linkables, { stack });
+  const resolvedInstructionInputVisitor = (0, import_visitors_core31.getResolvedInstructionInputsVisitor)();
+  const byteSizeVisitor = (0, import_visitors_core31.getByteSizeVisitor)(linkables, { stack });
   const globalScope = {
     asyncResolvers,
     customAccountData,
@@ -2572,23 +3133,23 @@ function getRenderMapVisitor(options = {}) {
     typeManifestVisitor
   };
   const render2 = (template, context, renderOptions) => {
-    return render((0, import_node_path3.join)("pages", template), context, renderOptions);
+    return render((0, import_node_path2.join)("pages", template), context, renderOptions);
   };
-  return (0, import_visitors_core21.pipe)(
-    (0, import_visitors_core21.staticVisitor)(() => new import_renderers_core.RenderMap(), {
+  return (0, import_visitors_core31.pipe)(
+    (0, import_visitors_core31.staticVisitor)(() => (0, import_renderers_core13.renderMap)(), {
       keys: ["rootNode", "programNode", "pdaNode", "accountNode", "definedTypeNode", "instructionNode"]
     }),
-    (v) => (0, import_visitors_core21.extendVisitor)(v, {
+    (v) => (0, import_visitors_core31.extendVisitor)(v, {
       visitAccount(node) {
         const accountPath = stack.getPath("accountNode");
-        if (!(0, import_visitors_core21.findProgramNodeFromPath)(accountPath)) {
+        if (!(0, import_visitors_core31.findProgramNodeFromPath)(accountPath)) {
           throw new Error("Account must be visited inside a program.");
         }
         const scope = {
           ...globalScope,
           accountPath,
-          size: (0, import_visitors_core21.visit)(node, byteSizeVisitor),
-          typeManifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor)
+          size: (0, import_visitors_core31.visit)(node, byteSizeVisitor),
+          typeManifest: (0, import_visitors_core31.visit)(node, typeManifestVisitor)
         };
         const fields = (0, import_nodes26.resolveNestedTypeNode)(node.data).fields;
         const accountDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
@@ -2608,14 +3169,15 @@ function getRenderMapVisitor(options = {}) {
           accountSizeHelpersFragment,
           accountPdaHelpersFragment
         );
-        return new import_renderers_core.RenderMap().add(
+        return (0, import_renderers_core13.addToRenderMap)(
+          (0, import_renderers_core13.renderMap)(),
           `accounts/${(0, import_nodes26.camelCase)(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)
           })
         );
@@ -2626,10 +3188,10 @@ function getRenderMapVisitor(options = {}) {
           codecDocs: [],
           decoderDocs: [],
           encoderDocs: [],
-          manifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor),
+          manifest: (0, import_visitors_core31.visit)(node, typeManifestVisitor),
           name: node.name,
           node: node.type,
-          size: (0, import_visitors_core21.visit)(node, byteSizeVisitor),
+          size: (0, import_visitors_core31.visit)(node, byteSizeVisitor),
           typeDocs: node.docs,
           typeNode: node.type
         };
@@ -2642,28 +3204,26 @@ function getRenderMapVisitor(options = {}) {
           nameApi.decoderFunction(node.name),
           nameApi.codecFunction(node.name)
         ]);
-        return new import_renderers_core.RenderMap().add(
+        return (0, import_renderers_core13.addToRenderMap)(
+          (0, import_renderers_core13.renderMap)(),
           `types/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("definedTypesPage.njk", {
-            imports: imports.toString({
-              ...dependencyMap,
-              generatedTypes: "."
-            }),
-            typeDiscriminatedUnionHelpersFragment,
-            typeWithCodecFragment
+            imports: imports.toString({ ...dependencyMap, generatedTypes: "." }),
+            typeDiscriminatedUnionHelpersFragment: typeDiscriminatedUnionHelpersFragment.content,
+            typeWithCodecFragment: typeWithCodecFragment.content
           })
         );
       },
       visitInstruction(node) {
         const instructionPath = stack.getPath("instructionNode");
-        if (!(0, import_visitors_core21.findProgramNodeFromPath)(instructionPath)) {
+        if (!(0, import_visitors_core31.findProgramNodeFromPath)(instructionPath)) {
           throw new Error("Instruction must be visited inside a program.");
         }
         const instructionExtraName = nameApi.instructionExtraType(node.name);
         const scope = {
           ...globalScope,
-          dataArgsManifest: (0, import_visitors_core21.visit)(node, typeManifestVisitor),
-          extraArgsManifest: (0, import_visitors_core21.visit)(
+          dataArgsManifest: (0, import_visitors_core31.visit)(node, typeManifestVisitor),
+          extraArgsManifest: (0, import_visitors_core31.visit)(
             (0, import_nodes26.definedTypeNode)({
               name: instructionExtraName,
               type: (0, import_nodes26.structTypeNodeFromInstructionArgumentNodes)(node.extraArguments ?? [])
@@ -2672,8 +3232,8 @@ function getRenderMapVisitor(options = {}) {
           ),
           instructionPath,
           renamedArgs: getRenamedArgsMap(node),
-          resolvedInputs: (0, import_visitors_core21.visit)(node, resolvedInstructionInputVisitor),
-          size: (0, import_visitors_core21.visit)(node, byteSizeVisitor)
+          resolvedInputs: (0, import_visitors_core31.visit)(node, resolvedInstructionInputVisitor),
+          size: (0, import_visitors_core31.visit)(node, byteSizeVisitor)
         };
         const instructionDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
@@ -2702,34 +3262,36 @@ function getRenderMapVisitor(options = {}) {
           instructionFunctionSyncFragment,
           instructionParseFunctionFragment
         );
-        return new import_renderers_core.RenderMap().add(
+        return (0, import_renderers_core13.addToRenderMap)(
+          (0, import_renderers_core13.renderMap)(),
           `instructions/${(0, import_nodes26.camelCase)(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 (!(0, import_visitors_core21.findProgramNodeFromPath)(pdaPath)) {
-          throw new Error("Account must be visited inside a program.");
+        if (!(0, import_visitors_core31.findProgramNodeFromPath)(pdaPath)) {
+          throw new Error("PDA must be visited inside a program.");
         }
         const scope = { ...globalScope, pdaPath };
         const pdaFunctionFragment = getPdaFunctionFragment(scope);
         const imports = new ImportMap().mergeWith(pdaFunctionFragment);
-        return new import_renderers_core.RenderMap().add(
+        return (0, import_renderers_core13.addToRenderMap)(
+          (0, import_renderers_core13.renderMap)(),
           `pdas/${(0, import_nodes26.camelCase)(node.name)}.ts`,
           render2("pdasPage.njk", {
             imports: imports.toString(dependencyMap, useGranularImports),
-            pdaFunctionFragment
+            pdaFunctionFragment: pdaFunctionFragment.content
           })
         );
       },
@@ -2739,35 +3301,42 @@ function getRenderMapVisitor(options = {}) {
           ...getDefinedTypeNodesToExtract(node.instructions, customInstructionData)
         ];
         const scope = { ...globalScope, programNode: node };
-        const renderMap = new import_renderers_core.RenderMap().mergeWith(...node.pdas.map((p) => (0, import_visitors_core21.visit)(p, self))).mergeWith(...node.accounts.map((a) => (0, import_visitors_core21.visit)(a, self))).mergeWith(...node.definedTypes.map((t) => (0, import_visitors_core21.visit)(t, self))).mergeWith(...customDataDefinedType.map((t) => (0, import_visitors_core21.visit)(t, self)));
+        let renders = (0, import_renderers_core13.mergeRenderMaps)([
+          ...node.pdas.map((p) => (0, import_visitors_core31.visit)(p, self)),
+          ...node.accounts.map((a) => (0, import_visitors_core31.visit)(a, self)),
+          ...node.definedTypes.map((t) => (0, import_visitors_core31.visit)(t, self)),
+          ...customDataDefinedType.map((t) => (0, import_visitors_core31.visit)(t, self))
+        ]);
         if (node.errors.length > 0) {
           const programErrorsFragment = getProgramErrorsFragment(scope);
-          renderMap.add(
+          renders = (0, import_renderers_core13.addToRenderMap)(
+            renders,
             `errors/${(0, import_nodes26.camelCase)(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 = (0, import_renderers_core13.addToRenderMap)(
+          renders,
           `programs/${(0, import_nodes26.camelCase)(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 (0, import_renderers_core13.mergeRenderMaps)([
+          renders,
           ...(0, import_nodes26.getAllInstructionsWithSubs)(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => (0, import_visitors_core21.visit)(ix, self))
-        );
-        return renderMap;
+          }).map((ix) => (0, import_visitors_core31.visit)(ix, self))
+        ]);
       },
       visitRoot(node, { self }) {
         const isNotInternal = (n) => !internalNodes.includes(n.name);
@@ -2790,9 +3359,10 @@ function getRenderMapVisitor(options = {}) {
           programsWithErrorsToExport,
           root: node
         };
-        const map = new import_renderers_core.RenderMap();
+        let renders = (0, import_renderers_core13.renderMap)();
         if (hasAnythingToExport) {
-          map.add(
+          renders = (0, import_renderers_core13.addToRenderMap)(
+            renders,
             "shared/index.ts",
             render2("sharedPage.njk", {
               ...ctx,
@@ -2813,28 +3383,36 @@ function getRenderMapVisitor(options = {}) {
           );
         }
         if (programsToExport.length > 0) {
-          map.add("programs/index.ts", render2("programsIndex.njk", ctx));
+          renders = (0, import_renderers_core13.addToRenderMap)(renders, "programs/index.ts", render2("programsIndex.njk", ctx));
         }
         if (programsWithErrorsToExport.length > 0) {
-          map.add("errors/index.ts", render2("errorsIndex.njk", ctx));
+          renders = (0, import_renderers_core13.addToRenderMap)(renders, "errors/index.ts", render2("errorsIndex.njk", ctx));
         }
         if (accountsToExport.length > 0) {
-          map.add("accounts/index.ts", render2("accountsIndex.njk", ctx));
+          renders = (0, import_renderers_core13.addToRenderMap)(renders, "accounts/index.ts", render2("accountsIndex.njk", ctx));
         }
         if (pdasToExport.length > 0) {
-          map.add("pdas/index.ts", render2("pdasIndex.njk", ctx));
+          renders = (0, import_renderers_core13.addToRenderMap)(renders, "pdas/index.ts", render2("pdasIndex.njk", ctx));
         }
         if (instructionsToExport.length > 0) {
-          map.add("instructions/index.ts", render2("instructionsIndex.njk", ctx));
+          renders = (0, import_renderers_core13.addToRenderMap)(
+            renders,
+            "instructions/index.ts",
+            render2("instructionsIndex.njk", ctx)
+          );
         }
         if (definedTypesToExport.length > 0) {
-          map.add("types/index.ts", render2("definedTypesIndex.njk", ctx));
+          renders = (0, import_renderers_core13.addToRenderMap)(renders, "types/index.ts", render2("definedTypesIndex.njk", ctx));
         }
-        return map.add("index.ts", render2("rootIndex.njk", ctx)).mergeWith(...(0, import_nodes26.getAllPrograms)(node).map((p) => (0, import_visitors_core21.visit)(p, self)));
+        return (0, import_visitors_core31.pipe)(
+          renders,
+          (r) => (0, import_renderers_core13.addToRenderMap)(r, "index.ts", render2("rootIndex.njk", ctx)),
+          (r) => (0, import_renderers_core13.mergeRenderMaps)([r, ...(0, import_nodes26.getAllPrograms)(node).map((p) => (0, import_visitors_core31.visit)(p, self))])
+        );
       }
     }),
-    (v) => (0, import_visitors_core21.recordNodeStackVisitor)(v, stack),
-    (v) => (0, import_visitors_core21.recordLinkablesOnFirstVisitVisitor)(v, linkables)
+    (v) => (0, import_visitors_core31.recordNodeStackVisitor)(v, stack),
+    (v) => (0, import_visitors_core31.recordLinkablesOnFirstVisitVisitor)(v, linkables)
   );
 }
 function getRenamedArgsMap(instruction) {
@@ -2856,8 +3434,8 @@ function getRenamedArgsMap(instruction) {
 }
 
 // src/renderVisitor.ts
-var import_renderers_core2 = require("@codama/renderers-core");
-var import_visitors_core22 = require("@codama/visitors-core");
+var import_renderers_core14 = require("@codama/renderers-core");
+var import_visitors_core32 = require("@codama/visitors-core");
 var estreePlugin = __toESM(require("prettier/plugins/estree"));
 var typeScriptPlugin = __toESM(require("prettier/plugins/typescript"));
 var import_standalone = require("prettier/standalone");
@@ -2873,16 +3451,16 @@ var DEFAULT_PRETTIER_OPTIONS = {
   useTabs: false
 };
 function renderVisitor(path, options = {}) {
-  return (0, import_visitors_core22.rootNodeVisitor)(async (root) => {
+  return (0, import_visitors_core32.rootNodeVisitor)(async (root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
-      (0, import_renderers_core2.deleteDirectory)(path);
+      (0, import_renderers_core14.deleteDirectory)(path);
     }
-    const renderMap = (0, import_visitors_core22.visit)(root, getRenderMapVisitor(options));
+    let renderMap2 = (0, import_visitors_core32.visit)(root, getRenderMapVisitor(options));
     if (options.formatCode ?? true) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
-      await renderMap.mapContentAsync((code) => (0, import_standalone.format)(code, prettierOptions));
+      renderMap2 = await (0, import_renderers_core14.mapRenderMapContentAsync)(renderMap2, (code) => (0, import_standalone.format)(code, prettierOptions));
     }
-    renderMap.write(path);
+    (0, import_renderers_core14.writeRenderMap)(renderMap2, path);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -2892,7 +3470,7 @@ function renderVisitor(path, options = {}) {
   getNameApi,
   getRenderMapVisitor,
   getTypeManifestVisitor,
-  mergeManifests,
+  mergeTypeManifests,
   renderVisitor,
   typeManifest
 });