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

package/dist/index.browser.cjs

@@ -96,6 +96,9 @@ function normaliseMember(input) {
 }
 
 // src/api/primitives.ts
+function address() {
+  return Object.freeze({ kind: "address" });
+}
 function string() {
   return Object.freeze({ kind: "string" });
 }
@@ -155,6 +158,8 @@ function docs() {
 }
 
 // src/api/validate.ts
+var CAMEL_CASE_REGEX = /^[a-z][A-Za-z0-9]*$/;
+var NODE_KIND_REGEX = /^[a-z][A-Za-z0-9]*Node$/;
 function validate(spec) {
   const errors = [];
   const allNodes = [];
@@ -192,7 +197,7 @@ function validate(spec) {
     seenCategories.add(c.name);
   }
   for (const n of allNodes) {
-    if (!/^[a-z][A-Za-z0-9]*Node$/.test(n.kind)) {
+    if (!NODE_KIND_REGEX.test(n.kind)) {
       errors.push(`Node kind "${n.kind}" does not match the camelCase ...Node naming convention.`);
     }
     const seenAttrs = /* @__PURE__ */ new Set();
@@ -208,6 +213,9 @@ function validate(spec) {
     }
   }
   for (const u of allUnions) {
+    if (!CAMEL_CASE_REGEX.test(u.name)) {
+      errors.push(`Union "${u.name}" does not match the camelCase naming convention.`);
+    }
     if (u.members.length === 0) {
       errors.push(`Union "${u.name}" has no members.`);
     }
@@ -226,7 +234,15 @@ function validate(spec) {
       }
     }
   }
+  for (const e of allEnumerations) {
+    if (!CAMEL_CASE_REGEX.test(e.name)) {
+      errors.push(`Enumeration "${e.name}" does not match the camelCase naming convention.`);
+    }
+  }
   for (const nu of allNestedUnions) {
+    if (!CAMEL_CASE_REGEX.test(nu.name)) {
+      errors.push(`Nested union "${nu.name}" does not match the camelCase naming convention.`);
+    }
     if (nu.wrappers.length === 0) {
       errors.push(`Nested union "${nu.name}" has no wrappers.`);
     }
@@ -296,14 +312,14 @@ function isChildAttribute(type) {
 }
 
 // src/v1/enumerations.ts
-var endianness = defineEnumeration("Endianness", {
+var endianness = defineEnumeration("endianness", {
   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."] })
   ]
 });
-var numberFormat = defineEnumeration("NumberFormat", {
+var numberFormat = defineEnumeration("numberFormat", {
   docs: ["The wire format of a numeric serialization."],
   variants: [
     variant("f32", { docs: ["IEEE-754 32-bit floating point."] }),
@@ -323,7 +339,7 @@ var numberFormat = defineEnumeration("NumberFormat", {
     variant("u128", { docs: ["Unsigned 128-bit integer."] })
   ]
 });
-var bytesEncoding = defineEnumeration("BytesEncoding", {
+var bytesEncoding = defineEnumeration("bytesEncoding", {
   docs: ["How a string of bytes is encoded for transport."],
   variants: [
     variant("base16", { docs: ["Hexadecimal encoding (two characters per byte)."] }),
@@ -332,7 +348,7 @@ var bytesEncoding = defineEnumeration("BytesEncoding", {
     variant("utf8", { docs: ["UTF-8 text encoding."] })
   ]
 });
-var instructionLifecycle = defineEnumeration("InstructionLifecycle", {
+var instructionLifecycle = defineEnumeration("instructionLifecycle", {
   docs: ["The lifecycle stage of an instruction."],
   variants: [
     variant("archived", {
@@ -347,7 +363,7 @@ var instructionLifecycle = defineEnumeration("InstructionLifecycle", {
     variant("live", { docs: ["Stable and supported for production use."] })
   ]
 });
-var defaultValueStrategy = defineEnumeration("DefaultValueStrategy", {
+var defaultValueStrategy = defineEnumeration("defaultValueStrategy", {
   docs: ["How an attribute that carries a default value is exposed in generated APIs."],
   variants: [
     variant("omitted", {
@@ -360,7 +376,7 @@ var defaultValueStrategy = defineEnumeration("DefaultValueStrategy", {
     })
   ]
 });
-var optionalAccountStrategy = defineEnumeration("OptionalAccountStrategy", {
+var optionalAccountStrategy = defineEnumeration("optionalAccountStrategy", {
   docs: ["How an absent optional account is represented when serialising an instruction."],
   variants: [
     variant("omitted", {
@@ -371,7 +387,7 @@ var optionalAccountStrategy = defineEnumeration("OptionalAccountStrategy", {
     })
   ]
 });
-var preOffsetStrategy = defineEnumeration("PreOffsetStrategy", {
+var preOffsetStrategy = defineEnumeration("preOffsetStrategy", {
   docs: ["How a pre-offset modifier interprets its offset value before serialising the wrapped type."],
   variants: [
     variant("absolute", {
@@ -385,7 +401,7 @@ var preOffsetStrategy = defineEnumeration("PreOffsetStrategy", {
     })
   ]
 });
-var postOffsetStrategy = defineEnumeration("PostOffsetStrategy", {
+var postOffsetStrategy = defineEnumeration("postOffsetStrategy", {
   docs: ["How a post-offset modifier interprets its offset value after serialising the wrapped type."],
   variants: [
     variant("absolute", {
@@ -402,7 +418,7 @@ var postOffsetStrategy = defineEnumeration("PostOffsetStrategy", {
     })
   ]
 });
-var programOrigin = defineEnumeration("ProgramOrigin", {
+var programOrigin = defineEnumeration("programOrigin", {
   docs: ["The toolchain that originally generated a program description."],
   variants: [
     variant("anchor", { docs: ["The program was originally described by an Anchor IDL."] }),
@@ -422,12 +438,12 @@ var ALL_ENUMERATIONS = [
 ];
 
 // src/v1/nestedUnions.ts
-var nestedTypeNode = defineNestedUnion("NestedTypeNode", {
+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."
+    "The wrapping is recursive: each modifier wraps another `nestedTypeNode<T>` until the inner `T` is reached."
   ],
-  base: union("TypeNode"),
+  base: union("typeNode"),
   wrappers: [
     "fixedSizeTypeNode",
     "sizePrefixTypeNode",
@@ -454,13 +470,13 @@ var accountNode = defineNode("accountNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the account."]
     }),
-    attribute("data", nestedUnion("NestedTypeNode", "structTypeNode"), {
+    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."]
     }),
-    optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
+    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."
@@ -479,10 +495,10 @@ var constantNode = defineNode("constantNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the constant."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The type of the constant."]
     }),
-    attribute("value", union("ValueNode"), {
+    attribute("value", union("valueNode"), {
       docs: ["The concrete value of the constant."]
     })
   ]
@@ -525,19 +541,19 @@ var conditionalValueNode = defineNode("conditionalValueNode", {
     "The condition resolves to a value at instruction time; that result selects between `ifTrue` and `ifFalse`."
   ],
   attributes: [
-    attribute("condition", union("ConditionalValueCondition"), {
+    attribute("condition", union("conditionalValueCondition"), {
       docs: ["The value whose evaluation drives the branch."]
     }),
-    optionalAttribute("value", union("ValueNode"), {
+    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."
       ]
     }),
-    optionalAttribute("ifTrue", union("InstructionInputValueNode"), {
+    optionalAttribute("ifTrue", union("instructionInputValueNode"), {
       docs: ["The value used when the condition resolves truthy (or matches `value`)."]
     }),
-    optionalAttribute("ifFalse", union("InstructionInputValueNode"), {
+    optionalAttribute("ifFalse", union("instructionInputValueNode"), {
       docs: ["The value used when the condition resolves falsy (or does not match `value`)."]
     })
   ]
@@ -555,42 +571,42 @@ var STANDALONE_CONTEXTUAL_VALUE_NODE_KINDS = [
   "programIdValueNode",
   "resolverValueNode"
 ];
-var standaloneContextualValueNodeUnion = defineUnion("StandaloneContextualValueNode", {
+var standaloneContextualValueNodeUnion = defineUnion("standaloneContextualValueNode", {
   docs: ["Every contextual-value node usable as a top-level value."],
   members: [...STANDALONE_CONTEXTUAL_VALUE_NODE_KINDS]
 });
-var contextualValueNodeUnion = defineUnion("ContextualValueNode", {
+var contextualValueNodeUnion = defineUnion("contextualValueNode", {
   docs: ["The composable form: any standalone contextual-value node."],
-  members: [union("StandaloneContextualValueNode")]
+  members: [union("standaloneContextualValueNode")]
 });
-var registeredContextualValueNodeUnion = defineUnion("RegisteredContextualValueNode", {
+var registeredContextualValueNodeUnion = defineUnion("registeredContextualValueNode", {
   docs: ["Every node tagged as a contextual-value node, including helper variants."],
-  members: [union("StandaloneContextualValueNode"), "pdaSeedValueNode"]
+  members: [union("standaloneContextualValueNode"), "pdaSeedValueNode"]
 });
-var instructionInputValueNodeUnion = defineUnion("InstructionInputValueNode", {
+var instructionInputValueNodeUnion = defineUnion("instructionInputValueNode", {
   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")]
+  members: [union("contextualValueNode"), "programLinkNode", union("valueNode")]
 });
-var conditionalValueConditionUnion = defineUnion("ConditionalValueCondition", {
+var conditionalValueConditionUnion = defineUnion("conditionalValueCondition", {
   docs: ["The condition forms accepted by a `conditionalValueNode`."],
   members: ["accountValueNode", "argumentValueNode", "resolverValueNode"]
 });
-var resolverDependencyUnion = defineUnion("ResolverDependency", {
+var resolverDependencyUnion = defineUnion("resolverDependency", {
   docs: ["The dependency forms accepted by a `resolverValueNode`."],
   members: ["accountValueNode", "argumentValueNode"]
 });
-var pdaSeedValueValueUnion = defineUnion("PdaSeedValueValue", {
+var pdaSeedValueValueUnion = defineUnion("pdaSeedValueValue", {
   docs: ["The value forms accepted by a `pdaSeedValueNode`."],
-  members: ["accountValueNode", "argumentValueNode", union("ValueNode")]
+  members: ["accountValueNode", "argumentValueNode", union("valueNode")]
 });
-var pdaValuePdaUnion = defineUnion("PdaValuePda", {
+var pdaValuePdaUnion = defineUnion("pdaValuePda", {
   docs: ["A `pdaValueNode` may reference a PDA either by link or inline."],
   members: ["pdaLinkNode", "pdaNode"]
 });
-var pdaValueProgramIdUnion = defineUnion("PdaValueProgramId", {
+var pdaValueProgramIdUnion = defineUnion("pdaValueProgramId", {
   docs: ["The program-id forms accepted by a `pdaValueNode`."],
   members: ["accountValueNode", "argumentValueNode"]
 });
@@ -614,7 +630,7 @@ var pdaSeedValueNode = defineNode("pdaSeedValueNode", {
     attribute("name", stringIdentifier(), {
       docs: ["The name of the seed being filled in."]
     }),
-    attribute("value", union("PdaSeedValueValue"), {
+    attribute("value", union("pdaSeedValueValue"), {
       docs: ["The value to substitute for the seed."]
     })
   ]
@@ -624,13 +640,13 @@ var pdaSeedValueNode = defineNode("pdaSeedValueNode", {
 var pdaValueNode = defineNode("pdaValueNode", {
   docs: ["Resolves to a PDA derived from a list of seed values."],
   attributes: [
-    attribute("pda", union("PdaValuePda"), {
+    attribute("pda", union("pdaValuePda"), {
       docs: ["The PDA being derived \u2014 either a link to a defined PDA or an inline `pdaNode`."]
     }),
-    attribute("seeds", array(node("pdaSeedValueNode")), {
+    optionalAttribute("seeds", array(node("pdaSeedValueNode")), {
       docs: ["The seed values used to derive the PDA, paired with their seed names."]
     }),
-    optionalAttribute("programId", union("PdaValueProgramId"), {
+    optionalAttribute("programId", union("pdaValueProgramId"), {
       docs: ["The program ID used to derive the PDA. When omitted, the PDA\u2019s declared program is used."]
     })
   ]
@@ -655,7 +671,7 @@ var resolverValueNode = defineNode("resolverValueNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the resolver."]
     }),
-    optionalAttribute("dependsOn", array(union("ResolverDependency")), {
+    optionalAttribute("dependsOn", array(union("resolverDependency")), {
       docs: [
         "The accounts and arguments the resolver depends on. Used by clients to ensure the dependencies are resolved first."
       ]
@@ -689,13 +705,13 @@ var ALL_CONTEXTUAL_VALUE_NODE_UNIONS = [
 ];
 
 // src/v1/nodes/countNodes/CountNode.ts
-var registeredCountNodeUnion = defineUnion("RegisteredCountNode", {
+var registeredCountNodeUnion = defineUnion("registeredCountNode", {
   docs: ["Every node tagged as a count strategy."],
   members: ["fixedCountNode", "prefixedCountNode", "remainderCountNode"]
 });
-var countNodeUnion = defineUnion("CountNode", {
+var countNodeUnion = defineUnion("countNode", {
   docs: ["The composable form: any registered count node."],
-  members: [union("RegisteredCountNode")]
+  members: [union("registeredCountNode")]
 });
 
 // src/v1/nodes/countNodes/FixedCountNode.ts
@@ -712,7 +728,7 @@ var fixedCountNode = defineNode("fixedCountNode", {
 var prefixedCountNode = defineNode("prefixedCountNode", {
   docs: ["A count strategy where the number of items is read from a numeric prefix."],
   attributes: [
-    attribute("prefix", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("prefix", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used as the count prefix."]
     })
   ]
@@ -738,7 +754,7 @@ var definedTypeNode = defineNode("definedTypeNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the type."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The type definition."]
     })
   ]
@@ -758,13 +774,13 @@ var constantDiscriminatorNode = defineNode("constantDiscriminatorNode", {
 });
 
 // src/v1/nodes/discriminatorNodes/DiscriminatorNode.ts
-var registeredDiscriminatorNodeUnion = defineUnion("RegisteredDiscriminatorNode", {
+var registeredDiscriminatorNodeUnion = defineUnion("registeredDiscriminatorNode", {
   docs: ["Every node tagged as a discriminator strategy."],
   members: ["constantDiscriminatorNode", "fieldDiscriminatorNode", "sizeDiscriminatorNode"]
 });
-var discriminatorNodeUnion = defineUnion("DiscriminatorNode", {
+var discriminatorNodeUnion = defineUnion("discriminatorNode", {
   docs: ["The composable form: any registered discriminator node."],
-  members: [union("RegisteredDiscriminatorNode")]
+  members: [union("registeredDiscriminatorNode")]
 });
 
 // src/v1/nodes/discriminatorNodes/FieldDiscriminatorNode.ts
@@ -827,10 +843,10 @@ var eventNode = defineNode("eventNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the event."]
     }),
-    attribute("data", union("TypeNode"), {
+    attribute("data", union("typeNode"), {
       docs: ["The type describing the event payload."]
     }),
-    optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
+    optionalAttribute("discriminators", array(union("discriminatorNode")), {
       docs: [
         "Discriminators that distinguish this event from others. When multiple are listed, they are combined with a logical AND."
       ]
@@ -862,7 +878,7 @@ var instructionAccountNode = defineNode("instructionAccountNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the account slot."]
     }),
-    optionalAttribute("defaultValue", union("InstructionInputValueNode"), {
+    optionalAttribute("defaultValue", union("instructionInputValueNode"), {
       docs: ["A default value used to fill the slot when the caller does not provide one."]
     })
   ]
@@ -875,16 +891,16 @@ var instructionArgumentNode = defineNode("instructionArgumentNode", {
     attribute("name", stringIdentifier(), {
       docs: ["The name of the argument."]
     }),
-    optionalAttribute("defaultValueStrategy", enumeration("DefaultValueStrategy"), {
+    optionalAttribute("defaultValueStrategy", enumeration("defaultValueStrategy"), {
       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."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The type of the argument."]
     }),
-    optionalAttribute("defaultValue", union("InstructionInputValueNode"), {
+    optionalAttribute("defaultValue", union("instructionInputValueNode"), {
       docs: ["A default value used when the argument is omitted by callers."]
     })
   ]
@@ -902,7 +918,7 @@ var instructionByteDeltaNode = defineNode("instructionByteDeltaNode", {
     optionalAttribute("subtract", boolean(), {
       docs: ["When `true`, the delta is subtracted from the running size instead of added. Defaults to `false`."]
     }),
-    attribute("value", union("InstructionByteDeltaValue"), {
+    attribute("value", union("instructionByteDeltaValue"), {
       docs: [
         "The source of the delta value \u2014 a literal number, a referenced account or argument, or a resolver."
       ]
@@ -922,13 +938,13 @@ var instructionNode = defineNode("instructionNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the instruction."]
     }),
-    optionalAttribute("optionalAccountStrategy", enumeration("OptionalAccountStrategy"), {
+    optionalAttribute("optionalAccountStrategy", enumeration("optionalAccountStrategy"), {
       docs: ["How absent optional accounts are represented when serialising the instruction."]
     }),
-    attribute("accounts", array(node("instructionAccountNode")), {
+    optionalAttribute("accounts", array(node("instructionAccountNode")), {
       docs: ["The accounts the instruction operates on, in order."]
     }),
-    attribute("arguments", array(node("instructionArgumentNode")), {
+    optionalAttribute("arguments", array(node("instructionArgumentNode")), {
       docs: ["The serialised arguments of the instruction, in order."]
     }),
     optionalAttribute("extraArguments", array(node("instructionArgumentNode")), {
@@ -942,7 +958,7 @@ var instructionNode = defineNode("instructionNode", {
         "Byte-size adjustments applied when computing rent or buffer size \u2014 for instructions that resize accounts."
       ]
     }),
-    optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
+    optionalAttribute("discriminators", array(union("discriminatorNode")), {
       docs: [
         "Discriminators that distinguish this instruction from others.",
         "When multiple are listed, they are combined with a logical AND."
@@ -958,11 +974,11 @@ var instructionNode = defineNode("instructionNode", {
 });
 
 // src/v1/nodes/InstructionNodeUnions.ts
-var instructionByteDeltaValueUnion = defineUnion("InstructionByteDeltaValue", {
+var instructionByteDeltaValueUnion = defineUnion("instructionByteDeltaValue", {
   docs: ["The value forms accepted by an `instructionByteDeltaNode`."],
   members: ["accountLinkNode", "argumentValueNode", "numberValueNode", "resolverValueNode"]
 });
-var instructionRemainingAccountsValueUnion = defineUnion("InstructionRemainingAccountsValue", {
+var instructionRemainingAccountsValueUnion = defineUnion("instructionRemainingAccountsValue", {
   docs: ["The value forms accepted by an `instructionRemainingAccountsNode`."],
   members: ["argumentValueNode", "resolverValueNode"]
 });
@@ -986,7 +1002,7 @@ var instructionRemainingAccountsNode = defineNode("instructionRemainingAccountsN
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the remaining-accounts slot."]
     }),
-    attribute("value", union("InstructionRemainingAccountsValue"), {
+    attribute("value", union("instructionRemainingAccountsValue"), {
       docs: ["The source of the remaining-accounts list \u2014 a referenced argument or a resolver."]
     })
   ]
@@ -998,7 +1014,7 @@ var instructionStatusNode = defineNode("instructionStatusNode", {
     "The lifecycle stage of an instruction (draft, live, deprecated, archived) with an optional accompanying message."
   ],
   attributes: [
-    attribute("lifecycle", enumeration("InstructionLifecycle"), {
+    attribute("lifecycle", enumeration("instructionLifecycle"), {
       docs: ["The lifecycle stage."]
     }),
     optionalAttribute("message", string(), {
@@ -1079,7 +1095,7 @@ var instructionLinkNode = defineNode("instructionLinkNode", {
 });
 
 // src/v1/nodes/linkNodes/LinkNode.ts
-var registeredLinkNodeUnion = defineUnion("RegisteredLinkNode", {
+var registeredLinkNodeUnion = defineUnion("registeredLinkNode", {
   docs: ["Every node tagged as a link to another part of the IDL."],
   members: [
     "accountLinkNode",
@@ -1091,9 +1107,9 @@ var registeredLinkNodeUnion = defineUnion("RegisteredLinkNode", {
     "programLinkNode"
   ]
 });
-var linkNodeUnion = defineUnion("LinkNode", {
+var linkNodeUnion = defineUnion("linkNode", {
   docs: ["The composable form: any registered link node."],
-  members: [union("RegisteredLinkNode")]
+  members: [union("registeredLinkNode")]
 });
 
 // src/v1/nodes/linkNodes/PdaLinkNode.ts
@@ -1141,12 +1157,12 @@ var pdaNode = defineNode("pdaNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the PDA."]
     }),
-    optionalAttribute("programId", string(), {
+    optionalAttribute("programId", address(), {
       docs: [
         "The base58-encoded program ID used to derive the PDA. When omitted, the surrounding program is assumed."
       ]
     }),
-    attribute("seeds", array(union("PdaSeedNode")), {
+    optionalAttribute("seeds", array(union("pdaSeedNode")), {
       docs: ["The seeds used to derive the PDA, in order."]
     })
   ]
@@ -1156,27 +1172,27 @@ var pdaNode = defineNode("pdaNode", {
 var constantPdaSeedNode = defineNode("constantPdaSeedNode", {
   docs: ["A PDA seed with a constant value (e.g. a UTF-8 string or a fixed byte sequence)."],
   attributes: [
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The type of the seed value."]
     }),
-    attribute("value", union("ConstantPdaSeedValue"), {
+    attribute("value", union("constantPdaSeedValue"), {
       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", {
+var registeredPdaSeedNodeUnion = defineUnion("registeredPdaSeedNode", {
   docs: ["Every node tagged as a PDA seed."],
   members: ["constantPdaSeedNode", "variablePdaSeedNode"]
 });
-var pdaSeedNodeUnion = defineUnion("PdaSeedNode", {
+var pdaSeedNodeUnion = defineUnion("pdaSeedNode", {
   docs: ["The composable form: any registered PDA seed node."],
-  members: [union("RegisteredPdaSeedNode")]
+  members: [union("registeredPdaSeedNode")]
 });
-var constantPdaSeedValueUnion = defineUnion("ConstantPdaSeedValue", {
+var constantPdaSeedValueUnion = defineUnion("constantPdaSeedValue", {
   docs: ["The value forms a `constantPdaSeedNode` may carry \u2014 either a literal value or the program ID placeholder."],
-  members: ["programIdValueNode", union("ValueNode")]
+  members: ["programIdValueNode", union("valueNode")]
 });
 
 // src/v1/nodes/pdaSeedNodes/VariablePdaSeedNode.ts
@@ -1189,7 +1205,7 @@ var variablePdaSeedNode = defineNode("variablePdaSeedNode", {
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the seed variable."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The expected type of the seed value."]
     })
   ]
@@ -1212,37 +1228,37 @@ var programNode = defineNode("programNode", {
     attribute("name", stringIdentifier(), {
       docs: ["The name of the program."]
     }),
-    attribute("publicKey", string(), {
+    attribute("publicKey", address(), {
       docs: ["The base58-encoded program ID."]
     }),
     attribute("version", stringVersion(), {
       docs: ["The version of the program, in semver form."]
     }),
-    optionalAttribute("origin", enumeration("ProgramOrigin"), {
+    optionalAttribute("origin", enumeration("programOrigin"), {
       docs: ["The toolchain that originally generated the program description, if known."]
     }),
     optionalAttribute("docs", docs(), {
       docs: ["Markdown documentation for the program."]
     }),
-    attribute("accounts", array(node("accountNode")), {
+    optionalAttribute("accounts", array(node("accountNode")), {
       docs: ["The accounts owned by the program."]
     }),
-    attribute("instructions", array(node("instructionNode")), {
+    optionalAttribute("instructions", array(node("instructionNode")), {
       docs: ["The instructions exposed by the program."]
     }),
-    attribute("definedTypes", array(node("definedTypeNode")), {
+    optionalAttribute("definedTypes", array(node("definedTypeNode")), {
       docs: ["The reusable types defined by the program."]
     }),
-    attribute("pdas", array(node("pdaNode")), {
+    optionalAttribute("pdas", array(node("pdaNode")), {
       docs: ["The PDAs derived by the program."]
     }),
-    attribute("events", array(node("eventNode")), {
+    optionalAttribute("events", array(node("eventNode")), {
       docs: ["The events emitted by the program."]
     }),
-    attribute("errors", array(node("errorNode")), {
+    optionalAttribute("errors", array(node("errorNode")), {
       docs: ["The errors returned by the program."]
     }),
-    attribute("constants", array(node("constantNode")), {
+    optionalAttribute("constants", array(node("constantNode")), {
       docs: ["The constants exposed by the program."]
     })
   ]
@@ -1264,7 +1280,7 @@ var rootNode = defineNode("rootNode", {
     attribute("program", node("programNode"), {
       docs: ["The primary program described by the document."]
     }),
-    attribute("additionalPrograms", array(node("programNode")), {
+    optionalAttribute("additionalPrograms", array(node("programNode")), {
       docs: ["Additional programs referenced by the primary program."]
     })
   ]
@@ -1286,7 +1302,7 @@ var amountTypeNode = defineNode("amountTypeNode", {
     optionalAttribute("unit", string(), {
       docs: ['The unit of the amount \u2014 e.g. "USD" or "%".']
     }),
-    attribute("number", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("number", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The number type the amount wraps."]
     })
   ]
@@ -1298,10 +1314,10 @@ var arrayTypeNode = defineNode("arrayTypeNode", {
     "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"), {
+    attribute("item", union("typeNode"), {
       docs: ["The type of each item in the array."]
     }),
-    attribute("count", union("CountNode"), {
+    attribute("count", union("countNode"), {
       docs: ["The strategy used to determine the number of items."]
     })
   ]
@@ -1311,7 +1327,7 @@ var arrayTypeNode = defineNode("arrayTypeNode", {
 var booleanTypeNode = defineNode("booleanTypeNode", {
   docs: ["A boolean serialised as a numeric value. The wrapped number type determines the byte width."],
   attributes: [
-    attribute("size", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("size", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used to serialise the boolean."]
     })
   ]
@@ -1331,7 +1347,7 @@ var dateTimeTypeNode = defineNode("dateTimeTypeNode", {
     "A timestamp encoded as a number, typically seconds since the Unix epoch. The wrapped number type determines the byte width."
   ],
   attributes: [
-    attribute("number", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("number", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used to serialise the timestamp."]
     })
   ]
@@ -1364,7 +1380,7 @@ var enumStructVariantTypeNode = defineNode("enumStructVariantTypeNode", {
         "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
       ]
     }),
-    attribute("struct", nestedUnion("NestedTypeNode", "structTypeNode"), {
+    attribute("struct", nestedUnion("nestedTypeNode", "structTypeNode"), {
       docs: ["The struct of named fields carried by the variant."]
     })
   ]
@@ -1382,7 +1398,7 @@ var enumTupleVariantTypeNode = defineNode("enumTupleVariantTypeNode", {
         "Explicit discriminator value. When omitted, the discriminator is inferred from the variant position."
       ]
     }),
-    attribute("tuple", nestedUnion("NestedTypeNode", "tupleTypeNode"), {
+    attribute("tuple", nestedUnion("nestedTypeNode", "tupleTypeNode"), {
       docs: ["The tuple of positional fields carried by the variant."]
     })
   ]
@@ -1392,10 +1408,10 @@ var enumTupleVariantTypeNode = defineNode("enumTupleVariantTypeNode", {
 var enumTypeNode = defineNode("enumTypeNode", {
   docs: ["A tagged union: a numeric discriminator followed by one of several variant payloads."],
   attributes: [
-    attribute("variants", array(union("EnumVariantTypeNode")), {
+    attribute("variants", array(union("enumVariantTypeNode")), {
       docs: ["The variants of the enum, in declaration order."]
     }),
-    attribute("size", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("size", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used to serialise the discriminator."]
     })
   ]
@@ -1408,7 +1424,7 @@ var fixedSizeTypeNode = defineNode("fixedSizeTypeNode", {
     attribute("size", u64(), {
       docs: ["The total byte size the wrapped type must occupy."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose serialisation is constrained."]
     })
   ]
@@ -1420,7 +1436,7 @@ var hiddenPrefixTypeNode = defineNode("hiddenPrefixTypeNode", {
     "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"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose serialisation is preceded by the hidden prefix."]
     }),
     attribute("prefix", array(node("constantValueNode")), {
@@ -1435,7 +1451,7 @@ var hiddenSuffixTypeNode = defineNode("hiddenSuffixTypeNode", {
     "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"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose serialisation is followed by the hidden suffix."]
     }),
     attribute("suffix", array(node("constantValueNode")), {
@@ -1451,13 +1467,13 @@ var mapTypeNode = defineNode("mapTypeNode", {
     "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"), {
+    attribute("key", union("typeNode"), {
       docs: ["The type of each entry key."]
     }),
-    attribute("value", union("TypeNode"), {
+    attribute("value", union("typeNode"), {
       docs: ["The type of each entry value."]
     }),
-    attribute("count", union("CountNode"), {
+    attribute("count", union("countNode"), {
       docs: ["The strategy used to determine the number of entries."]
     })
   ]
@@ -1467,10 +1483,10 @@ var mapTypeNode = defineNode("mapTypeNode", {
 var numberTypeNode = defineNode("numberTypeNode", {
   docs: ["A numeric type with a fixed wire format and byte order."],
   attributes: [
-    attribute("format", enumeration("NumberFormat"), {
+    attribute("format", enumeration("numberFormat"), {
       docs: ["The wire format used to serialise the number."]
     }),
-    attribute("endian", enumeration("Endianness"), {
+    attribute("endian", enumeration("endianness"), {
       docs: ["The byte order used to serialise the number."]
     })
   ]
@@ -1485,10 +1501,10 @@ var optionTypeNode = defineNode("optionTypeNode", {
         "When `true`, the absent variant still occupies the byte size of the present variant (zero-padded). Defaults to `false`."
       ]
     }),
-    attribute("item", union("TypeNode"), {
+    attribute("item", union("typeNode"), {
       docs: ["The type carried by the option when present."]
     }),
-    attribute("prefix", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("prefix", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used as the presence flag."]
     })
   ]
@@ -1503,10 +1519,10 @@ var postOffsetTypeNode = defineNode("postOffsetTypeNode", {
     attribute("offset", i64(), {
       docs: ["The signed byte offset to apply after the wrapped type runs."]
     }),
-    attribute("strategy", enumeration("PostOffsetStrategy"), {
+    attribute("strategy", enumeration("postOffsetStrategy"), {
       docs: ["How the `offset` value is interpreted."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose serialisation is followed by the offset."]
     })
   ]
@@ -1521,10 +1537,10 @@ var preOffsetTypeNode = defineNode("preOffsetTypeNode", {
     attribute("offset", i64(), {
       docs: ["The signed byte offset to apply before the wrapped type runs."]
     }),
-    attribute("strategy", enumeration("PreOffsetStrategy"), {
+    attribute("strategy", enumeration("preOffsetStrategy"), {
       docs: ["How the `offset` value is interpreted."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose serialisation is preceded by the offset."]
     })
   ]
@@ -1542,7 +1558,7 @@ var remainderOptionTypeNode = defineNode("remainderOptionTypeNode", {
     "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"), {
+    attribute("item", union("typeNode"), {
       docs: ["The type carried by the option when present."]
     })
   ]
@@ -1554,7 +1570,7 @@ var sentinelTypeNode = defineNode("sentinelTypeNode", {
     "Wraps another type and delimits it with a constant sentinel value written immediately after the wrapped type."
   ],
   attributes: [
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose extent is delimited by the sentinel."]
     }),
     attribute("sentinel", node("constantValueNode"), {
@@ -1569,10 +1585,10 @@ var setTypeNode = defineNode("setTypeNode", {
     "A unique-valued collection. The item type is defined by `item`; the size is determined by the `count` strategy."
   ],
   attributes: [
-    attribute("item", union("TypeNode"), {
+    attribute("item", union("typeNode"), {
       docs: ["The type of each item in the set."]
     }),
-    attribute("count", union("CountNode"), {
+    attribute("count", union("countNode"), {
       docs: ["The strategy used to determine the number of items."]
     })
   ]
@@ -1582,10 +1598,10 @@ var setTypeNode = defineNode("setTypeNode", {
 var sizePrefixTypeNode = defineNode("sizePrefixTypeNode", {
   docs: ["Wraps another type with a numeric prefix indicating the byte length of the wrapped type."],
   attributes: [
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The wrapped type whose serialisation is preceded by its size."]
     }),
-    attribute("prefix", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("prefix", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used as the size prefix."]
     })
   ]
@@ -1595,7 +1611,7 @@ var sizePrefixTypeNode = defineNode("sizePrefixTypeNode", {
 var solAmountTypeNode = defineNode("solAmountTypeNode", {
   docs: ["A SOL amount expressed in lamports under the wrapped numeric type."],
   attributes: [
-    attribute("number", nestedUnion("NestedTypeNode", "numberTypeNode"), {
+    attribute("number", nestedUnion("nestedTypeNode", "numberTypeNode"), {
       docs: ["The numeric type used to serialise the lamport amount."]
     })
   ]
@@ -1609,7 +1625,7 @@ var stringTypeNode = defineNode("stringTypeNode", {
     "The byte length is determined by an enclosing wrapper such as `sizePrefixTypeNode` or `fixedSizeTypeNode`."
   ],
   attributes: [
-    attribute("encoding", enumeration("BytesEncoding"), {
+    attribute("encoding", enumeration("bytesEncoding"), {
       docs: ["The byte encoding used to serialise the string."]
     })
   ]
@@ -1622,16 +1638,16 @@ var structFieldTypeNode = defineNode("structFieldTypeNode", {
     attribute("name", stringIdentifier(), {
       docs: ["The name of the field."]
     }),
-    optionalAttribute("defaultValueStrategy", enumeration("DefaultValueStrategy"), {
+    optionalAttribute("defaultValueStrategy", enumeration("defaultValueStrategy"), {
       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."]
     }),
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The type of the field."]
     }),
-    optionalAttribute("defaultValue", union("ValueNode"), {
+    optionalAttribute("defaultValue", union("valueNode"), {
       docs: ["A default value used when the field is omitted by callers."]
     })
   ]
@@ -1653,7 +1669,7 @@ var structTypeNode = defineNode("structTypeNode", {
 var tupleTypeNode = defineNode("tupleTypeNode", {
   docs: ["A heterogeneous fixed-length sequence in which each positional slot has its own type."],
   attributes: [
-    attribute("items", array(union("TypeNode")), {
+    attribute("items", array(union("typeNode")), {
       docs: ["The type of each positional slot, in order."]
     })
   ]
@@ -1686,28 +1702,28 @@ var STANDALONE_TYPE_NODE_KINDS = [
   "tupleTypeNode",
   "zeroableOptionTypeNode"
 ];
-var standaloneTypeNodeUnion = defineUnion("StandaloneTypeNode", {
+var standaloneTypeNodeUnion = defineUnion("standaloneTypeNode", {
   docs: ["Every type node that can be used as a top-level type."],
   members: [...STANDALONE_TYPE_NODE_KINDS]
 });
-var enumVariantTypeNodeUnion = defineUnion("EnumVariantTypeNode", {
+var enumVariantTypeNodeUnion = defineUnion("enumVariantTypeNode", {
   docs: ["The variant flavours of an `enumTypeNode`."],
   members: ["enumEmptyVariantTypeNode", "enumStructVariantTypeNode", "enumTupleVariantTypeNode"]
 });
-var typeNodeUnion = defineUnion("TypeNode", {
+var typeNodeUnion = defineUnion("typeNode", {
   docs: ["The composable form: any standalone type, or a reference to a defined type via `definedTypeLinkNode`."],
-  members: [union("StandaloneTypeNode"), "definedTypeLinkNode"]
+  members: [union("standaloneTypeNode"), "definedTypeLinkNode"]
 });
-var registeredTypeNodeUnion = defineUnion("RegisteredTypeNode", {
+var registeredTypeNodeUnion = defineUnion("registeredTypeNode", {
   docs: ["Every node tagged as a type-shaped node, including variants and struct fields."],
-  members: [union("StandaloneTypeNode"), union("EnumVariantTypeNode"), "structFieldTypeNode"]
+  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."],
   attributes: [
-    attribute("item", union("TypeNode"), {
+    attribute("item", union("typeNode"), {
       docs: ["The type carried by the option when present."]
     }),
     optionalAttribute("zeroValue", node("constantValueNode"), {
@@ -1760,7 +1776,7 @@ var ALL_TYPE_NODE_UNIONS = [
 var arrayValueNode = defineNode("arrayValueNode", {
   docs: ["A concrete array value: a list of value nodes."],
   attributes: [
-    attribute("items", array(union("ValueNode")), {
+    attribute("items", array(union("valueNode")), {
       docs: ["The items of the array, in order."]
     })
   ]
@@ -1783,7 +1799,7 @@ var bytesValueNode = defineNode("bytesValueNode", {
     attribute("data", string(), {
       docs: ["The bytes encoded as a text string per the `encoding` attribute."]
     }),
-    attribute("encoding", enumeration("BytesEncoding"), {
+    attribute("encoding", enumeration("bytesEncoding"), {
       docs: ["The encoding used to represent the bytes as text."]
     })
   ]
@@ -1793,10 +1809,10 @@ var bytesValueNode = defineNode("bytesValueNode", {
 var constantValueNode = defineNode("constantValueNode", {
   docs: ["A typed constant: a type node paired with a concrete value node."],
   attributes: [
-    attribute("type", union("TypeNode"), {
+    attribute("type", union("typeNode"), {
       docs: ["The type of the constant."]
     }),
-    attribute("value", union("ValueNode"), {
+    attribute("value", union("valueNode"), {
       docs: ["The concrete value of the constant."]
     })
   ]
@@ -1812,7 +1828,7 @@ var enumValueNode = defineNode("enumValueNode", {
     attribute("enum", node("definedTypeLinkNode"), {
       docs: ["A link to the defined enum type the value belongs to."]
     }),
-    optionalAttribute("value", union("EnumValuePayload"), {
+    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."
@@ -1825,10 +1841,10 @@ var enumValueNode = defineNode("enumValueNode", {
 var mapEntryValueNode = defineNode("mapEntryValueNode", {
   docs: ["A single (key, value) pair inside a `mapValueNode`."],
   attributes: [
-    attribute("key", union("ValueNode"), {
+    attribute("key", union("valueNode"), {
       docs: ["The entry key."]
     }),
-    attribute("value", union("ValueNode"), {
+    attribute("value", union("valueNode"), {
       docs: ["The entry value."]
     })
   ]
@@ -1867,7 +1883,7 @@ var numberValueNode = defineNode("numberValueNode", {
 var publicKeyValueNode = defineNode("publicKeyValueNode", {
   docs: ["A concrete public key, with an optional symbolic identifier for the address."],
   attributes: [
-    attribute("publicKey", string(), {
+    attribute("publicKey", address(), {
       docs: ["The base58-encoded public key."]
     }),
     optionalAttribute("identifier", stringIdentifier(), {
@@ -1880,7 +1896,7 @@ var publicKeyValueNode = defineNode("publicKeyValueNode", {
 var setValueNode = defineNode("setValueNode", {
   docs: ["A concrete set value: a list of unique value nodes."],
   attributes: [
-    attribute("items", array(union("ValueNode")), {
+    attribute("items", array(union("valueNode")), {
       docs: ["The items of the set."]
     })
   ]
@@ -1890,7 +1906,7 @@ var setValueNode = defineNode("setValueNode", {
 var someValueNode = defineNode("someValueNode", {
   docs: ['The "present" value for an optional type, wrapping a concrete value node.'],
   attributes: [
-    attribute("value", union("ValueNode"), {
+    attribute("value", union("valueNode"), {
       docs: ["The wrapped value."]
     })
   ]
@@ -1913,7 +1929,7 @@ var structFieldValueNode = defineNode("structFieldValueNode", {
     attribute("name", stringIdentifier(), {
       docs: ["The name of the field."]
     }),
-    attribute("value", union("ValueNode"), {
+    attribute("value", union("valueNode"), {
       docs: ["The concrete value of the field."]
     })
   ]
@@ -1933,7 +1949,7 @@ var structValueNode = defineNode("structValueNode", {
 var tupleValueNode = defineNode("tupleValueNode", {
   docs: ["A concrete tuple value: a fixed-length sequence of positional value nodes."],
   attributes: [
-    attribute("items", array(union("ValueNode")), {
+    attribute("items", array(union("valueNode")), {
       docs: ["The positional items of the tuple, in order."]
     })
   ]
@@ -1956,19 +1972,19 @@ var STANDALONE_VALUE_NODE_KINDS = [
   "structValueNode",
   "tupleValueNode"
 ];
-var standaloneValueNodeUnion = defineUnion("StandaloneValueNode", {
+var standaloneValueNodeUnion = defineUnion("standaloneValueNode", {
   docs: ["Every value node that can be used as a top-level value."],
   members: [...STANDALONE_VALUE_NODE_KINDS]
 });
-var valueNodeUnion = defineUnion("ValueNode", {
+var valueNodeUnion = defineUnion("valueNode", {
   docs: ["The composable form: any standalone value node."],
-  members: [union("StandaloneValueNode")]
+  members: [union("standaloneValueNode")]
 });
-var registeredValueNodeUnion = defineUnion("RegisteredValueNode", {
+var registeredValueNodeUnion = defineUnion("registeredValueNode", {
   docs: ["Every node tagged as a value-shaped node, including container variants."],
-  members: [union("StandaloneValueNode"), "mapEntryValueNode", "structFieldValueNode"]
+  members: [union("standaloneValueNode"), "mapEntryValueNode", "structFieldValueNode"]
 });
-var enumValuePayloadUnion = defineUnion("EnumValuePayload", {
+var enumValuePayloadUnion = defineUnion("enumValuePayload", {
   docs: ["The payload kinds an `enumValueNode` may carry \u2014 struct fields or positional tuple slots."],
   members: ["structValueNode", "tupleValueNode"]
 });