codama-renderers-dart 0.2.0 → 0.2.1

package/dist/index.node.js

@@ -0,0 +1,2092 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname, posix } from 'path';
+import { staticVisitor, extendVisitor, visit, NodeStack, LinkableDictionary, pipe, recordNodeStackVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor } from '@codama/visitors-core';
+import { createRenderMap, addToRenderMap, mergeRenderMaps, deleteDirectory } from '@codama/renderers-core';
+import { execSync } from 'child_process';
+import { resolveNestedTypeNode } from '@codama/nodes';
+import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
+
+// src/visitors/renderVisitor.ts
+function formatDartDirectory(dir) {
+  try {
+    execSync(`dart format --fix "${dir}"`, {
+      encoding: "utf-8",
+      timeout: 6e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+
+// src/utils/nameTransformers.ts
+function pascalCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
+}
+function camelCase(str) {
+  const pascal = pascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function snakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").replace(/_+/g, "_").toLowerCase();
+}
+function createDartNameApi() {
+  return {
+    dataType: (name) => pascalCase(name),
+    encoderFunction: (name) => `get${pascalCase(name)}Encoder`,
+    decoderFunction: (name) => `get${pascalCase(name)}Decoder`,
+    codecFunction: (name) => `get${pascalCase(name)}Codec`,
+    accountFetchFunction: (name) => `fetch${pascalCase(name)}`,
+    accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase(name)}`,
+    accountDecodeFunction: (name) => `decode${pascalCase(name)}`,
+    accountSizeConstant: (name) => `${camelCase(name)}Size`,
+    pdaFindFunction: (name) => `find${pascalCase(name)}Pda`,
+    instructionFunction: (name) => `get${pascalCase(name)}Instruction`,
+    instructionParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
+    programAddressConstant: (name) => `${camelCase(name)}ProgramAddress`,
+    errorConstant: (programName, errorName) => `${camelCase(programName)}Error${pascalCase(errorName)}`,
+    errorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
+    enumVariant: (name) => camelCase(name),
+    sealedClassVariant: (_parentName, variantName) => pascalCase(variantName),
+    isTypeFunction: (name) => `is${pascalCase(name)}`,
+    fileName: (name) => snakeCase(name),
+    discriminatorConstant: (name) => `${camelCase(name)}Discriminator`
+  };
+}
+
+// src/utils/codecs.ts
+function bytesToDartHexList(bytes) {
+  const pairs = [];
+  for (let i = 0; i < bytes.length; i++) {
+    pairs.push(`0x${bytes[i].toString(16).padStart(2, "0")}`);
+  }
+  return `[${pairs.join(", ")}]`;
+}
+
+// src/utils/importMap.ts
+var DART_EXTERNAL_PACKAGE_MAP = {
+  // Dart core
+  dartTypedData: "dart:typed_data",
+  dartConvert: "dart:convert",
+  meta: "package:meta/meta.dart",
+  // solana_kit packages
+  solanaAddresses: "package:solana_kit_addresses/solana_kit_addresses.dart",
+  solanaCodecsCore: "package:solana_kit_codecs_core/solana_kit_codecs_core.dart",
+  solanaCodecsDataStructures: "package:solana_kit_codecs_data_structures/solana_kit_codecs_data_structures.dart",
+  solanaCodecsNumbers: "package:solana_kit_codecs_numbers/solana_kit_codecs_numbers.dart",
+  solanaCodecsStrings: "package:solana_kit_codecs_strings/solana_kit_codecs_strings.dart",
+  solanaErrors: "package:solana_kit_errors/solana_kit_errors.dart",
+  solanaAccounts: "package:solana_kit_accounts/solana_kit_accounts.dart",
+  solanaInstructions: "package:solana_kit_instructions/solana_kit_instructions.dart",
+  solanaPrograms: "package:solana_kit_programs/solana_kit_programs.dart",
+  solanaRpcTypes: "package:solana_kit_rpc_types/solana_kit_rpc_types.dart",
+  solanaSigners: "package:solana_kit_signers/solana_kit_signers.dart"
+};
+var DartImportMap = class {
+  _imports = /* @__PURE__ */ new Set();
+  /**
+   * Add a logical module name (resolved via DART_EXTERNAL_PACKAGE_MAP)
+   * or a raw Dart import URI.
+   */
+  add(module) {
+    this._imports.add(module);
+    return this;
+  }
+  /**
+   * Merge another DartImportMap into this one.
+   */
+  mergeWith(other) {
+    for (const imp of other._imports) {
+      this._imports.add(imp);
+    }
+    return this;
+  }
+  /**
+   * Check if this import map is empty.
+   */
+  get isEmpty() {
+    return this._imports.size === 0;
+  }
+  /**
+   * Get all raw module keys.
+   */
+  get modules() {
+    return new Set(this._imports);
+  }
+  /**
+   * Resolve all imports to Dart import URIs and return them sorted.
+   * @param internalMap Maps logical names to relative file paths for generated code cross-references.
+   */
+  resolve(internalMap = {}) {
+    const uris = /* @__PURE__ */ new Set();
+    for (const module of this._imports) {
+      if (module in internalMap) {
+        uris.add(internalMap[module]);
+      } else if (module in DART_EXTERNAL_PACKAGE_MAP) {
+        uris.add(DART_EXTERNAL_PACKAGE_MAP[module]);
+      } else {
+        uris.add(module);
+      }
+    }
+    return [...uris].sort((a, b) => {
+      const aWeight = a.startsWith("dart:") ? 0 : a.startsWith("package:") ? 1 : 2;
+      const bWeight = b.startsWith("dart:") ? 0 : b.startsWith("package:") ? 1 : 2;
+      if (aWeight !== bWeight) return aWeight - bWeight;
+      return a.localeCompare(b);
+    });
+  }
+  /**
+   * Render all imports as Dart import statements.
+   */
+  toString(internalMap = {}) {
+    const resolved = this.resolve(internalMap);
+    if (resolved.length === 0) return "";
+    const lines = [];
+    let lastPrefix = "";
+    for (const uri of resolved) {
+      const prefix = uri.startsWith("dart:") ? "dart" : uri.startsWith("package:") ? "package" : "relative";
+      if (lastPrefix && lastPrefix !== prefix) {
+        lines.push("");
+      }
+      lastPrefix = prefix;
+      lines.push(`import '${uri}';`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/utils/fragment.ts
+function fragment(strings, ...values) {
+  const imports = new DartImportMap();
+  const parts = [];
+  for (let i = 0; i < strings.length; i++) {
+    parts.push(strings[i]);
+    if (i < values.length) {
+      const value = values[i];
+      if (value != null && typeof value === "object" && "imports" in value) {
+        parts.push(value.content);
+        imports.mergeWith(value.imports);
+      } else {
+        parts.push(String(value ?? ""));
+      }
+    }
+  }
+  return {
+    content: parts.join(""),
+    imports
+  };
+}
+function emptyFragment() {
+  return { content: "", imports: new DartImportMap() };
+}
+function fragmentFromString(content) {
+  return { content, imports: new DartImportMap() };
+}
+function mergeFragments(fragments, joiner) {
+  const imports = new DartImportMap();
+  const contents = [];
+  for (const frag of fragments) {
+    contents.push(frag.content);
+    imports.mergeWith(frag.imports);
+  }
+  return { content: joiner(contents), imports };
+}
+function use(typeName, module) {
+  const imports = new DartImportMap();
+  imports.add(module);
+  return { content: typeName, imports };
+}
+
+// src/utils/typeManifest.ts
+function emptyTypeManifest() {
+  return {
+    type: emptyFragment(),
+    encoder: emptyFragment(),
+    decoder: emptyFragment(),
+    value: emptyFragment(),
+    isEnum: false
+  };
+}
+
+// src/visitors/getTypeManifestVisitor.ts
+function getTypeManifestVisitor(input) {
+  const { nameApi, linkables, nonScalarEnums = [] } = input;
+  const baseVisitor = staticVisitor(
+    (node) => {
+      throw new CodamaError(CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+        expectedKinds: ["typeNode"],
+        kind: node.kind
+      });
+    },
+    {
+      keys: [
+        // Type nodes
+        "numberTypeNode",
+        "booleanTypeNode",
+        "stringTypeNode",
+        "publicKeyTypeNode",
+        "bytesTypeNode",
+        "arrayTypeNode",
+        "mapTypeNode",
+        "setTypeNode",
+        "tupleTypeNode",
+        "structTypeNode",
+        "structFieldTypeNode",
+        "enumTypeNode",
+        "enumEmptyVariantTypeNode",
+        "enumStructVariantTypeNode",
+        "enumTupleVariantTypeNode",
+        "optionTypeNode",
+        "remainderOptionTypeNode",
+        "zeroableOptionTypeNode",
+        "fixedSizeTypeNode",
+        "sizePrefixTypeNode",
+        "hiddenPrefixTypeNode",
+        "hiddenSuffixTypeNode",
+        "sentinelTypeNode",
+        "preOffsetTypeNode",
+        "postOffsetTypeNode",
+        "solAmountTypeNode",
+        "amountTypeNode",
+        "dateTimeTypeNode",
+        "definedTypeLinkNode",
+        // Context nodes (for links)
+        "definedTypeNode",
+        "accountNode",
+        "instructionNode"
+      ]
+    }
+  );
+  return extendVisitor(baseVisitor, {
+    visitNumberType(node, { self }) {
+      const { format, endian } = node;
+      const endianSuffix = endian === "be" ? ", NumberCodecConfig(endian: Endian.big)" : "";
+      const endianDecoderSuffix = endian === "be" ? ", NumberCodecConfig(endian: Endian.big)" : "";
+      const dartType = getNumberDartType(format);
+      const codecName = getNumberCodecName(format);
+      return {
+        type: dartType === "BigInt" ? use("BigInt", "dartTypedData") : fragmentFromString(dartType),
+        encoder: fragment`${use(
+          `get${codecName}Encoder`,
+          "solanaCodecsNumbers"
+        )}(${endianSuffix ? fragmentFromString(endianSuffix.slice(2)) : fragmentFromString("")})`,
+        decoder: fragment`${use(
+          `get${codecName}Decoder`,
+          "solanaCodecsNumbers"
+        )}(${endianDecoderSuffix ? fragmentFromString(endianDecoderSuffix.slice(2)) : fragmentFromString("")})`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitBooleanType(_node, { self }) {
+      return {
+        type: fragmentFromString("bool"),
+        encoder: fragment`${use(
+          "getBooleanEncoder",
+          "solanaCodecsDataStructures"
+        )}()`,
+        decoder: fragment`${use(
+          "getBooleanDecoder",
+          "solanaCodecsDataStructures"
+        )}()`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitStringType(node, { self }) {
+      const { encoding } = node;
+      const codecMap = {
+        utf8: "Utf8",
+        base58: "Base58",
+        base64: "Base64",
+        base16: "Base16"
+      };
+      const codecName = codecMap[encoding] ?? "Utf8";
+      return {
+        type: fragmentFromString("String"),
+        encoder: fragment`${use(
+          `get${codecName}Encoder`,
+          "solanaCodecsStrings"
+        )}()`,
+        decoder: fragment`${use(
+          `get${codecName}Decoder`,
+          "solanaCodecsStrings"
+        )}()`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitPublicKeyType(_node, { self }) {
+      return {
+        type: fragment`${use("Address", "solanaAddresses")}`,
+        encoder: fragment`${use(
+          "getAddressEncoder",
+          "solanaAddresses"
+        )}()`,
+        decoder: fragment`${use(
+          "getAddressDecoder",
+          "solanaAddresses"
+        )}()`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitBytesType(_node, { self }) {
+      return {
+        type: fragment`${use("Uint8List", "dartTypedData")}`,
+        encoder: fragment`${use(
+          "getBytesEncoder",
+          "solanaCodecsDataStructures"
+        )}()`,
+        decoder: fragment`${use(
+          "getBytesDecoder",
+          "solanaCodecsDataStructures"
+        )}()`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitArrayType(node, { self }) {
+      const itemManifest = visit(node.item, self);
+      const sizeExpr = getArraySizeExpression(node);
+      return {
+        type: fragment`List<${itemManifest.type}>`,
+        encoder: fragment`${use(
+          "getArrayEncoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.encoder}${sizeExpr})`,
+        decoder: fragment`${use(
+          "getArrayDecoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.decoder}${sizeExpr})`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitMapType(node, { self }) {
+      const keyManifest = visit(node.key, self);
+      const valueManifest = visit(node.value, self);
+      const sizeExpr = getMapSizeExpression(node);
+      return {
+        type: fragment`Map<${keyManifest.type}, ${valueManifest.type}>`,
+        encoder: fragment`${use(
+          "getMapEncoder",
+          "solanaCodecsDataStructures"
+        )}(${keyManifest.encoder}, ${valueManifest.encoder}${sizeExpr})`,
+        decoder: fragment`${use(
+          "getMapDecoder",
+          "solanaCodecsDataStructures"
+        )}(${keyManifest.decoder}, ${valueManifest.decoder}${sizeExpr})`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitSetType(node, { self }) {
+      const itemManifest = visit(node.item, self);
+      const sizeExpr = getSetSizeExpression(node);
+      return {
+        type: fragment`Set<${itemManifest.type}>`,
+        encoder: fragment`${use(
+          "getSetEncoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.encoder}${sizeExpr})`,
+        decoder: fragment`${use(
+          "getSetDecoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.decoder}${sizeExpr})`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitTupleType(node, { self }) {
+      const itemManifests = node.items.map((item) => visit(item, self));
+      const typeList = itemManifests.map((m) => m.type.content).join(", ");
+      const encoderList = itemManifests.map((m) => m.encoder);
+      const decoderList = itemManifests.map((m) => m.decoder);
+      const typeFragment = fragment`(${fragmentFromString(typeList)})`;
+      for (const m of itemManifests) {
+        typeFragment.imports.mergeWith(m.type.imports);
+      }
+      const encoderListStr = encoderList.map((e) => e.content).join(", ");
+      const encoderFrag = fragment`${use(
+        "getTupleEncoder",
+        "solanaCodecsDataStructures"
+      )}([${fragmentFromString(encoderListStr)}])`;
+      for (const e of encoderList) {
+        encoderFrag.imports.mergeWith(e.imports);
+      }
+      const decoderListStr = decoderList.map((d) => d.content).join(", ");
+      const decoderFrag = fragment`${use(
+        "getTupleDecoder",
+        "solanaCodecsDataStructures"
+      )}([${fragmentFromString(decoderListStr)}])`;
+      for (const d of decoderList) {
+        decoderFrag.imports.mergeWith(d.imports);
+      }
+      return {
+        type: typeFragment,
+        encoder: encoderFrag,
+        decoder: decoderFrag,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitStructType(node, { self }) {
+      const fields = node.fields.map((f) => visit(f, self));
+      const fieldNames = node.fields.map((f) => f.name);
+      const typeStr = "Map<String, Object?>";
+      const encoderFields = fields.map((f, i) => `('${fieldNames[i]}', ${f.encoder.content})`).join(", ");
+      const encoderFrag = fragment`${use(
+        "getStructEncoder",
+        "solanaCodecsDataStructures"
+      )}([${fragmentFromString(encoderFields)}])`;
+      for (const f of fields) {
+        encoderFrag.imports.mergeWith(f.encoder.imports);
+      }
+      const decoderFields = fields.map((f, i) => `('${fieldNames[i]}', ${f.decoder.content})`).join(", ");
+      const decoderFrag = fragment`${use(
+        "getStructDecoder",
+        "solanaCodecsDataStructures"
+      )}([${fragmentFromString(decoderFields)}])`;
+      for (const f of fields) {
+        decoderFrag.imports.mergeWith(f.decoder.imports);
+      }
+      return {
+        type: fragmentFromString(typeStr),
+        encoder: encoderFrag,
+        decoder: decoderFrag,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitStructFieldType(node, { self }) {
+      return visit(node.type, self);
+    },
+    visitEnumType(node, { self }) {
+      const isScalar = node.variants.every(
+        (v) => v.kind === "enumEmptyVariantTypeNode"
+      );
+      if (isScalar) {
+        return {
+          type: emptyTypeManifest().type,
+          // Will be replaced by the named type
+          encoder: emptyTypeManifest().encoder,
+          decoder: emptyTypeManifest().decoder,
+          value: emptyTypeManifest().value,
+          isEnum: true
+        };
+      }
+      return {
+        type: emptyTypeManifest().type,
+        encoder: emptyTypeManifest().encoder,
+        decoder: emptyTypeManifest().decoder,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitEnumEmptyVariantType(_node, { self }) {
+      return emptyTypeManifest();
+    },
+    visitEnumStructVariantType(node, { self }) {
+      return visit(node.struct, self);
+    },
+    visitEnumTupleVariantType(node, { self }) {
+      return visit(node.tuple, self);
+    },
+    visitOptionType(node, { self }) {
+      const itemManifest = visit(node.item, self);
+      const resolvedPrefix = resolveNestedTypeNode(node.prefix);
+      const prefixExpr = resolvedPrefix.format !== "u8" ? `, prefix: ${getNumberCodecExpression(resolvedPrefix.format, "Encoder")}` : "";
+      const prefixDecoderExpr = resolvedPrefix.format !== "u8" ? `, prefix: ${getNumberCodecExpression(resolvedPrefix.format, "Decoder")}` : "";
+      return {
+        type: fragment`${itemManifest.type}?`,
+        encoder: fragment`${use(
+          "getNullableEncoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.encoder}${fragmentFromString(prefixExpr)})`,
+        decoder: fragment`${use(
+          "getNullableDecoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.decoder}${fragmentFromString(prefixDecoderExpr)})`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitRemainderOptionType(node, { self }) {
+      const itemManifest = visit(node.item, self);
+      return {
+        type: fragment`${itemManifest.type}?`,
+        encoder: fragment`${use(
+          "getNullableEncoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.encoder}, hasPrefix: false)`,
+        decoder: fragment`${use(
+          "getNullableDecoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.decoder}, hasPrefix: false)`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitZeroableOptionType(node, { self }) {
+      const itemManifest = visit(node.item, self);
+      return {
+        type: fragment`${itemManifest.type}?`,
+        encoder: fragment`${use(
+          "getNullableEncoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.encoder}, hasPrefix: false, noneValue: const ZeroesNoneValue())`,
+        decoder: fragment`${use(
+          "getNullableDecoder",
+          "solanaCodecsDataStructures"
+        )}(${itemManifest.decoder}, hasPrefix: false, noneValue: const ZeroesNoneValue())`,
+        value: emptyTypeManifest().value,
+        isEnum: false
+      };
+    },
+    visitFixedSizeType(node, { self }) {
+      const innerManifest = visit(node.type, self);
+      return {
+        type: innerManifest.type,
+        encoder: fragment`${use(
+          "fixEncoderSize",
+          "solanaCodecsCore"
+        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))})`,
+        decoder: fragment`${use(
+          "fixDecoderSize",
+          "solanaCodecsCore"
+        )}(${innerManifest.decoder}, ${fragmentFromString(String(node.size))})`,
+        value: innerManifest.value,
+        isEnum: innerManifest.isEnum
+      };
+    },
+    visitSizePrefixType(node, { self }) {
+      const innerManifest = visit(node.type, self);
+      const prefixManifest = visit(node.prefix, self);
+      return {
+        type: innerManifest.type,
+        encoder: fragment`${use(
+          "addEncoderSizePrefix",
+          "solanaCodecsCore"
+        )}(${innerManifest.encoder}, ${prefixManifest.encoder})`,
+        decoder: fragment`${use(
+          "addDecoderSizePrefix",
+          "solanaCodecsCore"
+        )}(${innerManifest.decoder}, ${prefixManifest.decoder})`,
+        value: innerManifest.value,
+        isEnum: innerManifest.isEnum
+      };
+    },
+    visitHiddenPrefixType(node, { self }) {
+      const innerManifest = visit(node.type, self);
+      const prefixes = node.prefix.map((p) => visit(p, self));
+      const prefixEncoders = prefixes.map((p) => p.encoder.content).join(", ");
+      const prefixDecoders = prefixes.map((p) => p.decoder.content).join(", ");
+      const encoderFrag = fragment`${use(
+        "getHiddenPrefixEncoder",
+        "solanaCodecsDataStructures"
+      )}(${innerManifest.encoder}, [${fragmentFromString(prefixEncoders)}])`;
+      for (const p of prefixes) {
+        encoderFrag.imports.mergeWith(p.encoder.imports);
+      }
+      const decoderFrag = fragment`${use(
+        "getHiddenPrefixDecoder",
+        "solanaCodecsDataStructures"
+      )}(${innerManifest.decoder}, [${fragmentFromString(prefixDecoders)}])`;
+      for (const p of prefixes) {
+        decoderFrag.imports.mergeWith(p.decoder.imports);
+      }
+      return {
+        type: innerManifest.type,
+        encoder: encoderFrag,
+        decoder: decoderFrag,
+        value: innerManifest.value,
+        isEnum: innerManifest.isEnum
+      };
+    },
+    visitHiddenSuffixType(node, { self }) {
+      const innerManifest = visit(node.type, self);
+      const suffixes = node.suffix.map((s) => visit(s, self));
+      const suffixEncoders = suffixes.map((s) => s.encoder.content).join(", ");
+      const suffixDecoders = suffixes.map((s) => s.decoder.content).join(", ");
+      const encoderFrag = fragment`${use(
+        "getHiddenSuffixEncoder",
+        "solanaCodecsDataStructures"
+      )}(${innerManifest.encoder}, [${fragmentFromString(suffixEncoders)}])`;
+      for (const s of suffixes) {
+        encoderFrag.imports.mergeWith(s.encoder.imports);
+      }
+      const decoderFrag = fragment`${use(
+        "getHiddenSuffixDecoder",
+        "solanaCodecsDataStructures"
+      )}(${innerManifest.decoder}, [${fragmentFromString(suffixDecoders)}])`;
+      for (const s of suffixes) {
+        decoderFrag.imports.mergeWith(s.decoder.imports);
+      }
+      return {
+        type: innerManifest.type,
+        encoder: encoderFrag,
+        decoder: decoderFrag,
+        value: innerManifest.value,
+        isEnum: innerManifest.isEnum
+      };
+    },
+    visitSentinelType(node, { self }) {
+      const innerManifest = visit(node.type, self);
+      const sentinelManifest = visit(node.sentinel, self);
+      return {
+        type: innerManifest.type,
+        encoder: fragment`${use(
+          "addEncoderSentinel",
+          "solanaCodecsCore"
+        )}(${innerManifest.encoder}, ${sentinelManifest.encoder})`,
+        decoder: fragment`${use(
+          "addDecoderSentinel",
+          "solanaCodecsCore"
+        )}(${innerManifest.decoder}, ${sentinelManifest.decoder})`,
+        value: innerManifest.value,
+        isEnum: innerManifest.isEnum
+      };
+    },
+    visitPreOffsetType(node, { self }) {
+      return visit(node.type, self);
+    },
+    visitPostOffsetType(node, { self }) {
+      return visit(node.type, self);
+    },
+    visitSolAmountType(node, { self }) {
+      return visit(node.number, self);
+    },
+    visitAmountType(node, { self }) {
+      return visit(node.number, self);
+    },
+    visitDateTimeType(node, { self }) {
+      return visit(node.number, self);
+    },
+    visitDefinedTypeLink(node, { self }) {
+      const name = node.name;
+      const typeName = nameApi.dataType(name);
+      const isNonScalar = nonScalarEnums.includes(node.name);
+      const moduleKey = `definedType:${snakeCase(name)}`;
+      return {
+        type: fragment`${use(typeName, moduleKey)}`,
+        encoder: fragment`${use(nameApi.encoderFunction(name), moduleKey)}()`,
+        decoder: fragment`${use(nameApi.decoderFunction(name), moduleKey)}()`,
+        value: emptyTypeManifest().value,
+        isEnum: !isNonScalar
+      };
+    },
+    visitDefinedType(node, { self }) {
+      return visit(node.type, self);
+    },
+    visitAccount(node, { self }) {
+      return visit(node.data, self);
+    },
+    visitInstruction(node, { self }) {
+      return emptyTypeManifest();
+    }
+  });
+}
+function getNumberDartType(format) {
+  switch (format) {
+    case "u8":
+    case "u16":
+    case "u32":
+    case "i8":
+    case "i16":
+    case "i32":
+    case "shortU16":
+      return "int";
+    case "u64":
+    case "u128":
+    case "i64":
+    case "i128":
+      return "BigInt";
+    case "f32":
+    case "f64":
+      return "double";
+    default:
+      return "int";
+  }
+}
+function getNumberCodecName(format) {
+  switch (format) {
+    case "u8":
+      return "U8";
+    case "u16":
+      return "U16";
+    case "u32":
+      return "U32";
+    case "u64":
+      return "U64";
+    case "u128":
+      return "U128";
+    case "i8":
+      return "I8";
+    case "i16":
+      return "I16";
+    case "i32":
+      return "I32";
+    case "i64":
+      return "I64";
+    case "i128":
+      return "I128";
+    case "f32":
+      return "F32";
+    case "f64":
+      return "F64";
+    case "shortU16":
+      return "ShortU16";
+    default:
+      return "U8";
+  }
+}
+function getNumberCodecExpression(format, codecType) {
+  const name = getNumberCodecName(format);
+  return `get${name}${codecType}()`;
+}
+function getArraySizeExpression(node) {
+  if (!("count" in node) || !node.count) return "";
+  const count = node.count;
+  switch (count.kind) {
+    case "fixedCountNode":
+      return `, size: FixedArraySize(${count.value})`;
+    case "remainderCountNode":
+      return ", size: RemainderArraySize()";
+    case "prefixedCountNode": {
+      const resolvedPrefix = resolveNestedTypeNode(count.prefix);
+      if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
+        return "";
+      }
+      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+    }
+    default:
+      return "";
+  }
+}
+function getMapSizeExpression(node) {
+  if (!("count" in node) || !node.count) return "";
+  const count = node.count;
+  switch (count.kind) {
+    case "fixedCountNode":
+      return `, size: FixedArraySize(${count.value})`;
+    case "remainderCountNode":
+      return ", size: RemainderArraySize()";
+    case "prefixedCountNode": {
+      const resolvedPrefix = resolveNestedTypeNode(count.prefix);
+      if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
+        return "";
+      }
+      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+    }
+    default:
+      return "";
+  }
+}
+function getSetSizeExpression(node) {
+  if (!("count" in node) || !node.count) return "";
+  const count = node.count;
+  switch (count.kind) {
+    case "fixedCountNode":
+      return `, size: FixedArraySize(${count.value})`;
+    case "remainderCountNode":
+      return ", size: RemainderArraySize()";
+    case "prefixedCountNode": {
+      const resolvedPrefix = resolveNestedTypeNode(count.prefix);
+      if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
+        return "";
+      }
+      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+    }
+    default:
+      return "";
+  }
+}
+
+// src/fragments/discriminatorConstants.ts
+function getDiscriminatorConstantsFragment(node, scope) {
+  const discriminators = node.discriminators ?? [];
+  if (discriminators.length === 0) return emptyFragment();
+  const name = node.name;
+  const constName = scope.nameApi.discriminatorConstant(name);
+  const fragments = [];
+  for (const disc of discriminators) {
+    switch (disc.kind) {
+      case "constantDiscriminatorNode": {
+        const constDisc = disc;
+        if (constDisc.constant.value.kind === "bytesValueNode") {
+          const bytes = hexToBytes(constDisc.constant.value.data);
+          const hexList = bytesToDartHexList(bytes);
+          fragments.push(
+            fragment`/// The discriminator bytes for this ${node.kind === "accountNode" ? "account" : "instruction"}.
+final ${constName} = ${use("Uint8List", "dartTypedData")}.fromList(${fragmentFromString(hexList)});`
+          );
+        }
+        break;
+      }
+      case "fieldDiscriminatorNode": {
+        const fieldDisc = disc;
+        fragments.push(
+          fragment`/// The discriminator field name: '${fragmentFromString(fieldDisc.name)}'.
+/// Offset: ${fragmentFromString(String(fieldDisc.offset))}.`
+        );
+        break;
+      }
+      case "sizeDiscriminatorNode": {
+        const sizeDisc = disc;
+        fragments.push(
+          fragment`/// This ${node.kind === "accountNode" ? "account" : "instruction"} has a size discriminator of ${fragmentFromString(String(sizeDisc.size))} bytes.`
+        );
+        break;
+      }
+    }
+  }
+  if (fragments.length === 0) return emptyFragment();
+  return mergeFragments(fragments, (cs) => cs.join("\n\n"));
+}
+function hexToBytes(hex) {
+  const clean = hex.replace(/^0x/, "");
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < clean.length; i += 2) {
+    bytes[i / 2] = parseInt(clean.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+// src/fragments/accountPage.ts
+function getAccountPageFragment(node, scope) {
+  const name = node.name;
+  const typeName = scope.nameApi.dataType(name);
+  const dataNode = resolveNestedTypeNode(node.data);
+  const fields = dataNode.fields;
+  const fieldManifests = fields.map((f) => ({
+    field: f,
+    manifest: visit(f.type, scope.typeManifestVisitor)
+  }));
+  const fieldDecls = fieldManifests.map(({ field: f, manifest }) => {
+    return `  final ${manifest.type.content} ${camelCase(f.name)};`;
+  }).join("\n");
+  const ctorParams = fields.map((f) => `    required this.${camelCase(f.name)},`).join("\n");
+  const eqChecks = fields.length === 0 ? "true" : fields.map(
+    (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
+  ).join(" &&\n          ");
+  const hashFields = fields.map((f) => camelCase(f.name)).join(", ");
+  const toStringFields = fields.map(
+    (f) => `${camelCase(f.name)}: $${camelCase(f.name)}`
+  ).join(", ");
+  const encFields = fieldManifests.map(({ field: f, manifest }) => {
+    return `    ('${f.name}', ${manifest.encoder.content}),`;
+  }).join("\n");
+  const decFields = fieldManifests.map(({ field: f, manifest }) => {
+    return `    ('${f.name}', ${manifest.decoder.content}),`;
+  }).join("\n");
+  const toMapFields = fields.map(
+    (f) => `      '${f.name}': value.${camelCase(f.name)},`
+  ).join("\n");
+  const fromMapFields = fieldManifests.map(({ field: f, manifest }) => {
+    const typeStr = manifest.type.content;
+    const isNullable = typeStr.endsWith("?");
+    const accessor = isNullable ? `map['${f.name}']` : `map['${f.name}']!`;
+    return `      ${camelCase(f.name)}: ${accessor} as ${typeStr},`;
+  }).join("\n");
+  const encoderName = scope.nameApi.encoderFunction(name);
+  const decoderName = scope.nameApi.decoderFunction(name);
+  const codecName = scope.nameApi.codecFunction(name);
+  const decodeFnName = scope.nameApi.accountDecodeFunction(name);
+  const sizeFragment = node.size != null ? fragment`
+/// The size of the [${fragmentFromString(typeName)}] account data in bytes.
+const int ${fragmentFromString(scope.nameApi.accountSizeConstant(name))} = ${fragmentFromString(String(node.size))};` : emptyFragment();
+  const discFragment = getDiscriminatorConstantsFragment(node, scope);
+  const parts = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+${use("transformEncoder", "solanaCodecsCore")}
+${use("transformDecoder", "solanaCodecsCore")}
+${use("getStructEncoder", "solanaCodecsDataStructures")}
+${use("getStructDecoder", "solanaCodecsDataStructures")}
+${use("Account", "solanaAccounts")}
+${use("EncodedAccount", "solanaAccounts")}
+${use("decodeAccount", "solanaAccounts")}
+
+@immutable
+class ${fragmentFromString(typeName)} {
+  const ${fragmentFromString(typeName)}({
+${fragmentFromString(ctorParams)}
+  });
+
+${fragmentFromString(fieldDecls)}
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ${fragmentFromString(typeName)} &&
+          runtimeType == other.runtimeType &&
+          ${fragmentFromString(eqChecks)};
+
+  @override
+  int get hashCode => Object.hash(${fragmentFromString(hashFields)});
+
+  @override
+  String toString() => '${fragmentFromString(typeName)}(${fragmentFromString(toStringFields)})';
+}`
+  ];
+  if (sizeFragment.content) parts.push(sizeFragment);
+  if (discFragment.content) parts.push(discFragment);
+  parts.push(fragment`
+Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
+  final structEncoder = getStructEncoder(<(String, Encoder<Object?>)>[
+${fragmentFromString(encFields)}
+  ]);
+
+  return transformEncoder(
+    structEncoder,
+    (${fragmentFromString(typeName)} value) => <String, Object?>{
+${fragmentFromString(toMapFields)}
+    },
+  );
+}
+
+Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
+  final structDecoder = getStructDecoder(<(String, Decoder<Object?>)>[
+${fragmentFromString(decFields)}
+  ]);
+
+  return transformDecoder(
+    structDecoder,
+    (Map<String, Object?> map, Uint8List bytes, int offset) => ${fragmentFromString(typeName)}(
+${fragmentFromString(fromMapFields)}
+    ),
+  );
+}
+
+Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
+  return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
+}
+
+Account<${fragmentFromString(typeName)}> ${fragmentFromString(decodeFnName)}(EncodedAccount encodedAccount) {
+  return decodeAccount(encodedAccount, ${fragmentFromString(decoderName)}());
+}`);
+  const result = mergeFragments(parts, (cs) => cs.join("\n\n"));
+  for (const { manifest } of fieldManifests) {
+    result.imports.mergeWith(manifest.encoder.imports);
+    result.imports.mergeWith(manifest.decoder.imports);
+    result.imports.mergeWith(manifest.type.imports);
+  }
+  return result;
+}
+
+// src/fragments/errorPage.ts
+function getErrorPageFragment(programNode, scope) {
+  const errors = programNode.errors ?? [];
+  if (errors.length === 0) return emptyFragment();
+  const programName = programNode.name;
+  const errorConstants = errors.map((err) => {
+    const constName = scope.nameApi.errorConstant(
+      programName,
+      err.name
+    );
+    const hexCode = `0x${err.code.toString(16)}`;
+    const docs = err.docs?.length ? err.docs.map((d) => `/// ${d}`).join("\n") + "\n" : "";
+    const message = err.message ? `/// Message: "${err.message}"
+` : "";
+    return `${docs}${message}const int ${constName} = ${hexCode}; // ${err.code}`;
+  }).join("\n\n");
+  const messageEntries = errors.map((err) => {
+    const constName = scope.nameApi.errorConstant(
+      programName,
+      err.name
+    );
+    const message = err.message ?? err.name;
+    return `    ${constName}: '${escapeString(message)}',`;
+  }).join("\n");
+  const errorMessageFnName = scope.nameApi.errorMessageFunction(programName);
+  const isErrorFnName = `is${pascalCase(programName)}Error`;
+  return fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint, constant_identifier_names
+
+/// Error codes for the ${fragmentFromString(pascalCase(programName))} program.
+
+${fragmentFromString(errorConstants)}
+
+/// Map of error codes to human-readable messages.
+const Map<int, String> _${fragmentFromString(camelCase(programName))}ErrorMessages = {
+${fragmentFromString(messageEntries)}
+};
+
+/// Get the error message for a ${fragmentFromString(pascalCase(programName))} program error code.
+String? ${fragmentFromString(errorMessageFnName)}(int code) {
+  return _${fragmentFromString(camelCase(programName))}ErrorMessages[code];
+}
+
+/// Check if an error code belongs to the ${fragmentFromString(pascalCase(programName))} program.
+bool ${fragmentFromString(isErrorFnName)}(int code) {
+  return _${fragmentFromString(camelCase(programName))}ErrorMessages.containsKey(code);
+}`;
+}
+function escapeString(str) {
+  return str.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+}
+
+// src/fragments/indexPage.ts
+function getIndexPageFragment(fileNames, relativePath = "") {
+  if (fileNames.length === 0) {
+    return fragmentFromString(
+      "// Auto-generated. Do not edit.\n// ignore_for_file: type=lint\n"
+    );
+  }
+  const exports$1 = fileNames.sort().map((f) => {
+    const path = relativePath ? `${relativePath}/${f}` : f;
+    return `export '${path}';`;
+  }).join("\n");
+  return fragmentFromString(
+    `// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${exports$1}
+`
+  );
+}
+function getRootIndexPageFragment(categories) {
+  const exports$1 = categories.sort().map((cat) => `export '${cat}/${cat}.dart';`).join("\n");
+  return fragmentFromString(
+    `// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${exports$1}
+`
+  );
+}
+function getInstructionPageFragment(node, scope) {
+  const name = node.name;
+  const typeName = scope.nameApi.dataType(name);
+  const instrFnName = scope.nameApi.instructionFunction(name);
+  const parseFnName = scope.nameApi.instructionParseFunction(name);
+  const accounts = node.accounts ?? [];
+  const args = (node.arguments ?? []).filter(
+    (arg) => !isDiscriminatorArg(arg, node)
+  );
+  const allArgs = node.arguments ?? [];
+  const dataClassName = `${typeName}InstructionData`;
+  const allArgManifests = allArgs.map((arg) => ({
+    arg,
+    manifest: visit(arg.type, scope.typeManifestVisitor)
+  }));
+  const dataFieldDecls = allArgManifests.map(({ arg, manifest }) => {
+    const fieldName = camelCase(arg.name);
+    return `  final ${manifest.type.content} ${fieldName};`;
+  }).join("\n");
+  const dataCtorParams = allArgManifests.map(({ arg }) => {
+    const fieldName = camelCase(arg.name);
+    if (isDiscriminatorArg(arg, node)) {
+      return `    this.${fieldName} = ${getDiscriminatorDefault(arg)},`;
+    }
+    return `    required this.${fieldName},`;
+  }).join("\n");
+  const encFields = allArgManifests.map(({ arg, manifest }) => {
+    return `    ('${arg.name}', ${manifest.encoder.content}),`;
+  }).join("\n");
+  const decFields = allArgManifests.map(({ arg, manifest }) => {
+    return `    ('${arg.name}', ${manifest.decoder.content}),`;
+  }).join("\n");
+  const toMapFields = allArgs.map(
+    (arg) => `      '${arg.name}': value.${camelCase(arg.name)},`
+  ).join("\n");
+  const fromMapFields = allArgManifests.map(({ arg, manifest }) => {
+    const typeStr = manifest.type.content;
+    const isNullable = typeStr.endsWith("?");
+    const accessor = isNullable ? `map['${arg.name}']` : `map['${arg.name}']!`;
+    return `      ${camelCase(arg.name)}: ${accessor} as ${typeStr},`;
+  }).join("\n");
+  const dataEncoderName = `get${typeName}InstructionDataEncoder`;
+  const dataDecoderName = `get${typeName}InstructionDataDecoder`;
+  const dataCodecName = `get${typeName}InstructionDataCodec`;
+  const accountParams = accounts.map((acc) => {
+    const fieldName = camelCase(acc.name);
+    const isRequired = !(acc.isOptional ?? false);
+    return isRequired ? `  required Address ${fieldName},` : `  Address? ${fieldName},`;
+  }).join("\n");
+  const argManifestMap = new Map(allArgManifests.map(({ arg, manifest }) => [arg, manifest]));
+  const argParams = args.map((arg) => {
+    const manifest = argManifestMap.get(arg);
+    const fieldName = camelCase(arg.name);
+    const hasDefault = arg.defaultValue != null;
+    if (hasDefault) {
+      return `  ${manifest.type.content}? ${fieldName},`;
+    }
+    return `  required ${manifest.type.content} ${fieldName},`;
+  }).join("\n");
+  const accountMetas = accounts.map((acc) => {
+    const fieldName = camelCase(acc.name);
+    const role = getAccountRole(acc);
+    const isOptional = acc.isOptional ?? false;
+    if (isOptional) {
+      return `    if (${fieldName} != null) AccountMeta(address: ${fieldName}, role: ${role}),`;
+    }
+    return `    AccountMeta(address: ${fieldName}, role: ${role}),`;
+  }).join("\n");
+  const dataConstruction = allArgs.map((arg) => {
+    const fieldName = camelCase(arg.name);
+    if (isDiscriminatorArg(arg, node)) {
+      return "";
+    }
+    return `      ${fieldName}: ${fieldName}${arg.defaultValue != null ? ` ?? ${getDefaultValue(arg)}` : ""},`;
+  }).filter(Boolean).join("\n");
+  const discFragment = getDiscriminatorConstantsFragment(node, scope);
+  const parts = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+${use("transformEncoder", "solanaCodecsCore")}
+${use("transformDecoder", "solanaCodecsCore")}
+${use("getStructEncoder", "solanaCodecsDataStructures")}
+${use("getStructDecoder", "solanaCodecsDataStructures")}
+${use("Address", "solanaAddresses")}
+${use("Instruction", "solanaInstructions")}
+${use("AccountMeta", "solanaInstructions")}
+${use("AccountRole", "solanaInstructions")}`
+  ];
+  if (discFragment.content) parts.push(discFragment);
+  parts.push(fragment`
+@immutable
+class ${fragmentFromString(dataClassName)} {
+  const ${fragmentFromString(dataClassName)}({
+${fragmentFromString(dataCtorParams)}
+  });
+
+${fragmentFromString(dataFieldDecls)}
+}`);
+  parts.push(fragment`
+Encoder<${fragmentFromString(dataClassName)}> ${fragmentFromString(dataEncoderName)}() {
+  final structEncoder = getStructEncoder(<(String, Encoder<Object?>)>[
+${fragmentFromString(encFields)}
+  ]);
+
+  return transformEncoder(
+    structEncoder,
+    (${fragmentFromString(dataClassName)} value) => <String, Object?>{
+${fragmentFromString(toMapFields)}
+    },
+  );
+}
+
+Decoder<${fragmentFromString(dataClassName)}> ${fragmentFromString(dataDecoderName)}() {
+  final structDecoder = getStructDecoder(<(String, Decoder<Object?>)>[
+${fragmentFromString(decFields)}
+  ]);
+
+  return transformDecoder(
+    structDecoder,
+    (Map<String, Object?> map, Uint8List bytes, int offset) => ${fragmentFromString(dataClassName)}(
+${fragmentFromString(fromMapFields)}
+    ),
+  );
+}
+
+Codec<${fragmentFromString(dataClassName)}, ${fragmentFromString(dataClassName)}> ${fragmentFromString(dataCodecName)}() {
+  return combineCodec(${fragmentFromString(dataEncoderName)}(), ${fragmentFromString(dataDecoderName)}());
+}`);
+  parts.push(fragment`
+/// Creates a [${fragmentFromString(typeName)}] instruction.
+Instruction ${fragmentFromString(instrFnName)}({
+  required Address programAddress,
+${fragmentFromString(accountParams)}
+${fragmentFromString(argParams)}
+}) {
+  final data = ${fragmentFromString(dataClassName)}(
+${fragmentFromString(dataConstruction)}
+  );
+
+  return Instruction(
+    programAddress: programAddress,
+    accounts: [
+${fragmentFromString(accountMetas)}
+    ],
+    data: ${fragmentFromString(dataEncoderName)}().encode(data),
+  );
+}`);
+  parts.push(fragment`
+/// Parses a [${fragmentFromString(typeName)}] instruction from raw instruction data.
+${fragmentFromString(dataClassName)} ${fragmentFromString(parseFnName)}(Instruction instruction) {
+  return ${fragmentFromString(dataDecoderName)}().decode(instruction.data!);
+}`);
+  const result = mergeFragments(parts, (cs) => cs.join("\n"));
+  for (const { manifest } of allArgManifests) {
+    result.imports.mergeWith(manifest.encoder.imports);
+    result.imports.mergeWith(manifest.decoder.imports);
+    result.imports.mergeWith(manifest.type.imports);
+  }
+  return result;
+}
+function getAccountRole(acc) {
+  const isSigner = acc.isSigner === true || acc.isSigner === "either";
+  const isWritable = acc.isWritable ?? false;
+  if (isSigner && isWritable) return "AccountRole.writableSigner";
+  if (isSigner) return "AccountRole.readonlySigner";
+  if (isWritable) return "AccountRole.writable";
+  return "AccountRole.readonly";
+}
+function isDiscriminatorArg(arg, node) {
+  const discriminators = node.discriminators ?? [];
+  return discriminators.some(
+    (d) => d.kind === "fieldDiscriminatorNode" && d.name === arg.name
+  );
+}
+function getDiscriminatorDefault(arg, _node) {
+  if (arg.defaultValue) {
+    if (arg.defaultValue.kind === "numberValueNode") {
+      return String(arg.defaultValue.number);
+    }
+  }
+  return "0";
+}
+function getDefaultValue(arg) {
+  if (!arg.defaultValue) return "null";
+  const dv = arg.defaultValue;
+  switch (dv.kind) {
+    case "numberValueNode":
+      return String(dv.number);
+    case "booleanValueNode":
+      return String(dv.boolean);
+    case "stringValueNode":
+      return `'${dv.string}'`;
+    case "publicKeyValueNode":
+      return `Address('${dv.publicKey}')`;
+    case "noneValueNode":
+      return "null";
+    default:
+      return "null";
+  }
+}
+function getPdaPageFragment(node, scope) {
+  const name = node.name;
+  const findFnName = scope.nameApi.pdaFindFunction(name);
+  const seedsClassName = `${pascalCase(name)}Seeds`;
+  const seeds = node.seeds ?? [];
+  const variableSeeds = seeds.filter(
+    (s) => s.kind === "variablePdaSeedNode"
+  );
+  seeds.filter(
+    (s) => s.kind === "constantPdaSeedNode"
+  );
+  const hasSeedsClass = variableSeeds.length > 0;
+  const seedFieldDecls = variableSeeds.map((s) => {
+    if (s.kind !== "variablePdaSeedNode") return "";
+    const manifest = visit(s.type, scope.typeManifestVisitor);
+    return `  final ${manifest.type.content} ${camelCase(s.name)};`;
+  }).join("\n");
+  const seedCtorParams = variableSeeds.map((s) => {
+    if (s.kind !== "variablePdaSeedNode") return "";
+    return `    required this.${camelCase(s.name)},`;
+  }).join("\n");
+  const seedBytesList = [];
+  for (const seed of seeds) {
+    if (seed.kind === "constantPdaSeedNode") {
+      if (seed.value.kind === "bytesValueNode") {
+        seedBytesList.push(`    ...${bytesValueToDart(seed.value.data)},`);
+      } else if (seed.value.kind === "stringValueNode") {
+        seedBytesList.push(`    ...utf8.encode('${seed.value.string}'),`);
+      } else if (seed.value.kind === "publicKeyValueNode") {
+        seedBytesList.push(`    ...getAddressEncoder().encode(Address('${seed.value.publicKey}')),`);
+      } else if (seed.value.kind === "numberValueNode") {
+        const manifest = visit(seed.type, scope.typeManifestVisitor);
+        seedBytesList.push(`    ...${manifest.encoder.content}.encode(${seed.value.number}),`);
+      }
+    } else if (seed.kind === "variablePdaSeedNode") {
+      const manifest = visit(seed.type, scope.typeManifestVisitor);
+      seedBytesList.push(
+        `    ...${manifest.encoder.content}.encode(seeds.${camelCase(seed.name)}),`
+      );
+    }
+  }
+  const programIdParam = node.programId ? `Address programAddress = const Address('${node.programId}')` : "required Address programAddress";
+  const parts = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Address", "solanaAddresses")}
+${use("getAddressEncoder", "solanaAddresses")}`
+  ];
+  if (hasSeedsClass) {
+    parts.push(fragment`
+@immutable
+class ${fragmentFromString(seedsClassName)} {
+  const ${fragmentFromString(seedsClassName)}({
+${fragmentFromString(seedCtorParams)}
+  });
+
+${fragmentFromString(seedFieldDecls)}
+}`);
+  }
+  const seedsParam = hasSeedsClass ? `  required ${seedsClassName} seeds,` : "";
+  parts.push(fragment`
+/// Finds the program derived address for [${fragmentFromString(pascalCase(name))}].
+Future<(Address, int)> ${fragmentFromString(findFnName)}({
+${fragmentFromString(seedsParam)}
+  ${fragmentFromString(programIdParam)},
+}) async {
+  final seedBytes = <int>[
+${fragmentFromString(seedBytesList.join("\n"))}
+  ];
+
+  // TODO: Call getProgramDerivedAddress with seedBytes and programAddress
+  throw UnimplementedError('PDA derivation not yet implemented');
+}`);
+  return mergeFragments(parts, (cs) => cs.join("\n"));
+}
+function bytesValueToDart(hex) {
+  const clean = hex.replace(/^0x/, "");
+  const pairs = [];
+  for (let i = 0; i < clean.length; i += 2) {
+    pairs.push(`0x${clean.slice(i, i + 2)}`);
+  }
+  return `[${pairs.join(", ")}]`;
+}
+
+// src/fragments/programPage.ts
+function getProgramPageFragment(node, scope) {
+  const name = node.name;
+  const addressConstName = scope.nameApi.programAddressConstant(name);
+  const parts = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Address", "solanaAddresses")}
+
+/// The address of the ${fragmentFromString(pascalCase(name))} program.
+const ${fragmentFromString(addressConstName)} = Address('${fragmentFromString(node.publicKey)}');`
+  ];
+  const accounts = node.accounts ?? [];
+  if (accounts.length > 0) {
+    const accountVariants = accounts.map((acc) => `  ${camelCase(acc.name)},`).join("\n");
+    parts.push(fragment`
+/// Known accounts for the ${fragmentFromString(pascalCase(name))} program.
+enum ${fragmentFromString(pascalCase(name))}Account {
+${fragmentFromString(accountVariants)}
+}`);
+  }
+  const instructions = node.instructions ?? [];
+  if (instructions.length > 0) {
+    const instrVariants = instructions.map((instr) => `  ${camelCase(instr.name)},`).join("\n");
+    parts.push(fragment`
+/// Known instructions for the ${fragmentFromString(pascalCase(name))} program.
+enum ${fragmentFromString(pascalCase(name))}Instruction {
+${fragmentFromString(instrVariants)}
+}`);
+  }
+  return mergeFragments(parts, (cs) => cs.join("\n"));
+}
+function getTypePageFragment(node, scope) {
+  const name = node.name;
+  scope.nameApi.dataType(name);
+  const typeNode = node.type;
+  if (typeNode.kind === "enumTypeNode") {
+    const isScalar = typeNode.variants.every(
+      (v) => v.kind === "enumEmptyVariantTypeNode"
+    );
+    if (isScalar) {
+      return getScalarEnumPageFragment(node, scope);
+    }
+    return getDataEnumPageFragment(node, scope);
+  }
+  if (typeNode.kind === "structTypeNode") {
+    return getStructPageFragment(node, scope);
+  }
+  return getTypeAliasPageFragment(node, scope);
+}
+function getScalarEnumPageFragment(node, scope) {
+  const name = node.name;
+  const typeName = scope.nameApi.dataType(name);
+  const enumNode = node.type;
+  if (enumNode.kind !== "enumTypeNode") return emptyFragment();
+  const variants = enumNode.variants.map((v) => {
+    const variantName = scope.nameApi.enumVariant(v.name);
+    return variantName;
+  });
+  const variantLines = variants.map((v) => `  ${v},`).join("\n");
+  const encoderName = scope.nameApi.encoderFunction(name);
+  const decoderName = scope.nameApi.decoderFunction(name);
+  const codecName = scope.nameApi.codecFunction(name);
+  const resolvedSize = resolveNestedTypeNode(enumNode.size);
+  const sizeType = resolvedSize.format ?? "u8";
+  const sizeCodecName = getNumberCodecName2(sizeType);
+  return fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+${use("transformEncoder", "solanaCodecsCore")}
+${use("transformDecoder", "solanaCodecsCore")}
+${use(`get${sizeCodecName}Encoder`, "solanaCodecsNumbers")}
+${use(`get${sizeCodecName}Decoder`, "solanaCodecsNumbers")}
+
+enum ${fragmentFromString(typeName)} {
+${fragmentFromString(variantLines)}
+}
+
+Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
+  return transformEncoder(
+    get${fragmentFromString(sizeCodecName)}Encoder(),
+    (${fragmentFromString(typeName)} value) => value.index,
+  );
+}
+
+Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
+  return transformDecoder(
+    get${fragmentFromString(sizeCodecName)}Decoder(),
+    (int value, Uint8List bytes, int offset) => ${fragmentFromString(typeName)}.values[value],
+  );
+}
+
+Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
+  return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
+}`;
+}
+function getDataEnumPageFragment(node, scope) {
+  const name = node.name;
+  const typeName = scope.nameApi.dataType(name);
+  const enumNode = node.type;
+  if (enumNode.kind !== "enumTypeNode") return emptyFragment();
+  const variantClasses = [];
+  const encoderVariants = [];
+  const decoderVariants = [];
+  const allVariantManifests = [];
+  for (let i = 0; i < enumNode.variants.length; i++) {
+    const variant = enumNode.variants[i];
+    const variantClassName = scope.nameApi.sealedClassVariant(
+      name,
+      variant.name
+    );
+    if (variant.kind === "enumEmptyVariantTypeNode") {
+      variantClasses.push(`final class ${variantClassName} extends ${typeName} {
+  const ${variantClassName}();
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) || other is ${variantClassName};
+
+  @override
+  int get hashCode => runtimeType.hashCode;
+
+  @override
+  String toString() => '${typeName}.${variantClassName}()';
+}`);
+      encoderVariants.push(
+        `(${i}, getStructEncoder(<(String, Encoder<Object?>)>[]))`
+      );
+      decoderVariants.push(
+        `(${i}, getStructDecoder(<(String, Decoder<Object?>)>[]).map((_) => const ${variantClassName}()))`
+      );
+    } else if (variant.kind === "enumStructVariantTypeNode") {
+      const resolvedStruct = resolveNestedTypeNode(variant.struct);
+      const fields = resolvedStruct.fields;
+      const fieldManifests = fields.map((f) => ({
+        field: f,
+        manifest: visit(f.type, scope.typeManifestVisitor)
+      }));
+      for (const { manifest } of fieldManifests) {
+        allVariantManifests.push(manifest);
+      }
+      const fieldDecls = fieldManifests.map(({ field: f, manifest }) => {
+        return `  final ${manifest.type.content} ${camelCase(f.name)};`;
+      }).join("\n");
+      const ctorParams = fields.map((f) => `    required this.${camelCase(f.name)},`).join("\n");
+      const eqChecks = fields.map((f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`).join(" &&\n          ");
+      const hashFields = fields.map((f) => camelCase(f.name)).join(", ");
+      const toStringFields = fields.map((f) => `${camelCase(f.name)}: $${camelCase(f.name)}`).join(", ");
+      variantClasses.push(`final class ${variantClassName} extends ${typeName} {
+  const ${variantClassName}({
+${ctorParams}
+  });
+
+${fieldDecls}
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ${variantClassName} &&
+          ${eqChecks};
+
+  @override
+  int get hashCode => Object.hash(${hashFields});
+
+  @override
+  String toString() => '${typeName}.${variantClassName}(${toStringFields})';
+}`);
+      const encFields = fieldManifests.map(({ field: f, manifest }) => {
+        return `('${f.name}', ${manifest.encoder.content})`;
+      }).join(", ");
+      const decFields = fieldManifests.map(({ field: f, manifest }) => {
+        return `('${f.name}', ${manifest.decoder.content})`;
+      }).join(", ");
+      const fromMapFields = fieldManifests.map(
+        ({ field: f, manifest }) => {
+          const typeStr = manifest.type.content;
+          const isNullable = typeStr.endsWith("?");
+          const accessor = isNullable ? `map['${f.name}']` : `map['${f.name}']!`;
+          return `${camelCase(f.name)}: ${accessor} as ${typeStr}`;
+        }
+      ).join(", ");
+      const toMapFields = fields.map(
+        (f) => `'${f.name}': value.${camelCase(f.name)}`
+      ).join(", ");
+      encoderVariants.push(
+        `(${i}, transformEncoder(getStructEncoder([${encFields}]), (${variantClassName} value) => <String, Object?>{${toMapFields}}))`
+      );
+      decoderVariants.push(
+        `(${i}, transformDecoder(getStructDecoder([${decFields}]), (Map<String, Object?> map, Uint8List bytes, int offset) => ${variantClassName}(${fromMapFields})))`
+      );
+    } else if (variant.kind === "enumTupleVariantTypeNode") {
+      const resolvedTuple = resolveNestedTypeNode(variant.tuple);
+      const items = resolvedTuple.items;
+      if (items.length === 1) {
+        const manifest = visit(items[0], scope.typeManifestVisitor);
+        allVariantManifests.push(manifest);
+        variantClasses.push(`final class ${variantClassName} extends ${typeName} {
+  const ${variantClassName}(this.value);
+
+  final ${manifest.type.content} value;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ${variantClassName} && value == other.value;
+
+  @override
+  int get hashCode => value.hashCode;
+
+  @override
+  String toString() => '${typeName}.${variantClassName}($value)';
+}`);
+        encoderVariants.push(
+          `(${i}, transformEncoder(${manifest.encoder.content}, (${variantClassName} value) => value.value))`
+        );
+        decoderVariants.push(
+          `(${i}, transformDecoder(${manifest.decoder.content}, (${manifest.type.content} value, Uint8List bytes, int offset) => ${variantClassName}(value)))`
+        );
+      }
+    }
+  }
+  const encoderName = scope.nameApi.encoderFunction(name);
+  const decoderName = scope.nameApi.decoderFunction(name);
+  const codecName = scope.nameApi.codecFunction(name);
+  const resolvedSize = resolveNestedTypeNode(enumNode.size);
+  const sizeType = resolvedSize.format ?? "u8";
+  const sizeCodecName = getNumberCodecName2(sizeType);
+  const result = fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+${use("transformEncoder", "solanaCodecsCore")}
+${use("transformDecoder", "solanaCodecsCore")}
+${use("getStructEncoder", "solanaCodecsDataStructures")}
+${use("getStructDecoder", "solanaCodecsDataStructures")}
+${use("getDiscriminatedUnionEncoder", "solanaCodecsDataStructures")}
+${use("getDiscriminatedUnionDecoder", "solanaCodecsDataStructures")}
+${use(`get${sizeCodecName}Encoder`, "solanaCodecsNumbers")}
+${use(`get${sizeCodecName}Decoder`, "solanaCodecsNumbers")}
+
+sealed class ${fragmentFromString(typeName)} {
+  const ${fragmentFromString(typeName)}();
+}
+
+${fragmentFromString(variantClasses.join("\n\n"))}
+
+Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
+  return getDiscriminatedUnionEncoder([
+    ${fragmentFromString(encoderVariants.join(",\n    "))},
+  ], size: get${fragmentFromString(sizeCodecName)}Encoder());
+}
+
+Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
+  return getDiscriminatedUnionDecoder([
+    ${fragmentFromString(decoderVariants.join(",\n    "))},
+  ], size: get${fragmentFromString(sizeCodecName)}Decoder());
+}
+
+Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
+  return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
+}`;
+  for (const manifest of allVariantManifests) {
+    result.imports.mergeWith(manifest.encoder.imports);
+    result.imports.mergeWith(manifest.decoder.imports);
+    result.imports.mergeWith(manifest.type.imports);
+  }
+  return result;
+}
+function getStructPageFragment(node, scope) {
+  const name = node.name;
+  const typeName = scope.nameApi.dataType(name);
+  const structNode = node.type;
+  if (structNode.kind !== "structTypeNode") return emptyFragment();
+  const fields = structNode.fields;
+  const fieldManifests = fields.map((f) => ({
+    field: f,
+    manifest: visit(f.type, scope.typeManifestVisitor)
+  }));
+  const fieldDecls = fieldManifests.map(({ field: f, manifest }) => {
+    return `  final ${manifest.type.content} ${camelCase(f.name)};`;
+  }).join("\n");
+  const ctorParams = fields.map((f) => `    required this.${camelCase(f.name)},`).join("\n");
+  const eqChecks = fields.length === 0 ? "true" : fields.map(
+    (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
+  ).join(" &&\n          ");
+  const hashFields = fields.map((f) => camelCase(f.name)).join(", ");
+  const toStringFields = fields.map(
+    (f) => `${camelCase(f.name)}: $${camelCase(f.name)}`
+  ).join(", ");
+  const encoderName = scope.nameApi.encoderFunction(name);
+  const decoderName = scope.nameApi.decoderFunction(name);
+  const codecName = scope.nameApi.codecFunction(name);
+  const encFields = fieldManifests.map(({ field: f, manifest }) => {
+    return `    ('${f.name}', ${manifest.encoder.content}),`;
+  }).join("\n");
+  const decFields = fieldManifests.map(({ field: f, manifest }) => {
+    return `    ('${f.name}', ${manifest.decoder.content}),`;
+  }).join("\n");
+  const toMapFields = fields.map(
+    (f) => `      '${f.name}': value.${camelCase(f.name)},`
+  ).join("\n");
+  const fromMapFields = fieldManifests.map(({ field: f, manifest }) => {
+    const typeStr = manifest.type.content;
+    const isNullable = typeStr.endsWith("?");
+    const accessor = isNullable ? `map['${f.name}']` : `map['${f.name}']!`;
+    return `      ${camelCase(f.name)}: ${accessor} as ${typeStr},`;
+  }).join("\n");
+  const result = fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+${use("transformEncoder", "solanaCodecsCore")}
+${use("transformDecoder", "solanaCodecsCore")}
+${use("getStructEncoder", "solanaCodecsDataStructures")}
+${use("getStructDecoder", "solanaCodecsDataStructures")}
+
+@immutable
+class ${fragmentFromString(typeName)} {
+  const ${fragmentFromString(typeName)}({
+${fragmentFromString(ctorParams)}
+  });
+
+${fragmentFromString(fieldDecls)}
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ${fragmentFromString(typeName)} &&
+          runtimeType == other.runtimeType &&
+          ${fragmentFromString(eqChecks)};
+
+  @override
+  int get hashCode => Object.hash(${fragmentFromString(hashFields)});
+
+  @override
+  String toString() => '${fragmentFromString(typeName)}(${fragmentFromString(toStringFields)})';
+}
+
+Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
+  final structEncoder = getStructEncoder(<(String, Encoder<Object?>)>[
+${fragmentFromString(encFields)}
+  ]);
+
+  return transformEncoder(
+    structEncoder,
+    (${fragmentFromString(typeName)} value) => <String, Object?>{
+${fragmentFromString(toMapFields)}
+    },
+  );
+}
+
+Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
+  final structDecoder = getStructDecoder(<(String, Decoder<Object?>)>[
+${fragmentFromString(decFields)}
+  ]);
+
+  return transformDecoder(
+    structDecoder,
+    (Map<String, Object?> map, Uint8List bytes, int offset) => ${fragmentFromString(typeName)}(
+${fragmentFromString(fromMapFields)}
+    ),
+  );
+}
+
+Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
+  return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
+}`;
+  for (const { manifest } of fieldManifests) {
+    result.imports.mergeWith(manifest.encoder.imports);
+    result.imports.mergeWith(manifest.decoder.imports);
+    result.imports.mergeWith(manifest.type.imports);
+  }
+  return result;
+}
+function getTypeAliasPageFragment(node, scope) {
+  const name = node.name;
+  const typeName = scope.nameApi.dataType(name);
+  const manifest = visit(node.type, scope.typeManifestVisitor);
+  const encoderName = scope.nameApi.encoderFunction(name);
+  const decoderName = scope.nameApi.decoderFunction(name);
+  const codecName = scope.nameApi.codecFunction(name);
+  return fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+
+typedef ${fragmentFromString(typeName)} = ${manifest.type};
+
+Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
+  return ${manifest.encoder};
+}
+
+Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
+  return ${manifest.decoder};
+}
+
+Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
+  return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
+}`;
+}
+function getNumberCodecName2(format) {
+  switch (format) {
+    case "u8":
+      return "U8";
+    case "u16":
+      return "U16";
+    case "u32":
+      return "U32";
+    case "u64":
+      return "U64";
+    case "u128":
+      return "U128";
+    case "i8":
+      return "I8";
+    case "i16":
+      return "I16";
+    case "i32":
+      return "I32";
+    case "i64":
+      return "I64";
+    case "i128":
+      return "I128";
+    case "f32":
+      return "F32";
+    case "f64":
+      return "F64";
+    case "shortU16":
+      return "ShortU16";
+    default:
+      return "U8";
+  }
+}
+
+// src/visitors/getRenderMapVisitor.ts
+function getRenderMapVisitor(options = {}) {
+  const nameApi = {
+    ...createDartNameApi(),
+    ...options.nameApi
+  };
+  options.dependencyMap ?? {};
+  const stack = new NodeStack();
+  const linkables = new LinkableDictionary();
+  const typeManifestVisitor = getTypeManifestVisitor({
+    nameApi,
+    linkables});
+  const scope = {
+    nameApi,
+    typeManifestVisitor};
+  return pipe(
+    staticVisitor(
+      () => createRenderMap(),
+      {
+        keys: [
+          "rootNode",
+          "programNode",
+          "accountNode",
+          "definedTypeNode",
+          "instructionNode",
+          "pdaNode"
+        ]
+      }
+    ),
+    (v) => extendVisitor(v, {
+      visitRoot(node, { self }) {
+        const programMaps = [
+          visit(node.program, self),
+          ...node.additionalPrograms.map((p) => visit(p, self))
+        ];
+        return mergeRenderMaps(programMaps);
+      },
+      visitProgram(node, { self }) {
+        const programName = node.name;
+        const maps = [];
+        const accountFiles = [];
+        const instructionFiles = [];
+        const typeFiles = [];
+        const pdaFiles = [];
+        const errorFiles = [];
+        const programFiles = [];
+        for (const account of node.accounts ?? []) {
+          maps.push(visit(account, self));
+          accountFiles.push(`${snakeCase(account.name)}.dart`);
+        }
+        for (const instruction of node.instructions ?? []) {
+          maps.push(visit(instruction, self));
+          instructionFiles.push(
+            `${snakeCase(instruction.name)}.dart`
+          );
+        }
+        for (const definedType of node.definedTypes ?? []) {
+          maps.push(visit(definedType, self));
+          typeFiles.push(
+            `${snakeCase(definedType.name)}.dart`
+          );
+        }
+        for (const pda of node.pdas ?? []) {
+          maps.push(visit(pda, self));
+          pdaFiles.push(`${snakeCase(pda.name)}.dart`);
+        }
+        const programFragment = getProgramPageFragment(node, scope);
+        const programFileName = `${snakeCase(programName)}.dart`;
+        programFiles.push(programFileName);
+        let programMap = createRenderMap();
+        programMap = addToRenderMap(programMap, `programs/${programFileName}`, programFragment);
+        maps.push(programMap);
+        const errors = node.errors ?? [];
+        if (errors.length > 0) {
+          const errorFragment = getErrorPageFragment(node, scope);
+          const errorFileName = `${snakeCase(programName)}.dart`;
+          errorFiles.push(errorFileName);
+          let errorMap = createRenderMap();
+          errorMap = addToRenderMap(errorMap, `errors/${errorFileName}`, errorFragment);
+          maps.push(errorMap);
+        }
+        const categories = [];
+        if (accountFiles.length > 0) {
+          categories.push("accounts");
+          let indexMap = createRenderMap();
+          indexMap = addToRenderMap(
+            indexMap,
+            "accounts/accounts.dart",
+            getIndexPageFragment(accountFiles)
+          );
+          maps.push(indexMap);
+        }
+        if (instructionFiles.length > 0) {
+          categories.push("instructions");
+          let indexMap = createRenderMap();
+          indexMap = addToRenderMap(
+            indexMap,
+            "instructions/instructions.dart",
+            getIndexPageFragment(instructionFiles)
+          );
+          maps.push(indexMap);
+        }
+        if (typeFiles.length > 0) {
+          categories.push("types");
+          let indexMap = createRenderMap();
+          indexMap = addToRenderMap(
+            indexMap,
+            "types/types.dart",
+            getIndexPageFragment(typeFiles)
+          );
+          maps.push(indexMap);
+        }
+        if (pdaFiles.length > 0) {
+          categories.push("pdas");
+          let indexMap = createRenderMap();
+          indexMap = addToRenderMap(
+            indexMap,
+            "pdas/pdas.dart",
+            getIndexPageFragment(pdaFiles)
+          );
+          maps.push(indexMap);
+        }
+        if (errorFiles.length > 0) {
+          categories.push("errors");
+          let indexMap = createRenderMap();
+          indexMap = addToRenderMap(
+            indexMap,
+            "errors/errors.dart",
+            getIndexPageFragment(errorFiles)
+          );
+          maps.push(indexMap);
+        }
+        if (programFiles.length > 0) {
+          categories.push("programs");
+          let indexMap = createRenderMap();
+          indexMap = addToRenderMap(
+            indexMap,
+            "programs/programs.dart",
+            getIndexPageFragment(programFiles)
+          );
+          maps.push(indexMap);
+        }
+        if (categories.length > 0) {
+          let rootMap = createRenderMap();
+          rootMap = addToRenderMap(
+            rootMap,
+            `${snakeCase(programName)}.dart`,
+            getRootIndexPageFragment(categories)
+          );
+          maps.push(rootMap);
+        }
+        return mergeRenderMaps(maps);
+      },
+      visitAccount(node, { self }) {
+        const fileName = `${snakeCase(node.name)}.dart`;
+        const frag = getAccountPageFragment(node, scope);
+        let map = createRenderMap();
+        map = addToRenderMap(map, `accounts/${fileName}`, frag);
+        return map;
+      },
+      visitDefinedType(node, { self }) {
+        const fileName = `${snakeCase(node.name)}.dart`;
+        const frag = getTypePageFragment(node, scope);
+        let map = createRenderMap();
+        map = addToRenderMap(map, `types/${fileName}`, frag);
+        return map;
+      },
+      visitInstruction(node, { self }) {
+        const fileName = `${snakeCase(node.name)}.dart`;
+        const frag = getInstructionPageFragment(node, scope);
+        let map = createRenderMap();
+        map = addToRenderMap(map, `instructions/${fileName}`, frag);
+        return map;
+      },
+      visitPda(node, { self }) {
+        const fileName = `${snakeCase(node.name)}.dart`;
+        const frag = getPdaPageFragment(node, scope);
+        let map = createRenderMap();
+        map = addToRenderMap(map, `pdas/${fileName}`, frag);
+        return map;
+      }
+    }),
+    (v) => recordNodeStackVisitor(v, stack),
+    (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
+  );
+}
+
+// src/visitors/renderVisitor.ts
+function renderVisitor(outputDir, options = {}) {
+  const {
+    deleteFolderBeforeRendering = true,
+    formatCode = false,
+    nameApi,
+    dependencyMap
+  } = options;
+  return rootNodeVisitor((root) => {
+    if (deleteFolderBeforeRendering && existsSync(outputDir)) {
+      deleteDirectory(outputDir);
+    }
+    const renderMap = visit(
+      root,
+      getRenderMapVisitor({ nameApi, dependencyMap })
+    );
+    const typePathMap = {};
+    for (const renderPath of renderMap.keys()) {
+      const match = renderPath.match(/^(?:.*\/)?types\/([a-z_]+)\.dart$/);
+      if (match) {
+        typePathMap[`definedType:${match[1]}`] = renderPath;
+      }
+    }
+    for (const [filePath, frag] of renderMap.entries()) {
+      const fullPath = join(outputDir, filePath);
+      const dir = dirname(fullPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      const fileDir = dirname(filePath);
+      const internalMap = {};
+      for (const [key, typePath] of Object.entries(typePathMap)) {
+        if (typePath === filePath) continue;
+        let rel = posix.relative(fileDir, typePath);
+        if (!rel.startsWith(".")) {
+          rel = `./${rel}`;
+        }
+        internalMap[key] = rel;
+      }
+      const content = resolveFragmentContent(frag, dependencyMap ?? {}, internalMap);
+      writeFileSync(fullPath, content, "utf-8");
+    }
+    if (formatCode) {
+      formatDartDirectory(outputDir);
+    }
+  });
+}
+function resolveFragmentContent(frag, dependencyMap, internalMap = {}) {
+  const { content, imports } = frag;
+  const importStr = imports.toString({
+    ...internalMap,
+    ...dependencyMap
+  });
+  if (!importStr) {
+    return content + "\n";
+  }
+  const lines = content.split("\n");
+  const headerLines = [];
+  let restIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("//") || lines[i].trim() === "") {
+      headerLines.push(lines[i]);
+      restIndex = i + 1;
+    } else {
+      break;
+    }
+  }
+  const header = headerLines.join("\n");
+  const rest = lines.slice(restIndex).join("\n");
+  const cleanContent = cleanFragmentContent(rest);
+  return `${header}
+
+${importStr}
+
+${cleanContent}
+`;
+}
+function cleanFragmentContent(content) {
+  const lines = content.split("\n");
+  const cleanLines = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (/^[a-zA-Z][a-zA-Z0-9]*$/.test(trimmed)) {
+      return false;
+    }
+    return true;
+  });
+  return cleanLines.join("\n");
+}
+
+// src/index.ts
+var src_default = renderVisitor;
+
+export { DART_EXTERNAL_PACKAGE_MAP, DartImportMap, createDartNameApi, src_default as default, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
+//# sourceMappingURL=index.node.js.map
+//# sourceMappingURL=index.node.js.map