@codama/spec 1.6.0-rc.2 → 1.6.0-rc.4

package/dist/index.browser.mjs

@@ -4,7 +4,7 @@ function attribute(name, type, options = {}) {
     name,
     type,
     ...options.optional ? { optional: true } : {},
-    ...options.docs !== void 0 ? { docs: options.docs } : {}
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {}
   });
 }
 function optionalAttribute(name, type, options = {}) {
@@ -16,11 +16,23 @@ function array(inner) {
   return Object.freeze({ kind: "array", of: inner });
 }
 
+// src/api/defineCategory.ts
+function defineCategory(name, options = {}) {
+  return Object.freeze({
+    name,
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {},
+    nodes: Object.freeze([...options.nodes ?? []]),
+    unions: Object.freeze([...options.unions ?? []]),
+    enumerations: Object.freeze([...options.enumerations ?? []]),
+    nestedUnions: Object.freeze([...options.nestedUnions ?? []])
+  });
+}
+
 // src/api/defineEnumeration.ts
 function variant(name, options = {}) {
   return Object.freeze({
     name,
-    ...options.docs !== void 0 ? { docs: options.docs } : {}
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {}
   });
 }
 function defineEnumeration(name, options) {
@@ -37,7 +49,17 @@ function defineEnumeration(name, options) {
   return Object.freeze({
     name,
     variants: Object.freeze([...options.variants]),
-    ...options.docs !== void 0 ? { docs: options.docs } : {}
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {}
+  });
+}
+
+// src/api/defineNestedUnion.ts
+function defineNestedUnion(name, options) {
+  return Object.freeze({
+    name,
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {},
+    base: options.base,
+    wrappers: Object.freeze([...options.wrappers])
   });
 }
 
@@ -45,7 +67,7 @@ function defineEnumeration(name, options) {
 function defineNode(kind, options) {
   return Object.freeze({
     kind,
-    ...options.docs !== void 0 ? { docs: options.docs } : {},
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {},
     attributes: Object.freeze([...options.attributes]),
     examples: Object.freeze([...options.examples ?? []])
   });
@@ -57,7 +79,7 @@ function defineUnion(name, options) {
   return Object.freeze({
     name,
     members: Object.freeze(normalised),
-    ...options.docs !== void 0 ? { docs: options.docs } : {}
+    ...options.docs !== void 0 ? { docs: Object.freeze([...options.docs]) } : {}
   });
 }
 function normaliseMember(input) {
@@ -118,8 +140,8 @@ function node(name) {
 function union(name) {
   return Object.freeze({ kind: "union", name });
 }
-function nestedTypeNode(name) {
-  return Object.freeze({ kind: "nestedTypeNode", name });
+function nestedUnion(alias, name) {
+  return Object.freeze({ kind: "nestedUnion", alias, name });
 }
 
 // src/api/semanticAliases.ts
@@ -127,29 +149,47 @@ function byteSize() {
   return u64();
 }
 function docs() {
-  return array(string());
+  return Object.freeze({ kind: "docs" });
 }
 
 // src/api/validate.ts
 function validate(spec) {
   const errors = [];
-  const nodeKinds = new Set(spec.nodes.map((n) => n.kind));
-  const unionNames = new Set(spec.unions.map((u) => u.name));
-  const enumerationNames = new Set(spec.enumerations.map((e) => e.name));
-  const wrappers = new Set(spec.nestedTypeNodeWrappers);
+  const allNodes = [];
+  const allUnions = [];
+  const allEnumerations = [];
+  const allNestedUnions = [];
+  for (const c of spec.categories) {
+    allNodes.push(...c.nodes);
+    allUnions.push(...c.unions);
+    allEnumerations.push(...c.enumerations);
+    allNestedUnions.push(...c.nestedUnions);
+  }
+  const nodeKinds = new Set(allNodes.map((n) => n.kind));
+  const unionNames = new Set(allUnions.map((u) => u.name));
+  const enumerationNames = new Set(allEnumerations.map((e) => e.name));
+  const nestedUnionNames = new Set(allNestedUnions.map((nu) => nu.name));
   const registrations = /* @__PURE__ */ new Map();
   const record = (name, kind) => {
     const list = registrations.get(name);
     if (list) list.push(kind);
     else registrations.set(name, [kind]);
   };
-  for (const n of spec.nodes) record(n.kind, "node");
-  for (const u of spec.unions) record(u.name, "union");
-  for (const e of spec.enumerations) record(e.name, "enumeration");
+  for (const n of allNodes) record(n.kind, "node");
+  for (const u of allUnions) record(u.name, "union");
+  for (const e of allEnumerations) record(e.name, "enumeration");
+  for (const nu of allNestedUnions) record(nu.name, "nestedUnion");
   for (const [name, kinds] of registrations) {
     if (kinds.length > 1) errors.push(formatCollisionError(name, kinds));
   }
-  for (const n of spec.nodes) {
+  const seenCategories = /* @__PURE__ */ new Set();
+  for (const c of spec.categories) {
+    if (seenCategories.has(c.name)) {
+      errors.push(`Category "${c.name}" is declared more than once.`);
+    }
+    seenCategories.add(c.name);
+  }
+  for (const n of allNodes) {
     if (!/^[a-z][A-Za-z0-9]*Node$/.test(n.kind)) {
       errors.push(`Node kind "${n.kind}" does not match the camelCase ...Node naming convention.`);
     }
@@ -161,11 +201,11 @@ function validate(spec) {
       seenAttrs.add(a.name);
       walkTypeExpr(
         a.type,
-        (expr) => checkRef(expr, n.kind, a.name, errors, nodeKinds, unionNames, enumerationNames)
+        (expr) => checkRef(expr, n.kind, a.name, errors, nodeKinds, unionNames, enumerationNames, nestedUnionNames)
       );
     }
   }
-  for (const u of spec.unions) {
+  for (const u of allUnions) {
     if (u.members.length === 0) {
       errors.push(`Union "${u.name}" has no members.`);
     }
@@ -184,9 +224,14 @@ function validate(spec) {
       }
     }
   }
-  for (const wrapper of wrappers) {
-    if (!nodeKinds.has(wrapper)) {
-      errors.push(`Nested-type-node wrapper "${wrapper}" is not a defined node.`);
+  for (const nu of allNestedUnions) {
+    if (nu.wrappers.length === 0) {
+      errors.push(`Nested union "${nu.name}" has no wrappers.`);
+    }
+    for (const w of nu.wrappers) {
+      if (!nodeKinds.has(w)) {
+        errors.push(`Nested union "${nu.name}" wrapper "${w}" is not a defined node.`);
+      }
     }
   }
   return errors;
@@ -195,7 +240,7 @@ function formatCollisionError(name, kinds) {
   const counts = /* @__PURE__ */ new Map();
   for (const k of kinds) counts.set(k, (counts.get(k) ?? 0) + 1);
   const breakdown = [...counts.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([k, n]) => `${n} ${k}${n > 1 ? "s" : ""}`).join(", ");
-  return `Name "${name}" is registered ${kinds.length} times (${breakdown}); names must be unique across nodes, unions, and enumerations.`;
+  return `Name "${name}" is registered ${kinds.length} times (${breakdown}); names must be unique across nodes, unions, enumerations, and nested unions.`;
 }
 function walkTypeExpr(expr, visit) {
   visit(expr);
@@ -205,7 +250,7 @@ function walkTypeExpr(expr, visit) {
     for (const item of expr.items) walkTypeExpr(item, visit);
   }
 }
-function checkRef(expr, nodeKind, attrName, errors, nodeKinds, unionNames, enumerationNames) {
+function checkRef(expr, nodeKind, attrName, errors, nodeKinds, unionNames, enumerationNames, nestedUnionNames) {
   const where = `Node "${nodeKind}", attribute "${attrName}":`;
   switch (expr.kind) {
     case "node":
@@ -223,9 +268,12 @@ function checkRef(expr, nodeKind, attrName, errors, nodeKinds, unionNames, enume
         errors.push(`${where} references undefined enumeration "${expr.name}".`);
       }
       break;
-    case "nestedTypeNode":
+    case "nestedUnion":
       if (!nodeKinds.has(expr.name)) {
-        errors.push(`${where} nestedTypeNode references undefined node "${expr.name}".`);
+        errors.push(`${where} nestedUnion references undefined node "${expr.name}".`);
+      }
+      if (!nestedUnionNames.has(expr.alias)) {
+        errors.push(`${where} nestedUnion references undefined alias "${expr.alias}".`);
       }
       break;
   }
@@ -233,7 +281,7 @@ function checkRef(expr, nodeKind, attrName, errors, nodeKinds, unionNames, enume
 function isChildAttribute(type) {
   switch (type.kind) {
     case "node":
-    case "nestedTypeNode":
+    case "nestedUnion":
     case "union":
       return true;
     case "array":
@@ -247,114 +295,116 @@ function isChildAttribute(type) {
 
 // src/v1/enumerations.ts
 var endianness = defineEnumeration("Endianness", {
-  docs: "The byte order of a numeric serialization.",
+  docs: ["The byte order of a numeric serialization."],
   variants: [
-    variant("be", { docs: "Big-endian: the most significant byte is written first." }),
-    variant("le", { docs: "Little-endian: the least significant byte is written first." })
+    variant("be", { docs: ["Big-endian: the most significant byte is written first."] }),
+    variant("le", { docs: ["Little-endian: the least significant byte is written first."] })
   ]
 });
 var numberFormat = defineEnumeration("NumberFormat", {
-  docs: "The wire format of a numeric serialization.",
+  docs: ["The wire format of a numeric serialization."],
   variants: [
-    variant("f32", { docs: "IEEE-754 32-bit floating point." }),
-    variant("f64", { docs: "IEEE-754 64-bit floating point." }),
-    variant("i8", { docs: "Signed 8-bit integer." }),
-    variant("i16", { docs: "Signed 16-bit integer." }),
-    variant("i32", { docs: "Signed 32-bit integer." }),
-    variant("i64", { docs: "Signed 64-bit integer." }),
-    variant("i128", { docs: "Signed 128-bit integer." }),
+    variant("f32", { docs: ["IEEE-754 32-bit floating point."] }),
+    variant("f64", { docs: ["IEEE-754 64-bit floating point."] }),
+    variant("i8", { docs: ["Signed 8-bit integer."] }),
+    variant("i16", { docs: ["Signed 16-bit integer."] }),
+    variant("i32", { docs: ["Signed 32-bit integer."] }),
+    variant("i64", { docs: ["Signed 64-bit integer."] }),
+    variant("i128", { docs: ["Signed 128-bit integer."] }),
     variant("shortU16", {
-      docs: "Solana compact-u16 encoding: a variable-length unsigned integer occupying 1 to 3 bytes."
+      docs: ["Solana compact-u16 encoding: a variable-length unsigned integer occupying 1 to 3 bytes."]
     }),
-    variant("u8", { docs: "Unsigned 8-bit integer." }),
-    variant("u16", { docs: "Unsigned 16-bit integer." }),
-    variant("u32", { docs: "Unsigned 32-bit integer." }),
-    variant("u64", { docs: "Unsigned 64-bit integer." }),
-    variant("u128", { docs: "Unsigned 128-bit integer." })
+    variant("u8", { docs: ["Unsigned 8-bit integer."] }),
+    variant("u16", { docs: ["Unsigned 16-bit integer."] }),
+    variant("u32", { docs: ["Unsigned 32-bit integer."] }),
+    variant("u64", { docs: ["Unsigned 64-bit integer."] }),
+    variant("u128", { docs: ["Unsigned 128-bit integer."] })
   ]
 });
 var bytesEncoding = defineEnumeration("BytesEncoding", {
-  docs: "How a string of bytes is encoded for transport.",
+  docs: ["How a string of bytes is encoded for transport."],
   variants: [
-    variant("base16", { docs: "Hexadecimal encoding (two characters per byte)." }),
-    variant("base58", { docs: "Base58 encoding, the standard for Solana addresses." }),
-    variant("base64", { docs: "Base64 encoding (RFC 4648)." }),
-    variant("utf8", { docs: "UTF-8 text encoding." })
+    variant("base16", { docs: ["Hexadecimal encoding (two characters per byte)."] }),
+    variant("base58", { docs: ["Base58 encoding, the standard for Solana addresses."] }),
+    variant("base64", { docs: ["Base64 encoding (RFC 4648)."] }),
+    variant("utf8", { docs: ["UTF-8 text encoding."] })
   ]
 });
 var instructionLifecycle = defineEnumeration("InstructionLifecycle", {
-  docs: "The lifecycle stage of an instruction.",
+  docs: ["The lifecycle stage of an instruction."],
   variants: [
     variant("archived", {
-      docs: "No longer included in client SDKs. Retained in the IDL for historical reference only."
+      docs: ["No longer included in client SDKs. Retained in the IDL for historical reference only."]
     }),
     variant("deprecated", {
-      docs: "Still callable but discouraged. Clients should migrate to a replacement instruction."
+      docs: ["Still callable but discouraged. Clients should migrate to a replacement instruction."]
     }),
     variant("draft", {
-      docs: "Work-in-progress. The instruction may change before it stabilises."
+      docs: ["Work-in-progress. The instruction may change before it stabilises."]
     }),
-    variant("live", { docs: "Stable and supported for production use." })
+    variant("live", { docs: ["Stable and supported for production use."] })
   ]
 });
 var defaultValueStrategy = defineEnumeration("DefaultValueStrategy", {
-  docs: "How an attribute that carries a default value is exposed in generated APIs.",
+  docs: ["How an attribute that carries a default value is exposed in generated APIs."],
   variants: [
     variant("omitted", {
-      docs: "The attribute is not exposed as a parameter in the generated API; the default value is always used."
+      docs: [
+        "The attribute is not exposed as a parameter in the generated API; the default value is always used."
+      ]
     }),
     variant("optional", {
-      docs: "The attribute is exposed as an optional parameter; callers may override the default value."
+      docs: ["The attribute is exposed as an optional parameter; callers may override the default value."]
     })
   ]
 });
 var optionalAccountStrategy = defineEnumeration("OptionalAccountStrategy", {
-  docs: "How an absent optional account is represented when serialising an instruction.",
+  docs: ["How an absent optional account is represented when serialising an instruction."],
   variants: [
     variant("omitted", {
-      docs: "The account slot is left out of the instruction entirely. Subsequent accounts shift up."
+      docs: ["The account slot is left out of the instruction entirely. Subsequent accounts shift up."]
     }),
     variant("programId", {
-      docs: "The account slot is filled with the program ID as a placeholder, preserving positional indices."
+      docs: ["The account slot is filled with the program ID as a placeholder, preserving positional indices."]
     })
   ]
 });
 var preOffsetStrategy = defineEnumeration("PreOffsetStrategy", {
-  docs: "How a pre-offset modifier interprets its offset value before serialising the wrapped type.",
+  docs: ["How a pre-offset modifier interprets its offset value before serialising the wrapped type."],
   variants: [
     variant("absolute", {
-      docs: "Move the cursor to the absolute byte position given by the offset."
+      docs: ["Move the cursor to the absolute byte position given by the offset."]
     }),
     variant("padded", {
-      docs: "Pad with zero bytes from the current cursor up to the offset bytes ahead."
+      docs: ["Pad with zero bytes from the current cursor up to the offset bytes ahead."]
     }),
     variant("relative", {
-      docs: "Advance the cursor by the offset bytes relative to its current position."
+      docs: ["Advance the cursor by the offset bytes relative to its current position."]
     })
   ]
 });
 var postOffsetStrategy = defineEnumeration("PostOffsetStrategy", {
-  docs: "How a post-offset modifier interprets its offset value after serialising the wrapped type.",
+  docs: ["How a post-offset modifier interprets its offset value after serialising the wrapped type."],
   variants: [
     variant("absolute", {
-      docs: "Move the cursor to the absolute byte position given by the offset."
+      docs: ["Move the cursor to the absolute byte position given by the offset."]
     }),
     variant("padded", {
-      docs: "Pad with zero bytes from the current cursor up to the offset bytes ahead."
+      docs: ["Pad with zero bytes from the current cursor up to the offset bytes ahead."]
     }),
     variant("preOffset", {
-      docs: "Restore the cursor to where it was before the wrapped type ran (cancelling its pre-offset)."
+      docs: ["Restore the cursor to where it was before the wrapped type ran (cancelling its pre-offset)."]
     }),
     variant("relative", {
-      docs: "Advance the cursor by the offset bytes relative to its current position."
+      docs: ["Advance the cursor by the offset bytes relative to its current position."]
     })
   ]
 });
 var programOrigin = defineEnumeration("ProgramOrigin", {
-  docs: "The toolchain that originally generated a program description.",
+  docs: ["The toolchain that originally generated a program description."],
   variants: [
-    variant("anchor", { docs: "The program was originally described by an Anchor IDL." }),
-    variant("shank", { docs: "The program was originally described by a Shank IDL." })
+    variant("anchor", { docs: ["The program was originally described by an Anchor IDL."] }),
+    variant("shank", { docs: ["The program was originally described by a Shank IDL."] })
   ]
 });
 var ALL_ENUMERATIONS = [
@@ -369,106 +419,124 @@ var ALL_ENUMERATIONS = [
   programOrigin
 ];
 
-// src/v1/nestedTypeNodeWrappers.ts
-var NESTED_TYPE_NODE_WRAPPERS = [
-  "fixedSizeTypeNode",
-  "sizePrefixTypeNode",
-  "preOffsetTypeNode",
-  "postOffsetTypeNode",
-  "sentinelTypeNode",
-  "hiddenPrefixTypeNode",
-  "hiddenSuffixTypeNode"
-];
+// src/v1/nestedUnions.ts
+var nestedTypeNode = defineNestedUnion("NestedTypeNode", {
+  docs: [
+    "A type, possibly wrapped in zero-or-more size, offset, sentinel, or hidden prefix/suffix modifiers.",
+    "The wrapping is recursive: each modifier wraps another `NestedTypeNode<T>` until the inner `T` is reached."
+  ],
+  base: union("TypeNode"),
+  wrappers: [
+    "fixedSizeTypeNode",
+    "sizePrefixTypeNode",
+    "preOffsetTypeNode",
+    "postOffsetTypeNode",
+    "sentinelTypeNode",
+    "hiddenPrefixTypeNode",
+    "hiddenSuffixTypeNode"
+  ]
+});
 
 // src/v1/nodes/AccountNode.ts
 var accountNode = defineNode("accountNode", {
-  docs: "An on-chain account: its name, data structure, optional fixed size, optional PDA, and optional discriminators.",
+  docs: [
+    "An on-chain account: its name, data structure, optional fixed size, optional PDA, and optional discriminators."
+  ],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the account."
+      docs: ["The name of the account."]
     }),
     optionalAttribute("size", byteSize(), {
-      docs: "The size of the account in bytes, when the data length is fixed."
+      docs: ["The size of the account in bytes, when the data length is fixed."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the account."
+      docs: ["Markdown documentation for the account."]
     }),
-    attribute("data", nestedTypeNode("structTypeNode"), {
-      docs: "The struct describing the account data."
+    attribute("data", nestedUnion("NestedTypeNode", "structTypeNode"), {
+      docs: ["The struct describing the account data."]
     }),
     optionalAttribute("pda", node("pdaLinkNode"), {
-      docs: "A link to the PDA the account is derived from, if applicable."
+      docs: ["A link to the PDA the account is derived from, if applicable."]
     }),
     optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
-      docs: "Discriminators that distinguish this account from others in the program. When multiple are listed, they are combined with a logical AND."
+      docs: [
+        "Discriminators that distinguish this account from others in the program.",
+        "When multiple are listed, they are combined with a logical AND."
+      ]
     })
   ]
 });
 
 // src/v1/nodes/ConstantNode.ts
 var constantNode = defineNode("constantNode", {
-  docs: "A named constant exposed by the program: a typed value associated with a name.",
+  docs: ["A named constant exposed by the program: a typed value associated with a name."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the constant."
+      docs: ["The name of the constant."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the constant."
+      docs: ["Markdown documentation for the constant."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The type of the constant."
+      docs: ["The type of the constant."]
     }),
     attribute("value", union("ValueNode"), {
-      docs: "The concrete value of the constant."
+      docs: ["The concrete value of the constant."]
     })
   ]
 });
 
 // src/v1/nodes/contextualValueNodes/AccountBumpValueNode.ts
 var accountBumpValueNode = defineNode("accountBumpValueNode", {
-  docs: "Refers to the bump seed of a named PDA-derived account in the surrounding instruction.",
+  docs: ["Refers to the bump seed of a named PDA-derived account in the surrounding instruction."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the account whose bump seed is referenced."
+      docs: ["The name of the account whose bump seed is referenced."]
     })
   ]
 });
 
 // src/v1/nodes/contextualValueNodes/AccountValueNode.ts
 var accountValueNode = defineNode("accountValueNode", {
-  docs: "Refers to a named account in the surrounding instruction.",
+  docs: ["Refers to a named account in the surrounding instruction."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced account."
+      docs: ["The name of the referenced account."]
     })
   ]
 });
 
 // src/v1/nodes/contextualValueNodes/ArgumentValueNode.ts
 var argumentValueNode = defineNode("argumentValueNode", {
-  docs: "Refers to a named argument of the surrounding instruction.",
+  docs: ["Refers to a named argument of the surrounding instruction."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced argument."
+      docs: ["The name of the referenced argument."]
     })
   ]
 });
 
 // src/v1/nodes/contextualValueNodes/ConditionalValueNode.ts
 var conditionalValueNode = defineNode("conditionalValueNode", {
-  docs: "A branching contextual value. The condition resolves to a value at instruction time; that result selects between `ifTrue` and `ifFalse`.",
+  docs: [
+    "A branching contextual value.",
+    "The condition resolves to a value at instruction time; that result selects between `ifTrue` and `ifFalse`."
+  ],
   attributes: [
     attribute("condition", union("ConditionalValueCondition"), {
-      docs: "The value whose evaluation drives the branch."
+      docs: ["The value whose evaluation drives the branch."]
     }),
     optionalAttribute("value", union("ValueNode"), {
-      docs: "When present, the condition result is compared for equality against this value; otherwise the result is treated as a boolean."
+      docs: [
+        "When present, the condition result is compared for equality against this value.",
+        "Otherwise the result is treated as a boolean."
+      ]
     }),
     optionalAttribute("ifTrue", union("InstructionInputValueNode"), {
-      docs: "The value used when the condition resolves truthy (or matches `value`)."
+      docs: ["The value used when the condition resolves truthy (or matches `value`)."]
     }),
     optionalAttribute("ifFalse", union("InstructionInputValueNode"), {
-      docs: "The value used when the condition resolves falsy (or does not match `value`)."
+      docs: ["The value used when the condition resolves falsy (or does not match `value`)."]
     })
   ]
 });
@@ -486,101 +554,109 @@ var STANDALONE_CONTEXTUAL_VALUE_NODE_KINDS = [
   "resolverValueNode"
 ];
 var standaloneContextualValueNodeUnion = defineUnion("StandaloneContextualValueNode", {
-  docs: "Every contextual-value node usable as a top-level value.",
+  docs: ["Every contextual-value node usable as a top-level value."],
   members: [...STANDALONE_CONTEXTUAL_VALUE_NODE_KINDS]
 });
 var contextualValueNodeUnion = defineUnion("ContextualValueNode", {
-  docs: "The composable form: any standalone contextual-value node.",
+  docs: ["The composable form: any standalone contextual-value node."],
   members: [union("StandaloneContextualValueNode")]
 });
 var registeredContextualValueNodeUnion = defineUnion("RegisteredContextualValueNode", {
-  docs: "Every node tagged as a contextual-value node, including helper variants.",
+  docs: ["Every node tagged as a contextual-value node, including helper variants."],
   members: [union("StandaloneContextualValueNode"), "pdaSeedValueNode"]
 });
 var instructionInputValueNodeUnion = defineUnion("InstructionInputValueNode", {
-  docs: "Anything that can be used as the input value for an instruction account or argument default \u2014 a value, contextual reference, or program link.",
+  docs: [
+    "Anything that can be used as the input value for an instruction account or argument default.",
+    "Covers concrete values, contextual references, and program links."
+  ],
   members: [union("ContextualValueNode"), "programLinkNode", union("ValueNode")]
 });
 var conditionalValueConditionUnion = defineUnion("ConditionalValueCondition", {
-  docs: "The condition forms accepted by a `conditionalValueNode`.",
+  docs: ["The condition forms accepted by a `conditionalValueNode`."],
   members: ["accountValueNode", "argumentValueNode", "resolverValueNode"]
 });
 var resolverDependencyUnion = defineUnion("ResolverDependency", {
-  docs: "The dependency forms accepted by a `resolverValueNode`.",
+  docs: ["The dependency forms accepted by a `resolverValueNode`."],
   members: ["accountValueNode", "argumentValueNode"]
 });
 var pdaSeedValueValueUnion = defineUnion("PdaSeedValueValue", {
-  docs: "The value forms accepted by a `pdaSeedValueNode`.",
+  docs: ["The value forms accepted by a `pdaSeedValueNode`."],
   members: ["accountValueNode", "argumentValueNode", union("ValueNode")]
 });
 var pdaValuePdaUnion = defineUnion("PdaValuePda", {
-  docs: "A `pdaValueNode` may reference a PDA either by link or inline.",
+  docs: ["A `pdaValueNode` may reference a PDA either by link or inline."],
   members: ["pdaLinkNode", "pdaNode"]
 });
 var pdaValueProgramIdUnion = defineUnion("PdaValueProgramId", {
-  docs: "The program-id forms accepted by a `pdaValueNode`.",
+  docs: ["The program-id forms accepted by a `pdaValueNode`."],
   members: ["accountValueNode", "argumentValueNode"]
 });
 
 // src/v1/nodes/contextualValueNodes/IdentityValueNode.ts
 var identityValueNode = defineNode("identityValueNode", {
-  docs: "Refers to the wallet identity providing the instruction context.",
+  docs: ["Refers to the wallet identity providing the instruction context."],
   attributes: []
 });
 
 // src/v1/nodes/contextualValueNodes/PayerValueNode.ts
 var payerValueNode = defineNode("payerValueNode", {
-  docs: "Refers to the wallet paying for the surrounding transaction.",
+  docs: ["Refers to the wallet paying for the surrounding transaction."],
   attributes: []
 });
 
 // src/v1/nodes/contextualValueNodes/PdaSeedValueNode.ts
 var pdaSeedValueNode = defineNode("pdaSeedValueNode", {
-  docs: "Pairs a PDA seed name with the value to substitute when deriving the PDA.",
+  docs: ["Pairs a PDA seed name with the value to substitute when deriving the PDA."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the seed being filled in."
+      docs: ["The name of the seed being filled in."]
     }),
     attribute("value", union("PdaSeedValueValue"), {
-      docs: "The value to substitute for the seed."
+      docs: ["The value to substitute for the seed."]
     })
   ]
 });
 
 // src/v1/nodes/contextualValueNodes/PdaValueNode.ts
 var pdaValueNode = defineNode("pdaValueNode", {
-  docs: "Resolves to a PDA derived from a list of seed values.",
+  docs: ["Resolves to a PDA derived from a list of seed values."],
   attributes: [
     attribute("pda", union("PdaValuePda"), {
-      docs: "The PDA being derived \u2014 either a link to a defined PDA or an inline `pdaNode`."
+      docs: ["The PDA being derived \u2014 either a link to a defined PDA or an inline `pdaNode`."]
     }),
     attribute("seeds", array(node("pdaSeedValueNode")), {
-      docs: "The seed values used to derive the PDA, paired with their seed names."
+      docs: ["The seed values used to derive the PDA, paired with their seed names."]
     }),
     optionalAttribute("programId", union("PdaValueProgramId"), {
-      docs: "The program ID used to derive the PDA. When omitted, the PDA\u2019s declared program is used."
+      docs: ["The program ID used to derive the PDA. When omitted, the PDA\u2019s declared program is used."]
     })
   ]
 });
 
 // src/v1/nodes/contextualValueNodes/ProgramIdValueNode.ts
 var programIdValueNode = defineNode("programIdValueNode", {
-  docs: "Refers to the program ID of the surrounding instruction.",
+  docs: ["Refers to the program ID of the surrounding instruction."],
   attributes: []
 });
 
 // src/v1/nodes/contextualValueNodes/ResolverValueNode.ts
 var resolverValueNode = defineNode("resolverValueNode", {
-  docs: "A custom resolver: a named function provided by the consumer that produces a value, optionally depending on other accounts and arguments.",
+  docs: [
+    "A custom resolver: a named function provided by the consumer that produces a value.",
+    "May optionally depend on other accounts and arguments resolved at instruction-build time."
+  ],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the resolver function."
+      docs: ["The name of the resolver function."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the resolver."
+      docs: ["Markdown documentation for the resolver."]
     }),
     optionalAttribute("dependsOn", array(union("ResolverDependency")), {
-      docs: "The accounts and arguments the resolver depends on. Used by clients to ensure the dependencies are resolved first."
+      docs: [
+        "The accounts and arguments the resolver depends on. Used by clients to ensure the dependencies are resolved first."
+      ]
     })
   ]
 });
@@ -612,37 +688,37 @@ var ALL_CONTEXTUAL_VALUE_NODE_UNIONS = [
 
 // src/v1/nodes/countNodes/CountNode.ts
 var registeredCountNodeUnion = defineUnion("RegisteredCountNode", {
-  docs: "Every node tagged as a count strategy.",
+  docs: ["Every node tagged as a count strategy."],
   members: ["fixedCountNode", "prefixedCountNode", "remainderCountNode"]
 });
 var countNodeUnion = defineUnion("CountNode", {
-  docs: "The composable form: any registered count node.",
+  docs: ["The composable form: any registered count node."],
   members: [union("RegisteredCountNode")]
 });
 
 // src/v1/nodes/countNodes/FixedCountNode.ts
 var fixedCountNode = defineNode("fixedCountNode", {
-  docs: "A count strategy that fixes the number of items at a constant value.",
+  docs: ["A count strategy that fixes the number of items at a constant value."],
   attributes: [
     attribute("value", u64(), {
-      docs: "The fixed number of items."
+      docs: ["The fixed number of items."]
     })
   ]
 });
 
 // src/v1/nodes/countNodes/PrefixedCountNode.ts
 var prefixedCountNode = defineNode("prefixedCountNode", {
-  docs: "A count strategy where the number of items is read from a numeric prefix.",
+  docs: ["A count strategy where the number of items is read from a numeric prefix."],
   attributes: [
-    attribute("prefix", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used as the count prefix."
+    attribute("prefix", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used as the count prefix."]
     })
   ]
 });
 
 // src/v1/nodes/countNodes/RemainderCountNode.ts
 var remainderCountNode = defineNode("remainderCountNode", {
-  docs: "A count strategy where items are read until the buffer is exhausted.",
+  docs: ["A count strategy where items are read until the buffer is exhausted."],
   attributes: []
 });
 
@@ -652,62 +728,62 @@ var ALL_COUNT_NODE_UNIONS = [registeredCountNodeUnion, countNodeUnion];
 
 // src/v1/nodes/DefinedTypeNode.ts
 var definedTypeNode = defineNode("definedTypeNode", {
-  docs: "A reusable named type that can be referenced by `definedTypeLinkNode` from elsewhere in the IDL.",
+  docs: ["A reusable named type that can be referenced by `definedTypeLinkNode` from elsewhere in the IDL."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the defined type."
+      docs: ["The name of the defined type."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the type."
+      docs: ["Markdown documentation for the type."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The type definition."
+      docs: ["The type definition."]
     })
   ]
 });
 
 // src/v1/nodes/discriminatorNodes/ConstantDiscriminatorNode.ts
 var constantDiscriminatorNode = defineNode("constantDiscriminatorNode", {
-  docs: "Identifies a node by a constant value at a known byte offset (e.g. a magic header).",
+  docs: ["Identifies a node by a constant value at a known byte offset (e.g. a magic header)."],
   attributes: [
     attribute("offset", u64(), {
-      docs: "The byte offset at which the constant begins."
+      docs: ["The byte offset at which the constant begins."]
     }),
     attribute("constant", node("constantValueNode"), {
-      docs: "The constant value expected at the offset."
+      docs: ["The constant value expected at the offset."]
     })
   ]
 });
 
 // src/v1/nodes/discriminatorNodes/DiscriminatorNode.ts
 var registeredDiscriminatorNodeUnion = defineUnion("RegisteredDiscriminatorNode", {
-  docs: "Every node tagged as a discriminator strategy.",
+  docs: ["Every node tagged as a discriminator strategy."],
   members: ["constantDiscriminatorNode", "fieldDiscriminatorNode", "sizeDiscriminatorNode"]
 });
 var discriminatorNodeUnion = defineUnion("DiscriminatorNode", {
-  docs: "The composable form: any registered discriminator node.",
+  docs: ["The composable form: any registered discriminator node."],
   members: [union("RegisteredDiscriminatorNode")]
 });
 
 // src/v1/nodes/discriminatorNodes/FieldDiscriminatorNode.ts
 var fieldDiscriminatorNode = defineNode("fieldDiscriminatorNode", {
-  docs: "Identifies a node by the value of a named field at a known byte offset.",
+  docs: ["Identifies a node by the value of a named field at a known byte offset."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the discriminating field."
+      docs: ["The name of the discriminating field."]
     }),
     attribute("offset", u64(), {
-      docs: "The byte offset of the field."
+      docs: ["The byte offset of the field."]
     })
   ]
 });
 
 // src/v1/nodes/discriminatorNodes/SizeDiscriminatorNode.ts
 var sizeDiscriminatorNode = defineNode("sizeDiscriminatorNode", {
-  docs: "Identifies a node by its expected total byte size.",
+  docs: ["Identifies a node by its expected total byte size."],
   attributes: [
     attribute("size", u64(), {
-      docs: "The expected byte size."
+      docs: ["The expected byte size."]
     })
   ]
 });
@@ -722,258 +798,287 @@ var ALL_DISCRIMINATOR_NODE_UNIONS = [registeredDiscriminatorNodeUnion, discrimin
 
 // src/v1/nodes/ErrorNode.ts
 var errorNode = defineNode("errorNode", {
-  docs: "A program error \u2014 a numeric code paired with a name and human-readable message.",
+  docs: ["A program error \u2014 a numeric code paired with a name and human-readable message."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the error."
+      docs: ["The name of the error."]
     }),
     attribute("code", u32(), {
-      docs: "The numeric error code returned by the program."
+      docs: ["The numeric error code returned by the program."]
     }),
     attribute("message", string(), {
-      docs: "A human-readable description of the error."
+      docs: ["A human-readable description of the error."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the error."
+      docs: ["Markdown documentation for the error."]
     })
   ]
 });
 
 // src/v1/nodes/EventNode.ts
 var eventNode = defineNode("eventNode", {
-  docs: "A program event: its data shape and optional discriminators used to identify it on the wire.",
+  docs: ["A program event: its data shape and optional discriminators used to identify it on the wire."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the event."
+      docs: ["The name of the event."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the event."
+      docs: ["Markdown documentation for the event."]
     }),
     attribute("data", union("TypeNode"), {
-      docs: "The type describing the event payload."
+      docs: ["The type describing the event payload."]
     }),
     optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
-      docs: "Discriminators that distinguish this event from others. When multiple are listed, they are combined with a logical AND."
+      docs: [
+        "Discriminators that distinguish this event from others. When multiple are listed, they are combined with a logical AND."
+      ]
     })
   ]
 });
 
 // src/v1/nodes/InstructionAccountNode.ts
 var instructionAccountNode = defineNode("instructionAccountNode", {
-  docs: "An account participating in an instruction, with its name, signing/writability flags, and an optional default value.",
+  docs: [
+    "An account participating in an instruction, with its name, signing/writability flags, and an optional default value."
+  ],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the account."
+      docs: ["The name of the account."]
     }),
     attribute("isWritable", boolean(), {
-      docs: "Whether the instruction may write to the account."
+      docs: ["Whether the instruction may write to the account."]
     }),
     attribute("isSigner", literalUnion(true, false, "either"), {
-      docs: 'Whether the account must sign the transaction. The literal `"either"` indicates a slot that may or may not sign depending on context.'
+      docs: [
+        "Whether the account must sign the transaction.",
+        'The literal `"either"` indicates a slot that may or may not sign depending on context.'
+      ]
     }),
     optionalAttribute("isOptional", boolean(), {
-      docs: "Whether the account slot may be omitted by callers."
+      docs: ["Whether the account slot may be omitted by callers."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the account slot."
+      docs: ["Markdown documentation for the account slot."]
     }),
     optionalAttribute("defaultValue", union("InstructionInputValueNode"), {
-      docs: "A default value used to fill the slot when the caller does not provide one."
+      docs: ["A default value used to fill the slot when the caller does not provide one."]
     })
   ]
 });
 
 // src/v1/nodes/InstructionArgumentNode.ts
 var instructionArgumentNode = defineNode("instructionArgumentNode", {
-  docs: "A named argument of an instruction, with its type and an optional default value.",
+  docs: ["A named argument of an instruction, with its type and an optional default value."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the argument."
+      docs: ["The name of the argument."]
     }),
     optionalAttribute("defaultValueStrategy", enumeration("DefaultValueStrategy"), {
-      docs: "How a configured default value is exposed in generated APIs. Required when `defaultValue` is set."
+      docs: ["How a configured default value is exposed in generated APIs. Required when `defaultValue` is set."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the argument."
+      docs: ["Markdown documentation for the argument."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The type of the argument."
+      docs: ["The type of the argument."]
     }),
     optionalAttribute("defaultValue", union("InstructionInputValueNode"), {
-      docs: "A default value used when the argument is omitted by callers."
+      docs: ["A default value used when the argument is omitted by callers."]
     })
   ]
 });
 
 // src/v1/nodes/InstructionByteDeltaNode.ts
 var instructionByteDeltaNode = defineNode("instructionByteDeltaNode", {
-  docs: "A byte-size delta applied when computing rent or buffer size \u2014 typically used by instructions that resize accounts.",
+  docs: [
+    "A byte-size delta applied when computing rent or buffer size \u2014 typically used by instructions that resize accounts."
+  ],
   attributes: [
     attribute("withHeader", boolean(), {
-      docs: "Whether the delta includes the account header overhead."
+      docs: ["Whether the delta includes the account header overhead."]
     }),
     optionalAttribute("subtract", boolean(), {
-      docs: "When `true`, the delta is subtracted from the running size instead of added. Defaults to `false`."
+      docs: ["When `true`, the delta is subtracted from the running size instead of added. Defaults to `false`."]
     }),
     attribute("value", union("InstructionByteDeltaValue"), {
-      docs: "The source of the delta value \u2014 a literal number, a referenced account or argument, or a resolver."
+      docs: [
+        "The source of the delta value \u2014 a literal number, a referenced account or argument, or a resolver."
+      ]
     })
   ]
 });
 
 // src/v1/nodes/InstructionNode.ts
 var instructionNode = defineNode("instructionNode", {
-  docs: "A program instruction: its accounts, arguments, byte-delta hints, discriminators, optional status, and optional sub-instructions.",
+  docs: [
+    "A program instruction: its accounts, arguments, byte-delta hints, discriminators, optional status, and optional sub-instructions."
+  ],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the instruction."
+      docs: ["The name of the instruction."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the instruction."
+      docs: ["Markdown documentation for the instruction."]
     }),
     optionalAttribute("optionalAccountStrategy", enumeration("OptionalAccountStrategy"), {
-      docs: "How absent optional accounts are represented when serialising the instruction."
+      docs: ["How absent optional accounts are represented when serialising the instruction."]
     }),
     attribute("accounts", array(node("instructionAccountNode")), {
-      docs: "The accounts the instruction operates on, in order."
+      docs: ["The accounts the instruction operates on, in order."]
     }),
     attribute("arguments", array(node("instructionArgumentNode")), {
-      docs: "The serialised arguments of the instruction, in order."
+      docs: ["The serialised arguments of the instruction, in order."]
     }),
     optionalAttribute("extraArguments", array(node("instructionArgumentNode")), {
-      docs: "Additional arguments exposed in the generated client API but not serialised on the wire."
+      docs: ["Additional arguments exposed in the generated client API but not serialised on the wire."]
     }),
     optionalAttribute("remainingAccounts", array(node("instructionRemainingAccountsNode")), {
-      docs: "Variable-length tails of accounts appended after the named account slots."
+      docs: ["Variable-length tails of accounts appended after the named account slots."]
     }),
     optionalAttribute("byteDeltas", array(node("instructionByteDeltaNode")), {
-      docs: "Byte-size adjustments applied when computing rent or buffer size \u2014 for instructions that resize accounts."
+      docs: [
+        "Byte-size adjustments applied when computing rent or buffer size \u2014 for instructions that resize accounts."
+      ]
     }),
     optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
-      docs: "Discriminators that distinguish this instruction from others. When multiple are listed, they are combined with a logical AND."
+      docs: [
+        "Discriminators that distinguish this instruction from others.",
+        "When multiple are listed, they are combined with a logical AND."
+      ]
     }),
     optionalAttribute("status", node("instructionStatusNode"), {
-      docs: "The lifecycle status of the instruction."
+      docs: ["The lifecycle status of the instruction."]
     }),
     optionalAttribute("subInstructions", array(node("instructionNode")), {
-      docs: "Inner instructions invoked through CPI as part of executing this instruction."
+      docs: ["Inner instructions invoked through CPI as part of executing this instruction."]
     })
   ]
 });
 
 // src/v1/nodes/InstructionNodeUnions.ts
 var instructionByteDeltaValueUnion = defineUnion("InstructionByteDeltaValue", {
-  docs: "The value forms accepted by an `instructionByteDeltaNode`.",
+  docs: ["The value forms accepted by an `instructionByteDeltaNode`."],
   members: ["accountLinkNode", "argumentValueNode", "numberValueNode", "resolverValueNode"]
 });
 var instructionRemainingAccountsValueUnion = defineUnion("InstructionRemainingAccountsValue", {
-  docs: "The value forms accepted by an `instructionRemainingAccountsNode`.",
+  docs: ["The value forms accepted by an `instructionRemainingAccountsNode`."],
   members: ["argumentValueNode", "resolverValueNode"]
 });
 
 // src/v1/nodes/InstructionRemainingAccountsNode.ts
 var instructionRemainingAccountsNode = defineNode("instructionRemainingAccountsNode", {
-  docs: 'A "remaining accounts" slot in an instruction \u2014 a variable-length tail of accounts derived from a value.',
+  docs: ['A "remaining accounts" slot in an instruction \u2014 a variable-length tail of accounts derived from a value.'],
   attributes: [
     optionalAttribute("isOptional", boolean(), {
-      docs: "Whether the remaining-accounts tail may be empty."
+      docs: ["Whether the remaining-accounts tail may be empty."]
     }),
     optionalAttribute("isSigner", literalUnion(true, false, "either"), {
-      docs: 'Whether each remaining account must sign the transaction. The literal `"either"` indicates a slot that may or may not sign depending on context.'
+      docs: [
+        "Whether each remaining account must sign the transaction.",
+        'The literal `"either"` indicates a slot that may or may not sign depending on context.'
+      ]
     }),
     optionalAttribute("isWritable", boolean(), {
-      docs: "Whether the instruction may write to each remaining account."
+      docs: ["Whether the instruction may write to each remaining account."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the remaining-accounts slot."
+      docs: ["Markdown documentation for the remaining-accounts slot."]
     }),
     attribute("value", union("InstructionRemainingAccountsValue"), {
-      docs: "The source of the remaining-accounts list \u2014 a referenced argument or a resolver."
+      docs: ["The source of the remaining-accounts list \u2014 a referenced argument or a resolver."]
     })
   ]
 });
 
 // src/v1/nodes/InstructionStatusNode.ts
 var instructionStatusNode = defineNode("instructionStatusNode", {
-  docs: "The lifecycle stage of an instruction (draft, live, deprecated, archived) with an optional accompanying message.",
+  docs: [
+    "The lifecycle stage of an instruction (draft, live, deprecated, archived) with an optional accompanying message."
+  ],
   attributes: [
     attribute("lifecycle", enumeration("InstructionLifecycle"), {
-      docs: "The lifecycle stage."
+      docs: ["The lifecycle stage."]
     }),
     optionalAttribute("message", string(), {
-      docs: "Free-form prose accompanying the status \u2014 e.g. a deprecation notice with migration guidance."
+      docs: ["Free-form prose accompanying the status \u2014 e.g. a deprecation notice with migration guidance."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/AccountLinkNode.ts
 var accountLinkNode = defineNode("accountLinkNode", {
-  docs: "A reference to an account defined elsewhere \u2014 possibly in a different program.",
+  docs: ["A reference to an account defined elsewhere \u2014 possibly in a different program."],
   attributes: [
     optionalAttribute("program", node("programLinkNode"), {
-      docs: "The program the referenced account belongs to. When omitted, the surrounding program is assumed."
+      docs: ["The program the referenced account belongs to. When omitted, the surrounding program is assumed."]
     }),
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced account."
+      docs: ["The name of the referenced account."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/DefinedTypeLinkNode.ts
 var definedTypeLinkNode = defineNode("definedTypeLinkNode", {
-  docs: "A reference to a defined type \u2014 possibly in a different program.",
+  docs: ["A reference to a defined type \u2014 possibly in a different program."],
   attributes: [
     optionalAttribute("program", node("programLinkNode"), {
-      docs: "The program the referenced type is defined in. When omitted, the surrounding program is assumed."
+      docs: ["The program the referenced type is defined in. When omitted, the surrounding program is assumed."]
     }),
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced defined type."
+      docs: ["The name of the referenced defined type."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/InstructionAccountLinkNode.ts
 var instructionAccountLinkNode = defineNode("instructionAccountLinkNode", {
-  docs: "A reference to an account of another instruction.",
+  docs: ["A reference to an account of another instruction."],
   attributes: [
     optionalAttribute("instruction", node("instructionLinkNode"), {
-      docs: "The instruction the referenced account belongs to. When omitted, the surrounding instruction is assumed."
+      docs: [
+        "The instruction the referenced account belongs to. When omitted, the surrounding instruction is assumed."
+      ]
     }),
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced instruction account."
+      docs: ["The name of the referenced instruction account."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/InstructionArgumentLinkNode.ts
 var instructionArgumentLinkNode = defineNode("instructionArgumentLinkNode", {
-  docs: "A reference to an argument of another instruction.",
+  docs: ["A reference to an argument of another instruction."],
   attributes: [
     optionalAttribute("instruction", node("instructionLinkNode"), {
-      docs: "The instruction the referenced argument belongs to. When omitted, the surrounding instruction is assumed."
+      docs: [
+        "The instruction the referenced argument belongs to. When omitted, the surrounding instruction is assumed."
+      ]
     }),
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced instruction argument."
+      docs: ["The name of the referenced instruction argument."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/InstructionLinkNode.ts
 var instructionLinkNode = defineNode("instructionLinkNode", {
-  docs: "A reference to an instruction defined elsewhere \u2014 possibly in a different program.",
+  docs: ["A reference to an instruction defined elsewhere \u2014 possibly in a different program."],
   attributes: [
     optionalAttribute("program", node("programLinkNode"), {
-      docs: "The program the referenced instruction belongs to. When omitted, the surrounding program is assumed."
+      docs: [
+        "The program the referenced instruction belongs to. When omitted, the surrounding program is assumed."
+      ]
     }),
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced instruction."
+      docs: ["The name of the referenced instruction."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/LinkNode.ts
 var registeredLinkNodeUnion = defineUnion("RegisteredLinkNode", {
-  docs: "Every node tagged as a link to another part of the IDL.",
+  docs: ["Every node tagged as a link to another part of the IDL."],
   members: [
     "accountLinkNode",
     "definedTypeLinkNode",
@@ -985,29 +1090,29 @@ var registeredLinkNodeUnion = defineUnion("RegisteredLinkNode", {
   ]
 });
 var linkNodeUnion = defineUnion("LinkNode", {
-  docs: "The composable form: any registered link node.",
+  docs: ["The composable form: any registered link node."],
   members: [union("RegisteredLinkNode")]
 });
 
 // src/v1/nodes/linkNodes/PdaLinkNode.ts
 var pdaLinkNode = defineNode("pdaLinkNode", {
-  docs: "A reference to a PDA defined elsewhere \u2014 possibly in a different program.",
+  docs: ["A reference to a PDA defined elsewhere \u2014 possibly in a different program."],
   attributes: [
     optionalAttribute("program", node("programLinkNode"), {
-      docs: "The program the referenced PDA belongs to. When omitted, the surrounding program is assumed."
+      docs: ["The program the referenced PDA belongs to. When omitted, the surrounding program is assumed."]
     }),
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced PDA."
+      docs: ["The name of the referenced PDA."]
     })
   ]
 });
 
 // src/v1/nodes/linkNodes/ProgramLinkNode.ts
 var programLinkNode = defineNode("programLinkNode", {
-  docs: "A reference to a program by name.",
+  docs: ["A reference to a program by name."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the referenced program."
+      docs: ["The name of the referenced program."]
     })
   ]
 });
@@ -1026,62 +1131,64 @@ var ALL_LINK_NODE_UNIONS = [registeredLinkNodeUnion, linkNodeUnion];
 
 // src/v1/nodes/PdaNode.ts
 var pdaNode = defineNode("pdaNode", {
-  docs: "A program-derived address: its name, optional program ID override, and the seeds used to derive it.",
+  docs: ["A program-derived address: its name, optional program ID override, and the seeds used to derive it."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the PDA."
+      docs: ["The name of the PDA."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the PDA."
+      docs: ["Markdown documentation for the PDA."]
     }),
     optionalAttribute("programId", string(), {
-      docs: "The base58-encoded program ID used to derive the PDA. When omitted, the surrounding program is assumed."
+      docs: [
+        "The base58-encoded program ID used to derive the PDA. When omitted, the surrounding program is assumed."
+      ]
     }),
     attribute("seeds", array(union("PdaSeedNode")), {
-      docs: "The seeds used to derive the PDA, in order."
+      docs: ["The seeds used to derive the PDA, in order."]
     })
   ]
 });
 
 // src/v1/nodes/pdaSeedNodes/ConstantPdaSeedNode.ts
 var constantPdaSeedNode = defineNode("constantPdaSeedNode", {
-  docs: "A PDA seed with a constant value (e.g. a UTF-8 string or a fixed byte sequence).",
+  docs: ["A PDA seed with a constant value (e.g. a UTF-8 string or a fixed byte sequence)."],
   attributes: [
     attribute("type", union("TypeNode"), {
-      docs: "The type of the seed value."
+      docs: ["The type of the seed value."]
     }),
     attribute("value", union("ConstantPdaSeedValue"), {
-      docs: "The constant value to use as the seed \u2014 either a literal value or the program ID placeholder."
+      docs: ["The constant value to use as the seed \u2014 either a literal value or the program ID placeholder."]
     })
   ]
 });
 
 // src/v1/nodes/pdaSeedNodes/PdaSeedNode.ts
 var registeredPdaSeedNodeUnion = defineUnion("RegisteredPdaSeedNode", {
-  docs: "Every node tagged as a PDA seed.",
+  docs: ["Every node tagged as a PDA seed."],
   members: ["constantPdaSeedNode", "variablePdaSeedNode"]
 });
 var pdaSeedNodeUnion = defineUnion("PdaSeedNode", {
-  docs: "The composable form: any registered PDA seed node.",
+  docs: ["The composable form: any registered PDA seed node."],
   members: [union("RegisteredPdaSeedNode")]
 });
 var constantPdaSeedValueUnion = defineUnion("ConstantPdaSeedValue", {
-  docs: "The value forms a `constantPdaSeedNode` may carry \u2014 either a literal value or the program ID placeholder.",
+  docs: ["The value forms a `constantPdaSeedNode` may carry \u2014 either a literal value or the program ID placeholder."],
   members: ["programIdValueNode", union("ValueNode")]
 });
 
 // src/v1/nodes/pdaSeedNodes/VariablePdaSeedNode.ts
 var variablePdaSeedNode = defineNode("variablePdaSeedNode", {
-  docs: "A PDA seed whose value is provided at derivation time, identified by name.",
+  docs: ["A PDA seed whose value is provided at derivation time, identified by name."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the seed variable."
+      docs: ["The name of the seed variable."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the seed variable."
+      docs: ["Markdown documentation for the seed variable."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The expected type of the seed value."
+      docs: ["The expected type of the seed value."]
     })
   ]
 });
@@ -1096,408 +1203,456 @@ var ALL_PDA_SEED_NODE_UNIONS = [
 
 // src/v1/nodes/ProgramNode.ts
 var programNode = defineNode("programNode", {
-  docs: "A Solana program: its identity, version, accounts, instructions, defined types, PDAs, events, errors, and constants.",
+  docs: [
+    "A Solana program: its identity, version, accounts, instructions, defined types, PDAs, events, errors, and constants."
+  ],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the program."
+      docs: ["The name of the program."]
     }),
     attribute("publicKey", string(), {
-      docs: "The base58-encoded program ID."
+      docs: ["The base58-encoded program ID."]
     }),
     attribute("version", stringVersion(), {
-      docs: "The version of the program, in semver form."
+      docs: ["The version of the program, in semver form."]
     }),
     optionalAttribute("origin", enumeration("ProgramOrigin"), {
-      docs: "The toolchain that originally generated the program description, if known."
+      docs: ["The toolchain that originally generated the program description, if known."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the program."
+      docs: ["Markdown documentation for the program."]
     }),
     attribute("accounts", array(node("accountNode")), {
-      docs: "The accounts owned by the program."
+      docs: ["The accounts owned by the program."]
     }),
     attribute("instructions", array(node("instructionNode")), {
-      docs: "The instructions exposed by the program."
+      docs: ["The instructions exposed by the program."]
     }),
     attribute("definedTypes", array(node("definedTypeNode")), {
-      docs: "The reusable types defined by the program."
+      docs: ["The reusable types defined by the program."]
     }),
     attribute("pdas", array(node("pdaNode")), {
-      docs: "The PDAs derived by the program."
+      docs: ["The PDAs derived by the program."]
     }),
     attribute("events", array(node("eventNode")), {
-      docs: "The events emitted by the program."
+      docs: ["The events emitted by the program."]
     }),
     attribute("errors", array(node("errorNode")), {
-      docs: "The errors returned by the program."
+      docs: ["The errors returned by the program."]
     }),
     attribute("constants", array(node("constantNode")), {
-      docs: "The constants exposed by the program."
+      docs: ["The constants exposed by the program."]
     })
   ]
 });
 
 // src/v1/nodes/RootNode.ts
 var rootNode = defineNode("rootNode", {
-  docs: "The root of a Codama IDL document. Pairs a primary program with any number of additional programs and tags the document with the spec version.",
+  docs: [
+    "The root of a Codama IDL document.",
+    "Pairs a primary program with any number of additional programs and tags the document with the spec version."
+  ],
   attributes: [
     attribute("standard", literal("codama"), {
-      docs: "A literal marker identifying the document as a Codama IDL."
+      docs: ["A literal marker identifying the document as a Codama IDL."]
     }),
     attribute("version", codamaVersion(), {
-      docs: "The Codama spec version this document conforms to."
+      docs: ["The Codama spec version this document conforms to."]
     }),
     attribute("program", node("programNode"), {
-      docs: "The primary program described by the document."
+      docs: ["The primary program described by the document."]
     }),
     attribute("additionalPrograms", array(node("programNode")), {
-      docs: "Additional programs referenced by the primary program."
+      docs: ["Additional programs referenced by the primary program."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/AmountTypeNode.ts
 var amountTypeNode = defineNode("amountTypeNode", {
-  docs: "Wraps a number type to provide additional context such as decimal places and a unit. Useful for amounts representing financial values.",
+  docs: [
+    "Wraps a number type to provide additional context such as decimal places and a unit.",
+    "Useful for amounts representing financial values."
+  ],
   attributes: [
     attribute("decimals", u32(), {
-      docs: "The number of decimal places the wrapped integer carries. For example, an integer value of 12345 with 2 decimal places represents 123.45."
+      docs: [
+        "The number of decimal places the wrapped integer carries.",
+        "For example, an integer value of 12345 with 2 decimal places represents 123.45."
+      ]
     }),
     optionalAttribute("unit", string(), {
-      docs: 'The unit of the amount \u2014 e.g. "USD" or "%".'
+      docs: ['The unit of the amount \u2014 e.g. "USD" or "%".']
     }),
-    attribute("number", nestedTypeNode("numberTypeNode"), {
-      docs: "The number type the amount wraps."
+    attribute("number", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The number type the amount wraps."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/ArrayTypeNode.ts
 var arrayTypeNode = defineNode("arrayTypeNode", {
-  docs: "A homogeneous list of items. The item type is defined by `item`; the length is determined by the `count` strategy.",
+  docs: [
+    "A homogeneous list of items. The item type is defined by `item`; the length is determined by the `count` strategy."
+  ],
   attributes: [
     attribute("item", union("TypeNode"), {
-      docs: "The type of each item in the array."
+      docs: ["The type of each item in the array."]
     }),
     attribute("count", union("CountNode"), {
-      docs: "The strategy used to determine the number of items."
+      docs: ["The strategy used to determine the number of items."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/BooleanTypeNode.ts
 var booleanTypeNode = defineNode("booleanTypeNode", {
-  docs: "A boolean serialised as a numeric value. The wrapped number type determines the byte width.",
+  docs: ["A boolean serialised as a numeric value. The wrapped number type determines the byte width."],
   attributes: [
-    attribute("size", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used to serialise the boolean."
+    attribute("size", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used to serialise the boolean."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/BytesTypeNode.ts
 var bytesTypeNode = defineNode("bytesTypeNode", {
-  docs: "A raw sequence of bytes. Typically used inside a fixed-size, size-prefixed, or sentinel-terminated wrapper.",
+  docs: [
+    "A raw sequence of bytes. Typically used inside a fixed-size, size-prefixed, or sentinel-terminated wrapper."
+  ],
   attributes: []
 });
 
 // src/v1/nodes/typeNodes/DateTimeTypeNode.ts
 var dateTimeTypeNode = defineNode("dateTimeTypeNode", {
-  docs: "A timestamp encoded as a number, typically seconds since the Unix epoch. The wrapped number type determines the byte width.",
+  docs: [
+    "A timestamp encoded as a number, typically seconds since the Unix epoch. The wrapped number type determines the byte width."
+  ],
   attributes: [
-    attribute("number", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used to serialise the timestamp."
+    attribute("number", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used to serialise the timestamp."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/EnumEmptyVariantTypeNode.ts
 var enumEmptyVariantTypeNode = defineNode("enumEmptyVariantTypeNode", {
-  docs: "A unit-style variant of an enum that carries no payload.",
+  docs: ["A unit-style variant of an enum that carries no payload."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the variant."
+      docs: ["The name of the variant."]
     }),
     optionalAttribute("discriminator", u32(), {
-      docs: "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
+      docs: [
+        "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
+      ]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/EnumStructVariantTypeNode.ts
 var enumStructVariantTypeNode = defineNode("enumStructVariantTypeNode", {
-  docs: "A variant of an enum that carries a struct payload (named fields).",
+  docs: ["A variant of an enum that carries a struct payload (named fields)."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the variant."
+      docs: ["The name of the variant."]
     }),
     optionalAttribute("discriminator", u32(), {
-      docs: "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
+      docs: [
+        "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
+      ]
     }),
-    attribute("struct", nestedTypeNode("structTypeNode"), {
-      docs: "The struct of named fields carried by the variant."
+    attribute("struct", nestedUnion("NestedTypeNode", "structTypeNode"), {
+      docs: ["The struct of named fields carried by the variant."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/EnumTupleVariantTypeNode.ts
 var enumTupleVariantTypeNode = defineNode("enumTupleVariantTypeNode", {
-  docs: "A variant of an enum that carries a tuple payload (positional fields).",
+  docs: ["A variant of an enum that carries a tuple payload (positional fields)."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the variant."
+      docs: ["The name of the variant."]
     }),
     optionalAttribute("discriminator", u32(), {
-      docs: "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
+      docs: [
+        "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
+      ]
     }),
-    attribute("tuple", nestedTypeNode("tupleTypeNode"), {
-      docs: "The tuple of positional fields carried by the variant."
+    attribute("tuple", nestedUnion("NestedTypeNode", "tupleTypeNode"), {
+      docs: ["The tuple of positional fields carried by the variant."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/EnumTypeNode.ts
 var enumTypeNode = defineNode("enumTypeNode", {
-  docs: "A tagged union: a numeric discriminator followed by one of several variant payloads.",
+  docs: ["A tagged union: a numeric discriminator followed by one of several variant payloads."],
   attributes: [
     attribute("variants", array(union("EnumVariantTypeNode")), {
-      docs: "The variants of the enum, in declaration order."
+      docs: ["The variants of the enum, in declaration order."]
     }),
-    attribute("size", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used to serialise the discriminator."
+    attribute("size", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used to serialise the discriminator."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/FixedSizeTypeNode.ts
 var fixedSizeTypeNode = defineNode("fixedSizeTypeNode", {
-  docs: "Wraps another type and asserts a fixed total byte size. Padding or truncation is applied as needed.",
+  docs: ["Wraps another type and asserts a fixed total byte size. Padding or truncation is applied as needed."],
   attributes: [
     attribute("size", u64(), {
-      docs: "The total byte size the wrapped type must occupy."
+      docs: ["The total byte size the wrapped type must occupy."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose serialisation is constrained."
+      docs: ["The wrapped type whose serialisation is constrained."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/HiddenPrefixTypeNode.ts
 var hiddenPrefixTypeNode = defineNode("hiddenPrefixTypeNode", {
-  docs: "Prefixes another type with a list of constant values that are written and read but not surfaced as fields to consumers.",
+  docs: [
+    "Prefixes another type with a list of constant values that are written and read but not surfaced as fields to consumers."
+  ],
   attributes: [
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose serialisation is preceded by the hidden prefix."
+      docs: ["The wrapped type whose serialisation is preceded by the hidden prefix."]
     }),
     attribute("prefix", array(node("constantValueNode")), {
-      docs: "The constant values written before the wrapped type, in order."
+      docs: ["The constant values written before the wrapped type, in order."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/HiddenSuffixTypeNode.ts
 var hiddenSuffixTypeNode = defineNode("hiddenSuffixTypeNode", {
-  docs: "Suffixes another type with a list of constant values that are written and read but not surfaced as fields to consumers.",
+  docs: [
+    "Suffixes another type with a list of constant values that are written and read but not surfaced as fields to consumers."
+  ],
   attributes: [
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose serialisation is followed by the hidden suffix."
+      docs: ["The wrapped type whose serialisation is followed by the hidden suffix."]
     }),
     attribute("suffix", array(node("constantValueNode")), {
-      docs: "The constant values written after the wrapped type, in order."
+      docs: ["The constant values written after the wrapped type, in order."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/MapTypeNode.ts
 var mapTypeNode = defineNode("mapTypeNode", {
-  docs: "A keyed map. The key and value types are described by their respective type nodes; the entry count is determined by a count strategy.",
+  docs: [
+    "A keyed map.",
+    "The key and value types are described by their respective type nodes; the entry count is determined by a count strategy."
+  ],
   attributes: [
     attribute("key", union("TypeNode"), {
-      docs: "The type of each entry key."
+      docs: ["The type of each entry key."]
     }),
     attribute("value", union("TypeNode"), {
-      docs: "The type of each entry value."
+      docs: ["The type of each entry value."]
     }),
     attribute("count", union("CountNode"), {
-      docs: "The strategy used to determine the number of entries."
+      docs: ["The strategy used to determine the number of entries."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/NumberTypeNode.ts
 var numberTypeNode = defineNode("numberTypeNode", {
-  docs: "A numeric type with a fixed wire format and byte order.",
+  docs: ["A numeric type with a fixed wire format and byte order."],
   attributes: [
     attribute("format", enumeration("NumberFormat"), {
-      docs: "The wire format used to serialise the number."
+      docs: ["The wire format used to serialise the number."]
     }),
     attribute("endian", enumeration("Endianness"), {
-      docs: "The byte order used to serialise the number."
+      docs: ["The byte order used to serialise the number."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/OptionTypeNode.ts
 var optionTypeNode = defineNode("optionTypeNode", {
-  docs: "A value that may be present or absent (Some/None), with an explicit numeric prefix indicating presence.",
+  docs: ["A value that may be present or absent (Some/None), with an explicit numeric prefix indicating presence."],
   attributes: [
     optionalAttribute("fixed", boolean(), {
-      docs: "When `true`, the absent variant still occupies the byte size of the present variant (zero-padded). Defaults to `false`."
+      docs: [
+        "When `true`, the absent variant still occupies the byte size of the present variant (zero-padded). Defaults to `false`."
+      ]
     }),
     attribute("item", union("TypeNode"), {
-      docs: "The type carried by the option when present."
+      docs: ["The type carried by the option when present."]
     }),
-    attribute("prefix", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used as the presence flag."
+    attribute("prefix", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used as the presence flag."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/PostOffsetTypeNode.ts
 var postOffsetTypeNode = defineNode("postOffsetTypeNode", {
-  docs: "After serialising the wrapped type, advance the cursor by `offset` bytes interpreted via the chosen strategy.",
+  docs: [
+    "After serialising the wrapped type, advance the cursor by `offset` bytes interpreted via the chosen strategy."
+  ],
   attributes: [
     attribute("offset", i64(), {
-      docs: "The signed byte offset to apply after the wrapped type runs."
+      docs: ["The signed byte offset to apply after the wrapped type runs."]
     }),
     attribute("strategy", enumeration("PostOffsetStrategy"), {
-      docs: "How the `offset` value is interpreted."
+      docs: ["How the `offset` value is interpreted."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose serialisation is followed by the offset."
+      docs: ["The wrapped type whose serialisation is followed by the offset."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/PreOffsetTypeNode.ts
 var preOffsetTypeNode = defineNode("preOffsetTypeNode", {
-  docs: "Before serialising the wrapped type, advance the cursor by `offset` bytes interpreted via the chosen strategy.",
+  docs: [
+    "Before serialising the wrapped type, advance the cursor by `offset` bytes interpreted via the chosen strategy."
+  ],
   attributes: [
     attribute("offset", i64(), {
-      docs: "The signed byte offset to apply before the wrapped type runs."
+      docs: ["The signed byte offset to apply before the wrapped type runs."]
     }),
     attribute("strategy", enumeration("PreOffsetStrategy"), {
-      docs: "How the `offset` value is interpreted."
+      docs: ["How the `offset` value is interpreted."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose serialisation is preceded by the offset."
+      docs: ["The wrapped type whose serialisation is preceded by the offset."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/PublicKeyTypeNode.ts
 var publicKeyTypeNode = defineNode("publicKeyTypeNode", {
-  docs: "A 32-byte Solana public key.",
+  docs: ["A 32-byte Solana public key."],
   attributes: []
 });
 
 // src/v1/nodes/typeNodes/RemainderOptionTypeNode.ts
 var remainderOptionTypeNode = defineNode("remainderOptionTypeNode", {
-  docs: "A value that may be present or absent. Presence is signalled by whether any bytes remain to be read, with no explicit prefix.",
+  docs: [
+    "A value that may be present or absent. Presence is signalled by whether any bytes remain to be read, with no explicit prefix."
+  ],
   attributes: [
     attribute("item", union("TypeNode"), {
-      docs: "The type carried by the option when present."
+      docs: ["The type carried by the option when present."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/SentinelTypeNode.ts
 var sentinelTypeNode = defineNode("sentinelTypeNode", {
-  docs: "Wraps another type and delimits it with a constant sentinel value written immediately after the wrapped type.",
+  docs: [
+    "Wraps another type and delimits it with a constant sentinel value written immediately after the wrapped type."
+  ],
   attributes: [
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose extent is delimited by the sentinel."
+      docs: ["The wrapped type whose extent is delimited by the sentinel."]
     }),
     attribute("sentinel", node("constantValueNode"), {
-      docs: "The constant value written immediately after the wrapped type to mark its end."
+      docs: ["The constant value written immediately after the wrapped type to mark its end."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/SetTypeNode.ts
 var setTypeNode = defineNode("setTypeNode", {
-  docs: "A unique-valued collection. The item type is defined by `item`; the size is determined by the `count` strategy.",
+  docs: [
+    "A unique-valued collection. The item type is defined by `item`; the size is determined by the `count` strategy."
+  ],
   attributes: [
     attribute("item", union("TypeNode"), {
-      docs: "The type of each item in the set."
+      docs: ["The type of each item in the set."]
     }),
     attribute("count", union("CountNode"), {
-      docs: "The strategy used to determine the number of items."
+      docs: ["The strategy used to determine the number of items."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/SizePrefixTypeNode.ts
 var sizePrefixTypeNode = defineNode("sizePrefixTypeNode", {
-  docs: "Wraps another type with a numeric prefix indicating the byte length of the wrapped type.",
+  docs: ["Wraps another type with a numeric prefix indicating the byte length of the wrapped type."],
   attributes: [
     attribute("type", union("TypeNode"), {
-      docs: "The wrapped type whose serialisation is preceded by its size."
+      docs: ["The wrapped type whose serialisation is preceded by its size."]
     }),
-    attribute("prefix", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used as the size prefix."
+    attribute("prefix", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used as the size prefix."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/SolAmountTypeNode.ts
 var solAmountTypeNode = defineNode("solAmountTypeNode", {
-  docs: "A SOL amount expressed in lamports under the wrapped numeric type.",
+  docs: ["A SOL amount expressed in lamports under the wrapped numeric type."],
   attributes: [
-    attribute("number", nestedTypeNode("numberTypeNode"), {
-      docs: "The numeric type used to serialise the lamport amount."
+    attribute("number", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+      docs: ["The numeric type used to serialise the lamport amount."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/StringTypeNode.ts
 var stringTypeNode = defineNode("stringTypeNode", {
-  docs: "A string value. The encoding describes how its bytes are written; the byte length is determined by an enclosing wrapper such as `sizePrefixTypeNode` or `fixedSizeTypeNode`.",
+  docs: [
+    "A string value.",
+    "The encoding describes how its bytes are written.",
+    "The byte length is determined by an enclosing wrapper such as `sizePrefixTypeNode` or `fixedSizeTypeNode`."
+  ],
   attributes: [
     attribute("encoding", enumeration("BytesEncoding"), {
-      docs: "The byte encoding used to serialise the string."
+      docs: ["The byte encoding used to serialise the string."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/StructFieldTypeNode.ts
 var structFieldTypeNode = defineNode("structFieldTypeNode", {
-  docs: "A named field within a struct type.",
+  docs: ["A named field within a struct type."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the field."
+      docs: ["The name of the field."]
     }),
     optionalAttribute("defaultValueStrategy", enumeration("DefaultValueStrategy"), {
-      docs: "How a configured default value is exposed in generated APIs. Required when `defaultValue` is set."
+      docs: ["How a configured default value is exposed in generated APIs. Required when `defaultValue` is set."]
     }),
     optionalAttribute("docs", docs(), {
-      docs: "Markdown documentation for the field."
+      docs: ["Markdown documentation for the field."]
     }),
     attribute("type", union("TypeNode"), {
-      docs: "The type of the field."
+      docs: ["The type of the field."]
     }),
     optionalAttribute("defaultValue", union("ValueNode"), {
-      docs: "A default value used when the field is omitted by callers."
+      docs: ["A default value used when the field is omitted by callers."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/StructTypeNode.ts
 var structTypeNode = defineNode("structTypeNode", {
-  docs: "A composite type made of an ordered list of named fields. Fields are encoded and decoded in declaration order.",
+  docs: [
+    "A composite type made of an ordered list of named fields. Fields are encoded and decoded in declaration order."
+  ],
   attributes: [
     attribute("fields", array(node("structFieldTypeNode")), {
-      docs: "The fields of the struct, in declaration order."
+      docs: ["The fields of the struct, in declaration order."]
     })
   ]
 });
 
 // src/v1/nodes/typeNodes/TupleTypeNode.ts
 var tupleTypeNode = defineNode("tupleTypeNode", {
-  docs: "A heterogeneous fixed-length sequence in which each positional slot has its own type.",
+  docs: ["A heterogeneous fixed-length sequence in which each positional slot has its own type."],
   attributes: [
     attribute("items", array(union("TypeNode")), {
-      docs: "The type of each positional slot, in order."
+      docs: ["The type of each positional slot, in order."]
     })
   ]
 });
@@ -1530,31 +1685,33 @@ var STANDALONE_TYPE_NODE_KINDS = [
   "zeroableOptionTypeNode"
 ];
 var standaloneTypeNodeUnion = defineUnion("StandaloneTypeNode", {
-  docs: "Every type node that can be used as a top-level type.",
+  docs: ["Every type node that can be used as a top-level type."],
   members: [...STANDALONE_TYPE_NODE_KINDS]
 });
 var enumVariantTypeNodeUnion = defineUnion("EnumVariantTypeNode", {
-  docs: "The variant flavours of an `enumTypeNode`.",
+  docs: ["The variant flavours of an `enumTypeNode`."],
   members: ["enumEmptyVariantTypeNode", "enumStructVariantTypeNode", "enumTupleVariantTypeNode"]
 });
 var typeNodeUnion = defineUnion("TypeNode", {
-  docs: "The composable form: any standalone type, or a reference to a defined type via `definedTypeLinkNode`.",
+  docs: ["The composable form: any standalone type, or a reference to a defined type via `definedTypeLinkNode`."],
   members: [union("StandaloneTypeNode"), "definedTypeLinkNode"]
 });
 var registeredTypeNodeUnion = defineUnion("RegisteredTypeNode", {
-  docs: "Every node tagged as a type-shaped node, including variants and struct fields.",
+  docs: ["Every node tagged as a type-shaped node, including variants and struct fields."],
   members: [union("StandaloneTypeNode"), union("EnumVariantTypeNode"), "structFieldTypeNode"]
 });
 
 // src/v1/nodes/typeNodes/ZeroableOptionTypeNode.ts
 var zeroableOptionTypeNode = defineNode("zeroableOptionTypeNode", {
-  docs: "An optional value whose absence is signalled by a designated zero value rather than a presence flag.",
+  docs: ["An optional value whose absence is signalled by a designated zero value rather than a presence flag."],
   attributes: [
     attribute("item", union("TypeNode"), {
-      docs: "The type carried by the option when present."
+      docs: ["The type carried by the option when present."]
     }),
     optionalAttribute("zeroValue", node("constantValueNode"), {
-      docs: "The constant value that signals absence. When omitted, the all-zero byte pattern of the item type is used."
+      docs: [
+        "The constant value that signals absence. When omitted, the all-zero byte pattern of the item type is used."
+      ]
     })
   ]
 });
@@ -1599,177 +1756,183 @@ var ALL_TYPE_NODE_UNIONS = [
 
 // src/v1/nodes/valueNodes/ArrayValueNode.ts
 var arrayValueNode = defineNode("arrayValueNode", {
-  docs: "A concrete array value: a list of value nodes.",
+  docs: ["A concrete array value: a list of value nodes."],
   attributes: [
     attribute("items", array(union("ValueNode")), {
-      docs: "The items of the array, in order."
+      docs: ["The items of the array, in order."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/BooleanValueNode.ts
 var booleanValueNode = defineNode("booleanValueNode", {
-  docs: "A concrete boolean value.",
+  docs: ["A concrete boolean value."],
   attributes: [
     attribute("boolean", boolean(), {
-      docs: "The boolean value."
+      docs: ["The boolean value."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/BytesValueNode.ts
 var bytesValueNode = defineNode("bytesValueNode", {
-  docs: "A concrete bytes value, encoded as text in the chosen encoding.",
+  docs: ["A concrete bytes value, encoded as text in the chosen encoding."],
   attributes: [
     attribute("data", string(), {
-      docs: "The bytes encoded as a text string per the `encoding` attribute."
+      docs: ["The bytes encoded as a text string per the `encoding` attribute."]
     }),
     attribute("encoding", enumeration("BytesEncoding"), {
-      docs: "The encoding used to represent the bytes as text."
+      docs: ["The encoding used to represent the bytes as text."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/ConstantValueNode.ts
 var constantValueNode = defineNode("constantValueNode", {
-  docs: "A typed constant: a type node paired with a concrete value node.",
+  docs: ["A typed constant: a type node paired with a concrete value node."],
   attributes: [
     attribute("type", union("TypeNode"), {
-      docs: "The type of the constant."
+      docs: ["The type of the constant."]
     }),
     attribute("value", union("ValueNode"), {
-      docs: "The concrete value of the constant."
+      docs: ["The concrete value of the constant."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/EnumValueNode.ts
 var enumValueNode = defineNode("enumValueNode", {
-  docs: "A concrete value of a defined enum: a variant identifier plus an optional payload.",
+  docs: ["A concrete value of a defined enum: a variant identifier plus an optional payload."],
   attributes: [
     attribute("variant", stringIdentifier(), {
-      docs: "The name of the selected variant."
+      docs: ["The name of the selected variant."]
     }),
     attribute("enum", node("definedTypeLinkNode"), {
-      docs: "A link to the defined enum type the value belongs to."
+      docs: ["A link to the defined enum type the value belongs to."]
     }),
     optionalAttribute("value", union("EnumValuePayload"), {
-      docs: "The variant payload \u2014 a struct value for struct variants or a tuple value for tuple variants. Omitted for unit variants."
+      docs: [
+        "The variant payload \u2014 a struct value for struct variants or a tuple value for tuple variants.",
+        "Omitted for unit variants."
+      ]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/MapEntryValueNode.ts
 var mapEntryValueNode = defineNode("mapEntryValueNode", {
-  docs: "A single (key, value) pair inside a `mapValueNode`.",
+  docs: ["A single (key, value) pair inside a `mapValueNode`."],
   attributes: [
     attribute("key", union("ValueNode"), {
-      docs: "The entry key."
+      docs: ["The entry key."]
     }),
     attribute("value", union("ValueNode"), {
-      docs: "The entry value."
+      docs: ["The entry value."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/MapValueNode.ts
 var mapValueNode = defineNode("mapValueNode", {
-  docs: "A concrete map value: a list of (key, value) entries.",
+  docs: ["A concrete map value: a list of (key, value) entries."],
   attributes: [
     attribute("entries", array(node("mapEntryValueNode")), {
-      docs: "The entries of the map, in order."
+      docs: ["The entries of the map, in order."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/NoneValueNode.ts
 var noneValueNode = defineNode("noneValueNode", {
-  docs: 'The "absent" value for an optional type.',
+  docs: ['The "absent" value for an optional type.'],
   attributes: []
 });
 
 // src/v1/nodes/valueNodes/NumberValueNode.ts
 var numberValueNode = defineNode("numberValueNode", {
-  docs: "A concrete numeric value. Stored as a 64-bit float; consumers narrow to a specific integer or float width based on the surrounding type context.",
+  docs: [
+    "A concrete numeric value.",
+    "Stored as a 64-bit float; consumers narrow to a specific integer or float width based on the surrounding type context."
+  ],
   attributes: [
     attribute("number", f64(), {
-      docs: "The numeric value."
+      docs: ["The numeric value."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/PublicKeyValueNode.ts
 var publicKeyValueNode = defineNode("publicKeyValueNode", {
-  docs: "A concrete public key, with an optional symbolic identifier for the address.",
+  docs: ["A concrete public key, with an optional symbolic identifier for the address."],
   attributes: [
     attribute("publicKey", string(), {
-      docs: "The base58-encoded public key."
+      docs: ["The base58-encoded public key."]
     }),
     optionalAttribute("identifier", stringIdentifier(), {
-      docs: "A symbolic name for the address, useful in generated client code."
+      docs: ["A symbolic name for the address, useful in generated client code."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/SetValueNode.ts
 var setValueNode = defineNode("setValueNode", {
-  docs: "A concrete set value: a list of unique value nodes.",
+  docs: ["A concrete set value: a list of unique value nodes."],
   attributes: [
     attribute("items", array(union("ValueNode")), {
-      docs: "The items of the set."
+      docs: ["The items of the set."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/SomeValueNode.ts
 var someValueNode = defineNode("someValueNode", {
-  docs: 'The "present" value for an optional type, wrapping a concrete value node.',
+  docs: ['The "present" value for an optional type, wrapping a concrete value node.'],
   attributes: [
     attribute("value", union("ValueNode"), {
-      docs: "The wrapped value."
+      docs: ["The wrapped value."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/StringValueNode.ts
 var stringValueNode = defineNode("stringValueNode", {
-  docs: "A concrete string value.",
+  docs: ["A concrete string value."],
   attributes: [
     attribute("string", string(), {
-      docs: "The string value."
+      docs: ["The string value."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/StructFieldValueNode.ts
 var structFieldValueNode = defineNode("structFieldValueNode", {
-  docs: "A named field of a `structValueNode`.",
+  docs: ["A named field of a `structValueNode`."],
   attributes: [
     attribute("name", stringIdentifier(), {
-      docs: "The name of the field."
+      docs: ["The name of the field."]
     }),
     attribute("value", union("ValueNode"), {
-      docs: "The concrete value of the field."
+      docs: ["The concrete value of the field."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/StructValueNode.ts
 var structValueNode = defineNode("structValueNode", {
-  docs: "A concrete struct value: a list of named field values.",
+  docs: ["A concrete struct value: a list of named field values."],
   attributes: [
     attribute("fields", array(node("structFieldValueNode")), {
-      docs: "The named fields of the struct value."
+      docs: ["The named fields of the struct value."]
     })
   ]
 });
 
 // src/v1/nodes/valueNodes/TupleValueNode.ts
 var tupleValueNode = defineNode("tupleValueNode", {
-  docs: "A concrete tuple value: a fixed-length sequence of positional value nodes.",
+  docs: ["A concrete tuple value: a fixed-length sequence of positional value nodes."],
   attributes: [
     attribute("items", array(union("ValueNode")), {
-      docs: "The positional items of the tuple, in order."
+      docs: ["The positional items of the tuple, in order."]
     })
   ]
 });
@@ -1792,19 +1955,19 @@ var STANDALONE_VALUE_NODE_KINDS = [
   "tupleValueNode"
 ];
 var standaloneValueNodeUnion = defineUnion("StandaloneValueNode", {
-  docs: "Every value node that can be used as a top-level value.",
+  docs: ["Every value node that can be used as a top-level value."],
   members: [...STANDALONE_VALUE_NODE_KINDS]
 });
 var valueNodeUnion = defineUnion("ValueNode", {
-  docs: "The composable form: any standalone value node.",
+  docs: ["The composable form: any standalone value node."],
   members: [union("StandaloneValueNode")]
 });
 var registeredValueNodeUnion = defineUnion("RegisteredValueNode", {
-  docs: "Every node tagged as a value-shaped node, including container variants.",
+  docs: ["Every node tagged as a value-shaped node, including container variants."],
   members: [union("StandaloneValueNode"), "mapEntryValueNode", "structFieldValueNode"]
 });
 var enumValuePayloadUnion = defineUnion("EnumValuePayload", {
-  docs: "The payload kinds an `enumValueNode` may carry \u2014 struct fields or positional tuple slots.",
+  docs: ["The payload kinds an `enumValueNode` may carry \u2014 struct fields or positional tuple slots."],
   members: ["structValueNode", "tupleValueNode"]
 });
 
@@ -1834,55 +1997,87 @@ var ALL_VALUE_NODE_UNIONS = [
   enumValuePayloadUnion
 ];
 
-// src/v1/nodes/index.ts
-var ALL_NODES = [
-  ...ALL_TYPE_NODES,
-  ...ALL_VALUE_NODES,
-  ...ALL_LINK_NODES,
-  ...ALL_PDA_SEED_NODES,
-  ...ALL_COUNT_NODES,
-  ...ALL_DISCRIMINATOR_NODES,
-  ...ALL_CONTEXTUAL_VALUE_NODES,
-  // Top-level nodes — directly under `nodes/`, no subdirectory.
-  accountNode,
-  constantNode,
-  definedTypeNode,
-  errorNode,
-  eventNode,
-  instructionAccountNode,
-  instructionArgumentNode,
-  instructionByteDeltaNode,
-  instructionNode,
-  instructionRemainingAccountsNode,
-  instructionStatusNode,
-  pdaNode,
-  programNode,
-  rootNode
-];
-var ALL_UNIONS = [
-  ...ALL_TYPE_NODE_UNIONS,
-  ...ALL_VALUE_NODE_UNIONS,
-  ...ALL_LINK_NODE_UNIONS,
-  ...ALL_PDA_SEED_NODE_UNIONS,
-  ...ALL_COUNT_NODE_UNIONS,
-  ...ALL_DISCRIMINATOR_NODE_UNIONS,
-  ...ALL_CONTEXTUAL_VALUE_NODE_UNIONS,
-  // Inline-helper unions used by instruction-shaped nodes.
-  instructionByteDeltaValueUnion,
-  instructionRemainingAccountsValueUnion
-];
-
 // src/v1/index.ts
 var SPEC_VERSION = "1.6.0";
+var TYPE_CATEGORY = defineCategory("type", {
+  docs: ["Type nodes \u2014 the building blocks of every value shape."],
+  nestedUnions: [nestedTypeNode],
+  nodes: [...ALL_TYPE_NODES],
+  unions: [...ALL_TYPE_NODE_UNIONS]
+});
+var VALUE_CATEGORY = defineCategory("value", {
+  docs: ["Value nodes \u2014 concrete values whose shape is described by a type node."],
+  nodes: [...ALL_VALUE_NODES],
+  unions: [...ALL_VALUE_NODE_UNIONS]
+});
+var LINK_CATEGORY = defineCategory("link", {
+  docs: ["Link nodes \u2014 references to other named entities (programs, PDAs, accounts, \u2026)."],
+  nodes: [...ALL_LINK_NODES],
+  unions: [...ALL_LINK_NODE_UNIONS]
+});
+var PDA_SEED_CATEGORY = defineCategory("pdaSeed", {
+  docs: ["PDA-seed nodes \u2014 the constants and variables a program uses to derive PDAs."],
+  nodes: [...ALL_PDA_SEED_NODES],
+  unions: [...ALL_PDA_SEED_NODE_UNIONS]
+});
+var COUNT_CATEGORY = defineCategory("count", {
+  docs: ["Count nodes \u2014 strategies for sizing a homogeneous collection in serialized form."],
+  nodes: [...ALL_COUNT_NODES],
+  unions: [...ALL_COUNT_NODE_UNIONS]
+});
+var DISCRIMINATOR_CATEGORY = defineCategory("discriminator", {
+  docs: ["Discriminator nodes \u2014 strategies for distinguishing one account or instruction from another."],
+  nodes: [...ALL_DISCRIMINATOR_NODES],
+  unions: [...ALL_DISCRIMINATOR_NODE_UNIONS]
+});
+var CONTEXTUAL_VALUE_CATEGORY = defineCategory("contextualValue", {
+  docs: [
+    "Contextual-value nodes \u2014 references resolved at instruction-build time (account values, argument values, \u2026)."
+  ],
+  nodes: [...ALL_CONTEXTUAL_VALUE_NODES],
+  unions: [...ALL_CONTEXTUAL_VALUE_NODE_UNIONS]
+});
+var SHARED_CATEGORY = defineCategory("shared", {
+  docs: ["Shared enumerations referenced from multiple node categories."],
+  enumerations: [...ALL_ENUMERATIONS]
+});
+var TOP_LEVEL_CATEGORY = defineCategory("topLevel", {
+  docs: ["Top-level nodes and helper unions \u2014 the entry points of any Codama IDL."],
+  nodes: [
+    accountNode,
+    constantNode,
+    definedTypeNode,
+    errorNode,
+    eventNode,
+    instructionAccountNode,
+    instructionArgumentNode,
+    instructionByteDeltaNode,
+    instructionNode,
+    instructionRemainingAccountsNode,
+    instructionStatusNode,
+    pdaNode,
+    programNode,
+    rootNode
+  ],
+  unions: [instructionByteDeltaValueUnion, instructionRemainingAccountsValueUnion]
+});
+var ALL_CATEGORIES = [
+  TYPE_CATEGORY,
+  VALUE_CATEGORY,
+  LINK_CATEGORY,
+  PDA_SEED_CATEGORY,
+  COUNT_CATEGORY,
+  DISCRIMINATOR_CATEGORY,
+  CONTEXTUAL_VALUE_CATEGORY,
+  SHARED_CATEGORY,
+  TOP_LEVEL_CATEGORY
+];
 var cached;
 function getSpec() {
   if (cached) return cached;
   const built = {
     version: SPEC_VERSION,
-    enumerations: ALL_ENUMERATIONS,
-    nodes: ALL_NODES,
-    unions: ALL_UNIONS,
-    nestedTypeNodeWrappers: NESTED_TYPE_NODE_WRAPPERS
+    categories: ALL_CATEGORIES
   };
   const errors = validate(built);
   if (errors.length > 0) {
@@ -1893,13 +2088,25 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   return cached;
 }
 function getNode(kind) {
-  return getSpec().nodes.find((n) => n.kind === kind);
+  for (const c of getSpec().categories) {
+    const found = c.nodes.find((n) => n.kind === kind);
+    if (found) return found;
+  }
+  return void 0;
 }
 function getUnion(name) {
-  return getSpec().unions.find((u) => u.name === name);
+  for (const c of getSpec().categories) {
+    const found = c.unions.find((u) => u.name === name);
+    if (found) return found;
+  }
+  return void 0;
 }
 function getEnumeration(name) {
-  return getSpec().enumerations.find((e) => e.name === name);
+  for (const c of getSpec().categories) {
+    const found = c.enumerations.find((e) => e.name === name);
+    if (found) return found;
+  }
+  return void 0;
 }
 
 export { SPEC_VERSION, getEnumeration, getNode, getSpec, getUnion, isChildAttribute };