codama-renderers-dart 0.5.3 → 0.5.4

package/README.md

@@ -6,6 +6,8 @@ A [Codama](https://github.com/codama-idl/codama) renderer that generates Dart co
 
 Given a Codama IDL (Interface Description Language) describing a Solana program, this renderer produces a complete Dart package with typed account classes, instruction builders, codec functions, error definitions, PDA helpers, and barrel exports.
 
+Numeric prefix codecs retain the declared byte order, and pre/post offset types retain their cursor or padding strategy. Constant PDA integer seeds use the matching Dart integer type; malformed hexadecimal seeds and unsupported byte encodings are rejected.
+
 Fixed-size Codama types generate non-truncating encoders. Values within the declared byte capacity are zero-padded, while over-capacity values throw before any malformed bytes can be emitted. For UTF-8 strings, capacity is measured in encoded bytes rather than Dart code units.
 
 ## Installation
@@ -39,6 +41,8 @@ visit(root, renderVisitor("lib/src/generated", {
 
 `renderVisitor` accepts parsed Codama JSON as well as roots made with Codama constructors. Pina omits empty collections from its serialized IDLs; the renderer restores those structural defaults on an internal copy before traversal, leaving the parsed object unchanged.
 
+IDL names may contain letters, digits, underscores, hyphens, and spaces; names containing path separators, quotes, or other source syntax are rejected. Documentation and string values are escaped before they enter generated Dart. Rendering resolves all output before clearing the previous generated directory, so invalid IDLs do not delete an existing client. Formatter paths are passed as literal process arguments. Numeric defaults, counts, sizes, and error codes are validated before they are written as source. Duplicate generated paths are rejected, including names reserved for category barrel files, so nodes cannot silently replace one another.
+
 ```ts
 import { readFile } from "node:fs/promises";
 import { visit } from "@codama/visitors-core";
@@ -160,6 +164,8 @@ Account and instruction decoders validate every declared constant, field, and si
 
 Top-level instruction decoders require exact input consumption. Account decoders always reject truncated data, but accept unread trailing capacity unless the account declares a `sizeDiscriminatorNode`; size-discriminated accounts reject both truncation and suffix bytes.
 
+Accounts declared with `isSigner: "either"` expose an additional boolean such as `authorityIsSigner`, defaulting to `true`. Set it to `false` when the authority does not sign, including multisig authorities.
+
 Optional instruction accounts use Codama's `programId` strategy by default. When an optional account is absent, the builder emits a readonly program-address placeholder so every later account keeps its declared index. The account slot is removed only when the instruction explicitly selects the legacy `omitted` strategy.
 
 ### Scalar enums

package/dist/index.browser.cjs

@@ -12,7 +12,7 @@ var errors = require('@codama/errors');
 
 // src/visitors/renderVisitor.ts
 function formatDartDirectory(dir) {
-  child_process.execSync(`dart format "${dir}"`, {
+  child_process.execFileSync("dart", ["format", "--", dir], {
     encoding: "utf-8",
     timeout: 6e4,
     stdio: ["pipe", "pipe", "pipe"]
@@ -82,6 +82,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([
@@ -163,6 +164,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() {
@@ -188,6 +190,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) {
@@ -398,10 +405,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));
@@ -445,6 +461,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) {
@@ -645,23 +667,12 @@ function getTypeManifestVisitor(input) {
     }
   );
   return visitorsCore.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
       };
@@ -842,7 +853,7 @@ function getTypeManifestVisitor(input) {
       const fields = nodeFields.map((f) => visitorsCore.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"
@@ -850,7 +861,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"
@@ -904,8 +915,8 @@ function getTypeManifestVisitor(input) {
       const itemManifest = visitorsCore.visit(node.item, self);
       const itemTypeStr = itemManifest.type.content;
       const resolvedPrefix = nodes.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}?`,
@@ -915,11 +926,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
       };
@@ -965,11 +976,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
       };
@@ -979,10 +990,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 = visitorsCore.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 = visitorsCore.visit(node.prefix, self);
@@ -1073,10 +1084,10 @@ function getTypeManifestVisitor(input) {
       };
     },
     visitPreOffsetType(node, { self }) {
-      return visitorsCore.visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
     visitPostOffsetType(node, { self }) {
-      return visitorsCore.visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
     visitSolAmountType(node, { self }) {
       return visitorsCore.visit(node.number, self);
@@ -1165,16 +1176,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": {
@@ -1182,7 +1194,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 "";
@@ -1193,7 +1205,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": {
@@ -1201,7 +1213,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 "";
@@ -1212,7 +1224,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": {
@@ -1220,7 +1232,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 "";
@@ -1231,36 +1243,61 @@ function getHiddenAffixManifest(node, self) {
     const manifest = visitorsCore.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 = visitorsCore.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 = visitorsCore.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
@@ -1393,7 +1430,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,
@@ -1507,9 +1544,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");
@@ -1519,7 +1557,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`;
@@ -1545,8 +1583,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
@@ -1672,14 +1710,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);
@@ -1699,7 +1751,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") {
@@ -1782,11 +1834,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)}
@@ -1816,13 +1870,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 ?? [];
@@ -1875,9 +1936,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) {
@@ -1887,13 +1948,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 = visitorsCore.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 = visitorsCore.visit(seed.type, scope.typeManifestVisitor);
@@ -1907,7 +1969,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 = [
@@ -1954,14 +2016,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);
@@ -1982,7 +2036,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) {
@@ -2123,7 +2177,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)) ?? [];
@@ -2689,9 +2743,12 @@ function getRenderMapVisitor(options = {}) {
           visitorsCore.visit(node.program, self),
           ...(node.additionalPrograms ?? []).map((p) => visitorsCore.visit(p, self))
         ];
-        const mergedProgramMap = renderersCore.mergeRenderMaps(programMaps);
+        const mergedProgramMap = mergeRenderMapsWithoutCollisions(programMaps);
         const categoryMaps = getSharedCategoryIndexMaps(mergedProgramMap);
-        return renderersCore.mergeRenderMaps([mergedProgramMap, ...categoryMaps]);
+        return mergeRenderMapsWithoutCollisions([
+          mergedProgramMap,
+          ...categoryMaps
+        ]);
       },
       visitProgram(node, { self }) {
         const programName = node.name;
@@ -2753,7 +2810,7 @@ function getRenderMapVisitor(options = {}) {
           );
           maps.push(rootMap);
         }
-        return renderersCore.mergeRenderMaps(maps);
+        return mergeRenderMapsWithoutCollisions(maps);
       },
       visitAccount(node, { self }) {
         const fileName = `${snakeCase(node.name)}.dart`;
@@ -2788,6 +2845,18 @@ function getRenderMapVisitor(options = {}) {
     (v) => visitorsCore.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 renderersCore.mergeRenderMaps(maps);
+}
 function getSharedCategoryIndexMaps(renderMap) {
   const categories = /* @__PURE__ */ new Map();
   const categoryIndexNames = {
@@ -2804,7 +2873,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());
     }
@@ -2834,9 +2902,6 @@ function renderVisitor(outputDir, options = {}) {
   } = options;
   return visitorsCore.rootNodeVisitor((root) => {
     const normalizedRoot = normalizeRootNode(root);
-    if (deleteFolderBeforeRendering && fs.existsSync(outputDir)) {
-      renderersCore.deleteDirectory(outputDir);
-    }
     const renderMap = visitorsCore.visit(
       normalizedRoot,
       getRenderMapVisitor({ nameApi, dependencyMap })
@@ -2848,12 +2913,9 @@ function renderVisitor(outputDir, options = {}) {
         typePathMap[`definedType:${match[1]}`] = renderPath;
       }
     }
+    const files = [];
     for (const [filePath, frag] of renderMap.entries()) {
       const fullPath = path.join(outputDir, filePath);
-      const dir = path.dirname(fullPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
       const fileDir = path.dirname(filePath);
       const internalMap = {};
       for (const [key, typePath] of Object.entries(typePathMap)) {
@@ -2868,6 +2930,13 @@ function renderVisitor(outputDir, options = {}) {
         internalMap[key] = rel;
       }
       const content = resolveFragmentContent(frag, dependencyMap ?? {}, internalMap);
+      files.push([fullPath, content]);
+    }
+    if (deleteFolderBeforeRendering && fs.existsSync(outputDir)) {
+      renderersCore.deleteDirectory(outputDir);
+    }
+    for (const [fullPath, content] of files) {
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
       fs.writeFileSync(fullPath, content, "utf-8");
     }
     if (formatCode) {