codama-renderers-dart 0.5.3 → 0.5.4

package/dist/index.node.js

@@ -2,13 +2,13 @@ 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 { execFileSync } from 'child_process';
 import { resolveNestedTypeNode, getAllInstructionsWithSubs } from '@codama/nodes';
 import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
 
 // src/visitors/renderVisitor.ts
 function formatDartDirectory(dir) {
-  execSync(`dart format "${dir}"`, {
+  execFileSync("dart", ["format", "--", dir], {
     encoding: "utf-8",
     timeout: 6e4,
     stdio: ["pipe", "pipe", "pipe"]
@@ -78,6 +78,7 @@ function setEmptyCollection(record, key) {
 
 // src/utils/nameTransformers.ts
 function pascalCase(str) {
+  assertSafeName(str);
   return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
 }
 var DART_RESERVED_WORDS = /* @__PURE__ */ new Set([
@@ -159,6 +160,7 @@ function camelCase(str) {
   return escapeDartIdentifier(cased);
 }
 function snakeCase(str) {
+  assertSafeName(str);
   return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").replace(/_+/g, "_").toLowerCase();
 }
 function createDartNameApi() {
@@ -184,6 +186,11 @@ function createDartNameApi() {
     discriminatorConstant: (name) => `${camelCase(name)}Discriminator`
   };
 }
+function assertSafeName(name) {
+  if (!/^[a-zA-Z0-9_ -]*$/.test(name)) {
+    throw new Error(`Invalid Dart node name: ${JSON.stringify(name)}`);
+  }
+}
 
 // src/utils/codecs.ts
 function bytesToDartHexList(bytes) {
@@ -394,10 +401,19 @@ var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
 function getDartValueFragment(value, dartType) {
   switch (value.kind) {
     case "numberValueNode":
+      if (typeof value.number !== "number" || !Number.isFinite(value.number)) {
+        throw new Error("Invalid Dart number: expected a finite number");
+      }
+      if (dartType === "BigInt" && !Number.isSafeInteger(value.number)) {
+        throw new Error("Invalid Dart BigInt: expected a safe integer");
+      }
       return fragmentFromString(
         dartType === "BigInt" ? `BigInt.from(${value.number})` : String(value.number)
       );
     case "booleanValueNode":
+      if (typeof value.boolean !== "boolean") {
+        throw new Error("Invalid Dart boolean: expected a boolean");
+      }
       return fragmentFromString(String(value.boolean));
     case "stringValueNode":
       return fragmentFromString(toDartStringLiteral(value.string));
@@ -441,6 +457,12 @@ function isConstDartValueNode(value) {
 function toDartStringLiteral(value) {
   return `'${value.replaceAll("\\", "\\\\").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t").replaceAll("\b", "\\b").replaceAll("\f", "\\f").replaceAll("$", "\\$").replaceAll("'", "\\'")}'`;
 }
+function getNonNegativeInteger(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("Expected a non-negative safe integer value");
+  }
+  return String(value);
+}
 
 // src/utils/discriminators.ts
 function getDiscriminatorValidationFragment(node, scope) {
@@ -641,23 +663,12 @@ function getTypeManifestVisitor(input) {
     }
   );
   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);
+    visitNumberType(node) {
       return {
         // `BigInt` and other number types live in `dart:core` and need no import.
-        type: 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("")})`,
+        type: fragmentFromString(getNumberDartType(node.format)),
+        encoder: getNumberCodecExpression(node, "Encoder"),
+        decoder: getNumberCodecExpression(node, "Decoder"),
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -838,7 +849,7 @@ function getTypeManifestVisitor(input) {
       const fields = nodeFields.map((f) => visit(f, self));
       const fieldNames = nodeFields.map((f) => f.name);
       const typeStr = "Map<String, Object?>";
-      const encoderFields = fields.map((f, i) => `('${fieldNames[i]}', ${f.encoder.content})`).join(", ");
+      const encoderFields = fields.map((f, i) => `(${toDartStringLiteral(fieldNames[i])}, ${f.encoder.content})`).join(", ");
       const encoderFrag = fragment`${use(
         "getStructEncoder",
         "solanaCodecsDataStructures"
@@ -846,7 +857,7 @@ function getTypeManifestVisitor(input) {
       for (const f of fields) {
         encoderFrag.imports.mergeWith(f.encoder.imports);
       }
-      const decoderFields = fields.map((f, i) => `('${fieldNames[i]}', ${f.decoder.content})`).join(", ");
+      const decoderFields = fields.map((f, i) => `(${toDartStringLiteral(fieldNames[i])}, ${f.decoder.content})`).join(", ");
       const decoderFrag = fragment`${use(
         "getStructDecoder",
         "solanaCodecsDataStructures"
@@ -900,8 +911,8 @@ function getTypeManifestVisitor(input) {
       const itemManifest = visit(node.item, self);
       const itemTypeStr = itemManifest.type.content;
       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")}` : "";
+      const prefixExpr = resolvedPrefix.format !== "u8" ? fragment`, prefix: ${getNumberCodecExpression(resolvedPrefix, "Encoder")}` : "";
+      const prefixDecoderExpr = resolvedPrefix.format !== "u8" ? fragment`, prefix: ${getNumberCodecExpression(resolvedPrefix, "Decoder")}` : "";
       const noneValueExpr = node.fixed ? ", noneValue: const ZeroesNoneValue()" : "";
       return {
         type: fragment`${itemManifest.type}?`,
@@ -911,11 +922,11 @@ function getTypeManifestVisitor(input) {
         )}<${fragmentFromString(itemTypeStr)}>(${use(
           "transformEncoder",
           "solanaCodecsCore"
-        )}(${itemManifest.encoder}, (${fragmentFromString(itemTypeStr)} value) => value)${fragmentFromString(prefixExpr)}${fragmentFromString(noneValueExpr)})`,
+        )}(${itemManifest.encoder}, (${fragmentFromString(itemTypeStr)} value) => value)${prefixExpr}${fragmentFromString(noneValueExpr)})`,
         decoder: fragment`${use(
           "getNullableDecoder",
           "solanaCodecsDataStructures"
-        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}${fragmentFromString(prefixDecoderExpr)}${fragmentFromString(noneValueExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}${prefixDecoderExpr}${fragmentFromString(noneValueExpr)})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -961,11 +972,11 @@ function getTypeManifestVisitor(input) {
         encoder: fragment`${use(
           "fixEncoderSize",
           "solanaCodecsCore"
-        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))}, allowTruncation: false)`,
+        )}(${innerManifest.encoder}, ${fragmentFromString(getNonNegativeInteger(node.size))}, allowTruncation: false)`,
         decoder: fragment`${use(
           "fixDecoderSize",
           "solanaCodecsCore"
-        )}(${innerManifest.decoder}, ${fragmentFromString(String(node.size))})`,
+        )}(${innerManifest.decoder}, ${fragmentFromString(getNonNegativeInteger(node.size))})`,
         value: innerManifest.value,
         isEnum: innerManifest.isEnum
       };
@@ -975,10 +986,10 @@ function getTypeManifestVisitor(input) {
       const bigIntFormats = /* @__PURE__ */ new Set(["u64", "u128", "i64", "i128"]);
       let prefixManifest;
       if (node.prefix.kind === "numberTypeNode" && bigIntFormats.has(node.prefix.format)) {
-        const codecName = getNumberCodecName(node.prefix.format);
+        const numberManifest = visit(node.prefix, self);
         prefixManifest = {
-          encoder: fragment`transformEncoder(${use(`get${codecName}Encoder`, "solanaCodecsNumbers")}(), (size) => BigInt.from(size))`,
-          decoder: fragment`transformDecoder(${use(`get${codecName}Decoder`, "solanaCodecsNumbers")}(), (size, _, __) => size.toInt())`
+          encoder: fragment`${use("transformEncoder", "solanaCodecsCore")}(${numberManifest.encoder}, (size) => BigInt.from(size))`,
+          decoder: fragment`${use("transformDecoder", "solanaCodecsCore")}(${numberManifest.decoder}, (size, _, __) => size.toInt())`
         };
       } else {
         prefixManifest = visit(node.prefix, self);
@@ -1069,10 +1080,10 @@ function getTypeManifestVisitor(input) {
       };
     },
     visitPreOffsetType(node, { self }) {
-      return visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
     visitPostOffsetType(node, { self }) {
-      return visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
     visitSolAmountType(node, { self }) {
       return visit(node.number, self);
@@ -1161,16 +1172,17 @@ function getNumberCodecName(format) {
       return "U8";
   }
 }
-function getNumberCodecExpression(format, codecType) {
-  const name = getNumberCodecName(format);
-  return `get${name}${codecType}()`;
+function getNumberCodecExpression(node, codecType) {
+  const name = getNumberCodecName(node.format);
+  const config = node.endian === "be" ? fragment`${use("NumberCodecConfig", "solanaCodecsNumbers")}(endian: ${use("Endian", "dartTypedData")}.big)` : "";
+  return fragment`${use(`get${name}${codecType}`, "solanaCodecsNumbers")}(${config})`;
 }
 function getArraySizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
     case "fixedCountNode":
-      return `, size: FixedArraySize(${count.value})`;
+      return `, size: FixedArraySize(${getNonNegativeInteger(count.value)})`;
     case "remainderCountNode":
       return ", size: RemainderArraySize()";
     case "prefixedCountNode": {
@@ -1178,7 +1190,7 @@ function getArraySizeExpression(node, codecType) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -1189,7 +1201,7 @@ function getMapSizeExpression(node, codecType) {
   const count = node.count;
   switch (count.kind) {
     case "fixedCountNode":
-      return `, size: FixedArraySize(${count.value})`;
+      return `, size: FixedArraySize(${getNonNegativeInteger(count.value)})`;
     case "remainderCountNode":
       return ", size: RemainderArraySize()";
     case "prefixedCountNode": {
@@ -1197,7 +1209,7 @@ function getMapSizeExpression(node, codecType) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -1208,7 +1220,7 @@ function getSetSizeExpression(node, codecType) {
   const count = node.count;
   switch (count.kind) {
     case "fixedCountNode":
-      return `, size: FixedArraySize(${count.value})`;
+      return `, size: FixedArraySize(${getNonNegativeInteger(count.value)})`;
     case "remainderCountNode":
       return ", size: RemainderArraySize()";
     case "prefixedCountNode": {
@@ -1216,7 +1228,7 @@ function getSetSizeExpression(node, codecType) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -1227,36 +1239,61 @@ function getHiddenAffixManifest(node, self) {
     const manifest = visit(node, self);
     return { encoder: manifest.encoder, decoder: manifest.decoder };
   }
-  const constantBytes = getConstantBytesExpression(node);
+  const constantBytes = getConstantBytesExpression(node, self);
   return {
     encoder: fragment`${use("getConstantEncoder", "solanaCodecsDataStructures")}(${constantBytes})`,
     decoder: fragment`${use("getConstantDecoder", "solanaCodecsDataStructures")}(${constantBytes})`
   };
 }
-function getConstantBytesExpression(node) {
-  const valueNode = node.value;
-  const typeNode = node.type;
-  if (valueNode?.kind !== "numberValueNode") {
+function getConstantBytesExpression(node, self) {
+  if (node.value.kind !== "numberValueNode") {
     throw new Error(
-      `Unsupported hidden affix constant value kind: ${valueNode?.kind}`
+      `Unsupported hidden affix constant value kind: ${node.value.kind}`
     );
   }
-  const value = Number(valueNode.number);
-  if (typeNode?.kind === "numberTypeNode") {
-    return fragment`${use(`get${getNumberCodecName(typeNode.format)}Encoder`, "solanaCodecsNumbers")}().encode(${value})`;
+  const manifest = visit(node.type, self);
+  if (!["int", "BigInt", "double"].includes(manifest.type.content)) {
+    throw new Error(`Unsupported hidden affix constant type kind: ${node.type.kind}`);
   }
-  if (typeNode?.kind === "preOffsetTypeNode") {
-    const inner = typeNode.type;
-    if (inner?.kind !== "numberTypeNode") {
-      throw new Error(
-        `Unsupported hidden affix pre-offset inner type kind: ${inner?.kind}`
-      );
-    }
-    return fragment`${use("padLeftEncoder", "solanaCodecsCore")}(${use(`get${getNumberCodecName(inner.format)}Encoder`, "solanaCodecsNumbers")}(), ${typeNode.offset}).encode(${value})`;
+  const value = getDartValueFragment(node.value, manifest.type.content);
+  return fragment`${manifest.encoder}.encode(${value})`;
+}
+function getOffsetManifest(node, self) {
+  if (!Number.isSafeInteger(node.offset)) {
+    throw new Error("Expected a safe integer for a codec offset");
   }
-  throw new Error(
-    `Unsupported hidden affix constant type kind: ${typeNode?.kind}`
-  );
+  const manifest = visit(node.type, self);
+  const pre = node.kind === "preOffsetTypeNode";
+  const key = pre ? "preOffset" : "postOffset";
+  if (node.strategy === "padded") {
+    const side = pre ? "Left" : "Right";
+    const offset = getNonNegativeInteger(node.offset);
+    return {
+      ...manifest,
+      encoder: fragment`${use(`pad${side}Encoder`, "solanaCodecsCore")}(${manifest.encoder}, ${offset})`,
+      decoder: fragment`${use(`pad${side}Decoder`, "solanaCodecsCore")}(${manifest.decoder}, ${offset})`
+    };
+  }
+  let expression;
+  switch (node.strategy) {
+    case "absolute":
+      expression = node.offset < 0 ? `scope.wrapBytes(${node.offset})` : String(node.offset);
+      break;
+    case "relative":
+      expression = `scope.${key} + ${node.offset}`;
+      break;
+    case "preOffset":
+      expression = `scope.preOffset + ${node.offset}`;
+      break;
+    default:
+      throw new Error(`Unsupported offset strategy: ${node.strategy}`);
+  }
+  const config = fragment`${use("OffsetConfig", "solanaCodecsCore")}(${key}: (scope) => ${expression})`;
+  return {
+    ...manifest,
+    encoder: fragment`${use("offsetEncoder", "solanaCodecsCore")}(${manifest.encoder}, ${config})`,
+    decoder: fragment`${use("offsetDecoder", "solanaCodecsCore")}(${manifest.decoder}, ${config})`
+  };
 }
 
 // src/fragments/discriminatorConstants.ts
@@ -1389,7 +1426,7 @@ ${ctorParams}
   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 int ${fragmentFromString(scope.nameApi.accountSizeConstant(name))} = ${fragmentFromString(getNonNegativeInteger(node.size))};` : emptyFragment();
   const discFragment = getDiscriminatorConstantsFragment(node, scope);
   const discriminatorValidation = getDiscriminatorValidationFragment(
     node,
@@ -1503,9 +1540,10 @@ function getErrorPageFragment(programNode, scope) {
       programName,
       err.name
     );
+    getNonNegativeInteger(err.code);
     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}"
+    const docs = err.docs?.length ? err.docs.map(toDartDocComment).join("\n") + "\n" : "";
+    const message = err.message ? `${toDartDocComment(`Message: "${err.message}"`)}
 ` : "";
     return `${docs}${message}const int ${constName} = ${hexCode}; // ${err.code}`;
   }).join("\n\n");
@@ -1515,7 +1553,7 @@ function getErrorPageFragment(programNode, scope) {
       err.name
     );
     const message = err.message ?? err.name;
-    return `    ${constName}: '${escapeString(message)}',`;
+    return `    ${constName}: ${toDartStringLiteral(message)},`;
   }).join("\n");
   const errorMessageFnName = scope.nameApi.errorMessageFunction(programName);
   const isErrorFnName = `is${pascalCase(programName)}Error`;
@@ -1541,8 +1579,8 @@ bool ${fragmentFromString(isErrorFnName)}(int code) {
   return _${fragmentFromString(camelCase(programName))}ErrorMessages.containsKey(code);
 }`;
 }
-function escapeString(str) {
-  return str.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+function toDartDocComment(value) {
+  return value.split(/\r\n?|\n/).map((line) => `/// ${line}`).join("\n");
 }
 
 // src/fragments/indexPage.ts
@@ -1668,14 +1706,28 @@ ${dataCtorInitializers}` : ""};`;
   const dataEncoderName = `get${typeName}InstructionDataEncoder`;
   const dataDecoderName = `get${typeName}InstructionDataDecoder`;
   const dataCodecName = `get${typeName}InstructionDataCodec`;
-  const argNames = new Set(args.map((a) => camelCase(a.name)));
-  const accountNames = new Set(accounts.map((a) => camelCase(a.name)));
-  const hasProgramAddressCollision = argNames.has("programAddress") || accountNames.has("programAddress");
-  const instrProgramParam = hasProgramAddressCollision ? "instructionProgramAddress" : "programAddress";
-  let instructionDataLocal = "instructionData";
-  while (argNames.has(instructionDataLocal) || accountNames.has(instructionDataLocal)) {
-    instructionDataLocal = `${instructionDataLocal}_`;
+  const usedNames = /* @__PURE__ */ new Set([
+    ...args.map((arg) => camelCase(arg.name)),
+    ...accounts.map((account) => camelCase(account.name))
+  ]);
+  const instrProgramParam = reserveName(
+    usedNames.has("programAddress") ? "instructionProgramAddress" : "programAddress",
+    usedNames
+  );
+  const instructionDataLocal = reserveName("instructionData", usedNames);
+  const signerParams = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    if (account.isSigner === "either") {
+      signerParams.set(
+        account,
+        reserveName(`${camelCase(account.name)}IsSigner`, usedNames)
+      );
+    }
   }
+  const signerParamDeclarations = [...signerParams.values()].map((parameter) => `  bool ${parameter} = true,`).join("\n");
+  const signerParamDocs = [...signerParams.entries()].map(
+    ([account, parameter]) => `/// Set [${parameter}] to false when [${camelCase(account.name)}] does not sign (for example, a multisig authority).`
+  ).join("\n");
   const accountParams = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
     const isRequired = !(acc.isOptional ?? false);
@@ -1695,7 +1747,7 @@ ${dataCtorInitializers}` : ""};`;
   }).join("\n");
   const accountMetas = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
-    const role = getAccountRole(acc);
+    const role = getAccountRole(acc, signerParams.get(acc));
     const isOptional = acc.isOptional ?? false;
     if (isOptional) {
       if (optionalAccountStrategy === "omitted") {
@@ -1778,11 +1830,13 @@ Codec<${fragmentFromString(dataClassName)}, ${fragmentFromString(dataClassName)}
   return combineCodec(${fragmentFromString(dataEncoderName)}(), ${fragmentFromString(dataDecoderName)}());
 }`);
   parts.push(fragment`
-/// Creates a [${fragmentFromString(typeName)}] instruction.
+/// Creates a [${fragmentFromString(typeName)}] instruction.${fragmentFromString(signerParamDocs ? `
+${signerParamDocs}` : "")}
 Instruction ${fragmentFromString(instrFnName)}({
   required Address ${fragmentFromString(instrProgramParam)},
 ${fragmentFromString(accountParams)}
-${fragmentFromString(argParams)}
+${fragmentFromString(argParams)}${fragmentFromString(signerParamDeclarations ? `
+${signerParamDeclarations}` : "")}
 }) {
   final ${instructionDataLocal} = ${fragmentFromString(dataClassName)}(
 ${fragmentFromString(dataConstruction)}
@@ -1812,13 +1866,20 @@ ${fragmentFromString(dataClassName)} ${fragmentFromString(parseFnName)}(Instruct
   }
   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 reserveName(preferredName, usedNames) {
+  let name = preferredName;
+  while (usedNames.has(name)) {
+    name = `${name}_`;
+  }
+  usedNames.add(name);
+  return name;
+}
+function getAccountRole(acc, signerParameter) {
+  const role = acc.isWritable ? "AccountRole.writable" : "AccountRole.readonly";
+  if (signerParameter) {
+    return `${signerParameter} ? ${role}Signer : ${role}`;
+  }
+  return acc.isSigner === true ? `${role}Signer` : role;
 }
 function isDiscriminatorArg(arg, node) {
   const discriminators = node.discriminators ?? [];
@@ -1871,9 +1932,9 @@ function getPdaPageFragment(node, scope) {
   for (const seed of seeds) {
     if (seed.kind === "constantPdaSeedNode") {
       if (seed.value.kind === "bytesValueNode") {
-        seedValues.push(`    Uint8List.fromList(${bytesValueToDart(seed.value.data)}),`);
+        seedValues.push(`    ${getDartValueFragment(seed.value).content},`);
       } else if (seed.value.kind === "stringValueNode") {
-        seedValues.push(`    '${seed.value.string}',`);
+        seedValues.push(`    ${toDartStringLiteral(seed.value.string)},`);
       } else if (seed.value.kind === "publicKeyValueNode") {
         const wellKnownSeedName = WELL_KNOWN_ADDRESSES.get(seed.value.publicKey);
         if (wellKnownSeedName) {
@@ -1883,13 +1944,14 @@ function getPdaPageFragment(node, scope) {
           );
         } else {
           seedValues.push(
-            `    getAddressEncoder().encode(Address('${seed.value.publicKey}')),`
+            `    getAddressEncoder().encode(Address(${toDartStringLiteral(seed.value.publicKey)})),`
           );
         }
       } else if (seed.value.kind === "numberValueNode") {
         const manifest = visit(seed.type, scope.typeManifestVisitor);
         seedManifests.push(manifest);
-        seedValues.push(`    ${manifest.encoder.content}.encode(${seed.value.number}),`);
+        const value = getDartValueFragment(seed.value, manifest.type.content);
+        seedValues.push(`    ${manifest.encoder.content}.encode(${value.content}),`);
       }
     } else if (seed.kind === "variablePdaSeedNode") {
       const manifest = visit(seed.type, scope.typeManifestVisitor);
@@ -1903,7 +1965,7 @@ function getPdaPageFragment(node, scope) {
   if (wellKnownProgramName) {
     use(wellKnownProgramName, "solanaAddresses");
   }
-  const programIdParam = node.programId ? wellKnownProgramName ? `Address programAddress = ${wellKnownProgramName}` : `Address programAddress = const Address('${node.programId}')` : "required Address programAddress";
+  const programIdParam = node.programId ? wellKnownProgramName ? `Address programAddress = ${wellKnownProgramName}` : `Address programAddress = const Address(${toDartStringLiteral(node.programId)})` : "required Address programAddress";
   const typedDataImport = hasByteSeeds ? use("Uint8List", "dartTypedData") : fragmentFromString("");
   const metaImport = hasSeedsClass ? use("immutable", "meta") : fragmentFromString("");
   const parts = [
@@ -1950,14 +2012,6 @@ ${fragmentFromString(seedValues.join("\n"))}
   }
   return result;
 }
-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(", ")}]`;
-}
 function getProgramPageFragment(node, scope) {
   const name = node.name;
   const addressConstName = scope.nameApi.programAddressConstant(name);
@@ -1978,7 +2032,7 @@ const ${fragmentFromString(addressConstName)} = ${fragmentFromString(wellKnownNa
 ${use("Address", "solanaAddresses")}
 
 /// The address of the ${fragmentFromString(pascalCase(name))} program.
-const ${fragmentFromString(addressConstName)} = Address('${fragmentFromString(node.publicKey)}');`;
+const ${fragmentFromString(addressConstName)} = Address(${fragmentFromString(toDartStringLiteral(node.publicKey))});`;
   const parts = [addressDeclaration];
   const accounts = node.accounts ?? [];
   if (accounts.length > 0) {
@@ -2119,7 +2173,7 @@ function getValueFragment(value, dartType) {
     case "booleanValueNode":
       return fragmentFromString(String(value.boolean));
     case "stringValueNode":
-      return fragmentFromString(`'${value.string.replaceAll("'", "\\'")}'`);
+      return fragmentFromString(toDartStringLiteral(value.string));
     case "bytesValueNode": {
       const clean = value.data.replace(/^0x/, "");
       const bytes = clean.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
@@ -2685,9 +2739,12 @@ function getRenderMapVisitor(options = {}) {
           visit(node.program, self),
           ...(node.additionalPrograms ?? []).map((p) => visit(p, self))
         ];
-        const mergedProgramMap = mergeRenderMaps(programMaps);
+        const mergedProgramMap = mergeRenderMapsWithoutCollisions(programMaps);
         const categoryMaps = getSharedCategoryIndexMaps(mergedProgramMap);
-        return mergeRenderMaps([mergedProgramMap, ...categoryMaps]);
+        return mergeRenderMapsWithoutCollisions([
+          mergedProgramMap,
+          ...categoryMaps
+        ]);
       },
       visitProgram(node, { self }) {
         const programName = node.name;
@@ -2749,7 +2806,7 @@ function getRenderMapVisitor(options = {}) {
           );
           maps.push(rootMap);
         }
-        return mergeRenderMaps(maps);
+        return mergeRenderMapsWithoutCollisions(maps);
       },
       visitAccount(node, { self }) {
         const fileName = `${snakeCase(node.name)}.dart`;
@@ -2784,6 +2841,18 @@ function getRenderMapVisitor(options = {}) {
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
+function mergeRenderMapsWithoutCollisions(maps) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const map of maps) {
+    for (const path of map.keys()) {
+      if (paths.has(path)) {
+        throw new Error(`Duplicate generated path "${path}"`);
+      }
+      paths.add(path);
+    }
+  }
+  return mergeRenderMaps(maps);
+}
 function getSharedCategoryIndexMaps(renderMap) {
   const categories = /* @__PURE__ */ new Map();
   const categoryIndexNames = {
@@ -2800,7 +2869,6 @@ function getSharedCategoryIndexMaps(renderMap) {
     );
     if (!match) continue;
     const [, category, fileName] = match;
-    if (fileName === categoryIndexNames[category]) continue;
     if (!categories.has(category)) {
       categories.set(category, /* @__PURE__ */ new Set());
     }
@@ -2830,9 +2898,6 @@ function renderVisitor(outputDir, options = {}) {
   } = options;
   return rootNodeVisitor((root) => {
     const normalizedRoot = normalizeRootNode(root);
-    if (deleteFolderBeforeRendering && existsSync(outputDir)) {
-      deleteDirectory(outputDir);
-    }
     const renderMap = visit(
       normalizedRoot,
       getRenderMapVisitor({ nameApi, dependencyMap })
@@ -2844,12 +2909,9 @@ function renderVisitor(outputDir, options = {}) {
         typePathMap[`definedType:${match[1]}`] = renderPath;
       }
     }
+    const files = [];
     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)) {
@@ -2864,6 +2926,13 @@ function renderVisitor(outputDir, options = {}) {
         internalMap[key] = rel;
       }
       const content = resolveFragmentContent(frag, dependencyMap ?? {}, internalMap);
+      files.push([fullPath, content]);
+    }
+    if (deleteFolderBeforeRendering && existsSync(outputDir)) {
+      deleteDirectory(outputDir);
+    }
+    for (const [fullPath, content] of files) {
+      mkdirSync(dirname(fullPath), { recursive: true });
       writeFileSync(fullPath, content, "utf-8");
     }
     if (formatCode) {