codama-renderers-dart 0.5.1 → 0.5.4

package/src/utils/nameTransformers.ts

@@ -6,19 +6,50 @@ import type { CamelCaseString } from "@codama/nodes";
 
 /** Convert a string to PascalCase */
 export function pascalCase(str: string): string {
+  assertSafeName(str);
+
   return str
     .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
     .replace(/^(.)/, (c) => c.toUpperCase());
 }
 
+/**
+ * Dart reserved words (plus `async`/`await`/`yield` where they cannot be
+ * plain identifiers). A lowercase declaration named with one of these must
+ * be escaped, e.g. an account named `null` becomes a `null_` parameter.
+ */
+const DART_RESERVED_WORDS = new Set([
+  "abstract", "as", "assert", "async", "augment", "await", "base",
+  "break", "case", "catch", "class", "const", "continue", "covariant",
+  "default", "deferred", "do", "dynamic", "else", "enum", "export",
+  "extends", "extension", "external", "factory", "false", "final",
+  "finally", "for", "get", "hide", "if", "implements", "import", "in",
+  "interface", "is", "late", "library", "mixin", "native", "new", "null",
+  "of", "on", "operator", "part", "required", "rethrow", "return",
+  "sealed", "set", "show", "static", "super", "switch", "sync", "this",
+  "throw", "true", "try", "typedef", "var", "void", "when", "while",
+  "with", "yield",
+]);
+
+/**
+ * Escape a lowercase identifier if it collides with a Dart reserved word
+ * by appending `_` (e.g. an account named `null` renders as `null_`).
+ */
+export function escapeDartIdentifier(name: string): string {
+  return DART_RESERVED_WORDS.has(name) ? `${name}_` : name;
+}
+
 /** Convert a string to camelCase */
 export function camelCase(str: string): string {
   const pascal = pascalCase(str);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  const cased = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return escapeDartIdentifier(cased);
 }
 
 /** Convert a string to snake_case */
 export function snakeCase(str: string): string {
+  assertSafeName(str);
+
   return str
     .replace(/([A-Z])/g, "_$1")
     .replace(/[-\s]+/g, "_")
@@ -111,3 +142,10 @@ export function createDartNameApi(): DartNameApi {
 export function fromCamelCaseString(str: CamelCaseString): string {
   return str as string;
 }
+
+/** Reject IDL names that could escape generated identifiers, strings, or paths. */
+function assertSafeName(name: string): void {
+  if (!/^[a-zA-Z0-9_ -]*$/.test(name)) {
+    throw new Error(`Invalid Dart node name: ${JSON.stringify(name)}`);
+  }
+}

package/src/utils/valueNodes.ts

@@ -23,12 +23,25 @@ export function getDartValueFragment(
 ): Fragment {
   switch (value.kind) {
     case "numberValueNode":
+      // Serialized IDLs bypass TypeScript types; never interpolate unvalidated data.
+      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));
@@ -74,7 +87,8 @@ export function isConstDartValueNode(value: RenderableValueNode): boolean {
   }
 }
 
-function toDartStringLiteral(value: string): string {
+/** Escape IDL text so it remains data inside a Dart string literal. */
+export function toDartStringLiteral(value: string): string {
   return `'${value
     .replaceAll("\\", "\\\\")
     .replaceAll("\n", "\\n")
@@ -85,3 +99,12 @@ function toDartStringLiteral(value: string): string {
     .replaceAll("$", "\\$")
     .replaceAll("'", "\\'")}'`;
 }
+
+/** Reject executable or lossy sizes from serialized IDLs before generating Dart. */
+export function getNonNegativeInteger(value: number): string {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("Expected a non-negative safe integer value");
+  }
+
+  return String(value);
+}

package/src/visitors/getRenderMapVisitor.ts

@@ -89,10 +89,13 @@ export function getRenderMapVisitor(
             ...(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: ProgramNode, { self }) {
@@ -173,7 +176,7 @@ export function getRenderMapVisitor(
             maps.push(rootMap);
           }
 
-          return mergeRenderMaps(maps);
+          return mergeRenderMapsWithoutCollisions(maps);
         },
 
         visitAccount(node: AccountNode, { self }) {
@@ -213,6 +216,30 @@ export function getRenderMapVisitor(
   );
 }
 
+/**
+ * Merges generated files while rejecting ambiguous output paths.
+ *
+ * Silent overwrites could replace signer checks or data layouts when an
+ * untrusted IDL contains duplicate names.
+ */
+function mergeRenderMapsWithoutCollisions(
+  maps: RenderMap<Fragment>[],
+): RenderMap<Fragment> {
+  const paths = new Set<string>();
+
+  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: RenderMap<Fragment>,
 ): RenderMap<Fragment>[] {
@@ -233,8 +260,6 @@ function getSharedCategoryIndexMaps(
     if (!match) continue;
 
     const [, category, fileName] = match;
-    if (fileName === categoryIndexNames[category]) continue;
-
     if (!categories.has(category)) {
       categories.set(category, new Set());
     }

package/src/visitors/getTypeManifestVisitor.ts

@@ -5,6 +5,7 @@ import {
   type BooleanTypeNode,
   type BytesTypeNode,
   type CamelCaseString,
+  type ConstantValueNode,
   type DateTimeTypeNode,
   type DefinedTypeLinkNode,
   type DefinedTypeNode,
@@ -31,6 +32,7 @@ import {
   type StructFieldTypeNode,
   type StructTypeNode,
   type TupleTypeNode,
+  type TypeNode,
   type ZeroableOptionTypeNode,
   isNode,
   resolveNestedTypeNode,
@@ -55,6 +57,7 @@ import {
   use,
 } from "../utils/index.js";
 import { type DartNameApi, snakeCase } from "../utils/nameTransformers.js";
+import { getDartValueFragment, getNonNegativeInteger, toDartStringLiteral } from "../utils/valueNodes.js";
 
 /**
  * Type alias for the type manifest visitor.
@@ -121,32 +124,12 @@ export function getTypeManifestVisitor(input: {
   );
 
   return extendVisitor(baseVisitor, {
-    visitNumberType(node: NumberTypeNode, { self }) {
-      const { format, endian } = node;
-      const endianSuffix =
-        endian === "be"
-          ? ", NumberCodecConfig(endian: Endian.big)"
-          : "";
-      const endianDecoderSuffix =
-        endian === "be"
-          ? ", NumberCodecConfig(endian: Endian.big)"
-          : "";
-
-      // Map format to Dart type and codec
-      const dartType = getNumberDartType(format);
-      const codecName = getNumberCodecName(format);
-
+    visitNumberType(node: NumberTypeNode) {
       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,
       };
@@ -239,7 +222,7 @@ export function getTypeManifestVisitor(input: {
         encoder: fragment`${use(
           "getArrayEncoder",
           "solanaCodecsDataStructures",
-        )}<${itemType}>(${itemEncoder}${encoderSizeExpr})`,
+        )}(${itemEncoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures",
@@ -305,19 +288,33 @@ export function getTypeManifestVisitor(input: {
       }
 
       const encoderListStr = encoderList.map((e) => e.content).join(", ");
+      const decoderListStr = decoderList.map((d) => d.content).join(", ");
+      // Two-element tuples render through the typed getTuple2 helpers so the
+      // generated value type is the Dart record `(T1, T2)` rather than a
+      // heterogeneous List<Object?>. Arity-2 is the only shape that currently
+      // appears in supported IDLs; wider tuples stay on the untyped helpers.
+      let tupleEncoderFn = "getTupleEncoder";
+      let tupleDecoderFn = "getTupleDecoder";
+      let tupleEncoderArgs = `[${encoderListStr}]`;
+      let tupleDecoderArgs = `[${decoderListStr}]`;
+      if (itemManifests.length === 2) {
+        tupleEncoderFn = "getTuple2Encoder";
+        tupleDecoderFn = "getTuple2Decoder";
+        tupleEncoderArgs = encoderListStr;
+        tupleDecoderArgs = decoderListStr;
+      }
       const encoderFrag = fragment`${use(
-        "getTupleEncoder",
+        tupleEncoderFn,
         "solanaCodecsDataStructures",
-      )}([${fragmentFromString(encoderListStr)}])`;
+      )}(${tupleEncoderArgs})`;
       for (const e of encoderList) {
         encoderFrag.imports.mergeWith(e.imports);
       }
 
-      const decoderListStr = decoderList.map((d) => d.content).join(", ");
       const decoderFrag = fragment`${use(
-        "getTupleDecoder",
+        tupleDecoderFn,
         "solanaCodecsDataStructures",
-      )}([${fragmentFromString(decoderListStr)}])`;
+      )}(${tupleDecoderArgs})`;
       for (const d of decoderList) {
         decoderFrag.imports.mergeWith(d.imports);
       }
@@ -341,7 +338,7 @@ export function getTypeManifestVisitor(input: {
 
       // Build encoder fields list
       const encoderFields = fields
-        .map((f, i) => `('${fieldNames[i]}', ${f.encoder.content})`)
+        .map((f, i) => `(${toDartStringLiteral(fieldNames[i])}, ${f.encoder.content})`)
         .join(", ");
       const encoderFrag = fragment`${use(
         "getStructEncoder",
@@ -352,7 +349,7 @@ export function getTypeManifestVisitor(input: {
       }
 
       const decoderFields = fields
-        .map((f, i) => `('${fieldNames[i]}', ${f.decoder.content})`)
+        .map((f, i) => `(${toDartStringLiteral(fieldNames[i])}, ${f.decoder.content})`)
         .join(", ");
       const decoderFrag = fragment`${use(
         "getStructDecoder",
@@ -428,10 +425,10 @@ export function getTypeManifestVisitor(input: {
       const itemTypeStr = itemManifest.type.content;
       const resolvedPrefix = resolveNestedTypeNode(node.prefix);
       const prefixExpr = resolvedPrefix.format !== "u8"
-        ? `, prefix: ${getNumberCodecExpression(resolvedPrefix.format, "Encoder")}`
+        ? fragment`, prefix: ${getNumberCodecExpression(resolvedPrefix, "Encoder")}`
         : "";
       const prefixDecoderExpr = resolvedPrefix.format !== "u8"
-        ? `, prefix: ${getNumberCodecExpression(resolvedPrefix.format, "Decoder")}`
+        ? fragment`, prefix: ${getNumberCodecExpression(resolvedPrefix, "Decoder")}`
         : "";
       const noneValueExpr = node.fixed
         ? ", noneValue: const ZeroesNoneValue()"
@@ -442,11 +439,14 @@ export function getTypeManifestVisitor(input: {
         encoder: fragment`${use(
           "getNullableEncoder",
           "solanaCodecsDataStructures",
-        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.encoder}${fragmentFromString(prefixExpr)}${fragmentFromString(noneValueExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${use(
+          "transformEncoder",
+          "solanaCodecsCore",
+        )}(${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,
       };
@@ -504,11 +504,11 @@ export 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,
       };
@@ -527,12 +527,12 @@ export function getTypeManifestVisitor(input: {
       let prefixManifest;
       if (
         node.prefix.kind === "numberTypeNode" &&
-        bigIntFormats.has((node.prefix as any).format)
+        bigIntFormats.has(node.prefix.format)
       ) {
-        const codecName = getNumberCodecName((node.prefix as any).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);
@@ -643,13 +643,11 @@ export function getTypeManifestVisitor(input: {
     },
 
     visitPreOffsetType(node: PreOffsetTypeNode, { self }) {
-      // Pre-offset types pass through to inner type in Dart
-      return visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
 
     visitPostOffsetType(node: PostOffsetTypeNode, { self }) {
-      // Post-offset types pass through to inner type in Dart
-      return visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
 
     visitSolAmountType(node: SolAmountTypeNode, { self }) {
@@ -760,22 +758,26 @@ function getNumberCodecName(format: string): string {
 }
 
 function getNumberCodecExpression(
-  format: string,
+  node: NumberTypeNode,
   codecType: "Encoder" | "Decoder",
-): string {
-  const name = getNumberCodecName(format);
-  return `get${name}${codecType}()`;
+): Fragment {
+  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: ArrayTypeNode,
   codecType: "Encoder" | "Decoder",
-): string {
+): string | Fragment {
   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": {
@@ -783,7 +785,7 @@ function getArraySizeExpression(
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return ""; // Default
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -793,12 +795,12 @@ function getArraySizeExpression(
 function getMapSizeExpression(
   node: MapTypeNode,
   codecType: "Encoder" | "Decoder",
-): string {
+): string | Fragment {
   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": {
@@ -806,7 +808,7 @@ function getMapSizeExpression(
       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 "";
@@ -816,12 +818,12 @@ function getMapSizeExpression(
 function getSetSizeExpression(
   node: SetTypeNode,
   codecType: "Encoder" | "Decoder",
-): string {
+): string | Fragment {
   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": {
@@ -829,7 +831,7 @@ function getSetSizeExpression(
       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 "";
@@ -842,7 +844,7 @@ type HiddenAffixManifest = {
 };
 
 function getHiddenAffixManifest(
-  node: any,
+  node: ConstantValueNode | TypeNode,
   self: Visitor<TypeManifest>,
 ): HiddenAffixManifest {
   if (node?.kind !== "constantValueNode") {
@@ -850,40 +852,80 @@ function getHiddenAffixManifest(
     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: any): Fragment {
-  const valueNode = node.value;
-  const typeNode = node.type;
-
-  if (valueNode?.kind !== "numberValueNode") {
+/** Serialize affix constants using the same validated codec as ordinary fields. */
+function getConstantBytesExpression(
+  node: ConstantValueNode,
+  self: Visitor<TypeManifest>,
+): Fragment {
+  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);
+  const manifest = visit(node.type, self);
 
-  if (typeNode?.kind === "numberTypeNode") {
-    return fragment`${use(`get${getNumberCodecName(typeNode.format)}Encoder`, "solanaCodecsNumbers")}().encode(${value})`;
+  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})`;
+}
+
+/** Preserve the IDL's cursor strategy instead of silently discarding offsets. */
+function getOffsetManifest(
+  node: PreOffsetTypeNode | PostOffsetTypeNode,
+  self: Visitor<TypeManifest>,
+): TypeManifest {
+  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: string;
+
+  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})`,
+  };
 }

package/src/visitors/renderVisitor.ts

@@ -32,11 +32,6 @@ export function renderVisitor(
   return rootNodeVisitor((root: RootNode) => {
     const normalizedRoot = normalizeRootNode(root);
 
-    // 1. Optionally delete the output directory
-    if (deleteFolderBeforeRendering && existsSync(outputDir)) {
-      deleteDirectory(outputDir);
-    }
-
     // 2. Build the render map
     const renderMap = visit(
       normalizedRoot,
@@ -52,16 +47,10 @@ export function renderVisitor(
       }
     }
 
-    // 4. Resolve imports and write files
+    // Resolve every file before deleting previous output, so invalid IDLs fail safely.
+    const files: [string, string][] = [];
     for (const [filePath, frag] of renderMap.entries()) {
       const fullPath = join(outputDir, filePath);
-      const dir = dirname(fullPath);
-
-      // Ensure directory exists
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-
       // Compute per-file internal import map (relative paths to defined types)
       const fileDir = dirname(filePath);
       const internalMap: Record<string, string> = {};
@@ -81,6 +70,15 @@ export function renderVisitor(
 
       // Resolve fragment content with imports
       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");
     }