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

package/dist/index.browser.mjs

@@ -1,3 +1,1907 @@
-export { SPEC_VERSION, getEnumeration, getNode, getSpec, getUnion, isChildAttribute } from './chunk-AU77NZTG.browser.mjs';
+// src/api/attribute.ts
+function attribute(name, type, options = {}) {
+  return Object.freeze({
+    name,
+    type,
+    ...options.optional ? { optional: true } : {},
+    ...options.docs !== void 0 ? { docs: options.docs } : {}
+  });
+}
+function optionalAttribute(name, type, options = {}) {
+  return attribute(name, type, { ...options, optional: true });
+}
+
+// src/api/compounds.ts
+function array(inner) {
+  return Object.freeze({ kind: "array", of: inner });
+}
+
+// src/api/defineEnumeration.ts
+function variant(name, options = {}) {
+  return Object.freeze({
+    name,
+    ...options.docs !== void 0 ? { docs: options.docs } : {}
+  });
+}
+function defineEnumeration(name, options) {
+  if (options.variants.length === 0) {
+    throw new Error(`defineEnumeration("${name}"): variants must be non-empty`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of options.variants) {
+    if (seen.has(v.name)) {
+      throw new Error(`defineEnumeration("${name}"): duplicate variant "${v.name}"`);
+    }
+    seen.add(v.name);
+  }
+  return Object.freeze({
+    name,
+    variants: Object.freeze([...options.variants]),
+    ...options.docs !== void 0 ? { docs: options.docs } : {}
+  });
+}
+
+// src/api/defineNode.ts
+function defineNode(kind, options) {
+  return Object.freeze({
+    kind,
+    ...options.docs !== void 0 ? { docs: options.docs } : {},
+    attributes: Object.freeze([...options.attributes]),
+    examples: Object.freeze([...options.examples ?? []])
+  });
+}
+
+// src/api/defineUnion.ts
+function defineUnion(name, options) {
+  const normalised = options.members.map(normaliseMember);
+  return Object.freeze({
+    name,
+    members: Object.freeze(normalised),
+    ...options.docs !== void 0 ? { docs: options.docs } : {}
+  });
+}
+function normaliseMember(input) {
+  if (typeof input === "string") {
+    return Object.freeze({ kind: "node", name: input });
+  }
+  if (input.kind === "node") return Object.freeze({ kind: "node", name: input.name });
+  if (input.kind === "union") return Object.freeze({ kind: "union", name: input.name });
+  throw new Error(
+    `defineUnion: members must be node kind strings, node(...) or union(...) references; got ${JSON.stringify(input)}`
+  );
+}
+
+// src/api/primitives.ts
+function string() {
+  return Object.freeze({ kind: "string" });
+}
+function stringIdentifier() {
+  return Object.freeze({ kind: "string", constraint: "identifier" });
+}
+function stringVersion() {
+  return Object.freeze({ kind: "string", constraint: "version" });
+}
+function codamaVersion() {
+  return Object.freeze({ kind: "codamaVersion" });
+}
+var integer = (width) => Object.freeze({ kind: "integer", width });
+var u32 = () => integer("u32");
+var u64 = () => integer("u64");
+var i64 = () => integer("i64");
+var float = (width) => Object.freeze({ kind: "float", width });
+var f64 = () => float("f64");
+function boolean() {
+  return Object.freeze({ kind: "boolean" });
+}
+function literal(value) {
+  return Object.freeze({ kind: "literal", value });
+}
+function literalUnion(...values) {
+  if (values.length === 0) {
+    throw new Error("literalUnion: at least one value required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    if (seen.has(v)) {
+      throw new Error(`literalUnion: duplicate value ${JSON.stringify(v)}`);
+    }
+    seen.add(v);
+  }
+  return Object.freeze({ kind: "literalUnion", values: Object.freeze([...values]) });
+}
+function enumeration(name) {
+  return Object.freeze({ kind: "enumeration", name });
+}
+function node(name) {
+  return Object.freeze({ kind: "node", name });
+}
+function union(name) {
+  return Object.freeze({ kind: "union", name });
+}
+function nestedTypeNode(name) {
+  return Object.freeze({ kind: "nestedTypeNode", name });
+}
+
+// src/api/semanticAliases.ts
+function byteSize() {
+  return u64();
+}
+function docs() {
+  return array(string());
+}
+
+// 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 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 [name, kinds] of registrations) {
+    if (kinds.length > 1) errors.push(formatCollisionError(name, kinds));
+  }
+  for (const n of spec.nodes) {
+    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.`);
+    }
+    const seenAttrs = /* @__PURE__ */ new Set();
+    for (const a of n.attributes) {
+      if (seenAttrs.has(a.name)) {
+        errors.push(`Node "${n.kind}" declares attribute "${a.name}" more than once.`);
+      }
+      seenAttrs.add(a.name);
+      walkTypeExpr(
+        a.type,
+        (expr) => checkRef(expr, n.kind, a.name, errors, nodeKinds, unionNames, enumerationNames)
+      );
+    }
+  }
+  for (const u of spec.unions) {
+    if (u.members.length === 0) {
+      errors.push(`Union "${u.name}" has no members.`);
+    }
+    const seenMembers = /* @__PURE__ */ new Set();
+    for (const m of u.members) {
+      const key = `${m.kind}:${m.name}`;
+      if (seenMembers.has(key)) {
+        errors.push(`Union "${u.name}" lists member ${key} more than once.`);
+      }
+      seenMembers.add(key);
+      if (m.kind === "node" && !nodeKinds.has(m.name)) {
+        errors.push(`Union "${u.name}" references undefined node "${m.name}".`);
+      }
+      if (m.kind === "union" && !unionNames.has(m.name)) {
+        errors.push(`Union "${u.name}" references undefined union "${m.name}".`);
+      }
+    }
+  }
+  for (const wrapper of wrappers) {
+    if (!nodeKinds.has(wrapper)) {
+      errors.push(`Nested-type-node wrapper "${wrapper}" is not a defined node.`);
+    }
+  }
+  return errors;
+}
+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.`;
+}
+function walkTypeExpr(expr, visit) {
+  visit(expr);
+  if (expr.kind === "array") {
+    walkTypeExpr(expr.of, visit);
+  } else if (expr.kind === "tuple") {
+    for (const item of expr.items) walkTypeExpr(item, visit);
+  }
+}
+function checkRef(expr, nodeKind, attrName, errors, nodeKinds, unionNames, enumerationNames) {
+  const where = `Node "${nodeKind}", attribute "${attrName}":`;
+  switch (expr.kind) {
+    case "node":
+      if (!nodeKinds.has(expr.name)) {
+        errors.push(`${where} references undefined node "${expr.name}".`);
+      }
+      break;
+    case "union":
+      if (!unionNames.has(expr.name)) {
+        errors.push(`${where} references undefined union "${expr.name}".`);
+      }
+      break;
+    case "enumeration":
+      if (!enumerationNames.has(expr.name)) {
+        errors.push(`${where} references undefined enumeration "${expr.name}".`);
+      }
+      break;
+    case "nestedTypeNode":
+      if (!nodeKinds.has(expr.name)) {
+        errors.push(`${where} nestedTypeNode references undefined node "${expr.name}".`);
+      }
+      break;
+  }
+}
+function isChildAttribute(type) {
+  switch (type.kind) {
+    case "node":
+    case "nestedTypeNode":
+    case "union":
+      return true;
+    case "array":
+      return isChildAttribute(type.of);
+    case "tuple":
+      return type.items.some(isChildAttribute);
+    default:
+      return false;
+  }
+}
+
+// src/v1/enumerations.ts
+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", {
+  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("shortU16", {
+      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." })
+  ]
+});
+var bytesEncoding = defineEnumeration("BytesEncoding", {
+  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." })
+  ]
+});
+var instructionLifecycle = defineEnumeration("InstructionLifecycle", {
+  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."
+    }),
+    variant("deprecated", {
+      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."
+    }),
+    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.",
+  variants: [
+    variant("omitted", {
+      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."
+    })
+  ]
+});
+var optionalAccountStrategy = defineEnumeration("OptionalAccountStrategy", {
+  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."
+    }),
+    variant("programId", {
+      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.",
+  variants: [
+    variant("absolute", {
+      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."
+    }),
+    variant("relative", {
+      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.",
+  variants: [
+    variant("absolute", {
+      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."
+    }),
+    variant("preOffset", {
+      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."
+    })
+  ]
+});
+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." }),
+    variant("shank", { docs: "The program was originally described by a Shank IDL." })
+  ]
+});
+var ALL_ENUMERATIONS = [
+  bytesEncoding,
+  defaultValueStrategy,
+  endianness,
+  instructionLifecycle,
+  numberFormat,
+  optionalAccountStrategy,
+  postOffsetStrategy,
+  preOffsetStrategy,
+  programOrigin
+];
+
+// src/v1/nestedTypeNodeWrappers.ts
+var NESTED_TYPE_NODE_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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the account."
+    }),
+    optionalAttribute("size", byteSize(), {
+      docs: "The size of the account in bytes, when the data length is fixed."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the account."
+    }),
+    attribute("data", 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")), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the constant."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the constant."
+    }),
+    attribute("type", union("TypeNode"), {
+      docs: "The type of the constant."
+    }),
+    attribute("value", union("ValueNode"), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      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`.",
+  attributes: [
+    attribute("condition", union("ConditionalValueCondition"), {
+      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."
+    }),
+    optionalAttribute("ifTrue", union("InstructionInputValueNode"), {
+      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`)."
+    })
+  ]
+});
+
+// src/v1/nodes/contextualValueNodes/ContextualValueNode.ts
+var STANDALONE_CONTEXTUAL_VALUE_NODE_KINDS = [
+  "accountBumpValueNode",
+  "accountValueNode",
+  "argumentValueNode",
+  "conditionalValueNode",
+  "identityValueNode",
+  "payerValueNode",
+  "pdaValueNode",
+  "programIdValueNode",
+  "resolverValueNode"
+];
+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", {
+  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.",
+  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.",
+  members: [union("ContextualValueNode"), "programLinkNode", union("ValueNode")]
+});
+var conditionalValueConditionUnion = defineUnion("ConditionalValueCondition", {
+  docs: "The condition forms accepted by a `conditionalValueNode`.",
+  members: ["accountValueNode", "argumentValueNode", "resolverValueNode"]
+});
+var resolverDependencyUnion = defineUnion("ResolverDependency", {
+  docs: "The dependency forms accepted by a `resolverValueNode`.",
+  members: ["accountValueNode", "argumentValueNode"]
+});
+var pdaSeedValueValueUnion = defineUnion("PdaSeedValueValue", {
+  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.",
+  members: ["pdaLinkNode", "pdaNode"]
+});
+var pdaValueProgramIdUnion = defineUnion("PdaValueProgramId", {
+  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.",
+  attributes: []
+});
+
+// src/v1/nodes/contextualValueNodes/PayerValueNode.ts
+var payerValueNode = defineNode("payerValueNode", {
+  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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the seed being filled in."
+    }),
+    attribute("value", union("PdaSeedValueValue"), {
+      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.",
+  attributes: [
+    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")), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/contextualValueNodes/ProgramIdValueNode.ts
+var programIdValueNode = defineNode("programIdValueNode", {
+  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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the resolver function."
+    }),
+    optionalAttribute("docs", docs(), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/contextualValueNodes/index.ts
+var ALL_CONTEXTUAL_VALUE_NODES = [
+  accountBumpValueNode,
+  accountValueNode,
+  argumentValueNode,
+  conditionalValueNode,
+  identityValueNode,
+  payerValueNode,
+  pdaSeedValueNode,
+  pdaValueNode,
+  programIdValueNode,
+  resolverValueNode
+];
+var ALL_CONTEXTUAL_VALUE_NODE_UNIONS = [
+  standaloneContextualValueNodeUnion,
+  contextualValueNodeUnion,
+  registeredContextualValueNodeUnion,
+  instructionInputValueNodeUnion,
+  conditionalValueConditionUnion,
+  resolverDependencyUnion,
+  pdaSeedValueValueUnion,
+  pdaValuePdaUnion,
+  pdaValueProgramIdUnion
+];
+
+// src/v1/nodes/countNodes/CountNode.ts
+var registeredCountNodeUnion = defineUnion("RegisteredCountNode", {
+  docs: "Every node tagged as a count strategy.",
+  members: ["fixedCountNode", "prefixedCountNode", "remainderCountNode"]
+});
+var countNodeUnion = defineUnion("CountNode", {
+  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.",
+  attributes: [
+    attribute("value", u64(), {
+      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.",
+  attributes: [
+    attribute("prefix", 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.",
+  attributes: []
+});
+
+// src/v1/nodes/countNodes/index.ts
+var ALL_COUNT_NODES = [fixedCountNode, prefixedCountNode, remainderCountNode];
+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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the defined type."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the type."
+    }),
+    attribute("type", union("TypeNode"), {
+      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).",
+  attributes: [
+    attribute("offset", u64(), {
+      docs: "The byte offset at which the constant begins."
+    }),
+    attribute("constant", node("constantValueNode"), {
+      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.",
+  members: ["constantDiscriminatorNode", "fieldDiscriminatorNode", "sizeDiscriminatorNode"]
+});
+var discriminatorNodeUnion = defineUnion("DiscriminatorNode", {
+  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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the discriminating field."
+    }),
+    attribute("offset", u64(), {
+      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.",
+  attributes: [
+    attribute("size", u64(), {
+      docs: "The expected byte size."
+    })
+  ]
+});
+
+// src/v1/nodes/discriminatorNodes/index.ts
+var ALL_DISCRIMINATOR_NODES = [
+  constantDiscriminatorNode,
+  fieldDiscriminatorNode,
+  sizeDiscriminatorNode
+];
+var ALL_DISCRIMINATOR_NODE_UNIONS = [registeredDiscriminatorNodeUnion, discriminatorNodeUnion];
+
+// 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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the error."
+    }),
+    attribute("code", u32(), {
+      docs: "The numeric error code returned by the program."
+    }),
+    attribute("message", string(), {
+      docs: "A human-readable description of the error."
+    }),
+    optionalAttribute("docs", docs(), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the event."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the event."
+    }),
+    attribute("data", union("TypeNode"), {
+      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."
+    })
+  ]
+});
+
+// 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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the account."
+    }),
+    attribute("isWritable", boolean(), {
+      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.'
+    }),
+    optionalAttribute("isOptional", boolean(), {
+      docs: "Whether the account slot may be omitted by callers."
+    }),
+    optionalAttribute("docs", docs(), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/InstructionArgumentNode.ts
+var instructionArgumentNode = defineNode("instructionArgumentNode", {
+  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."
+    }),
+    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"), {
+      docs: "The type of the argument."
+    }),
+    optionalAttribute("defaultValue", union("InstructionInputValueNode"), {
+      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.",
+  attributes: [
+    attribute("withHeader", boolean(), {
+      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`."
+    }),
+    attribute("value", union("InstructionByteDeltaValue"), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the instruction."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the instruction."
+    }),
+    optionalAttribute("optionalAccountStrategy", enumeration("OptionalAccountStrategy"), {
+      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."
+    }),
+    attribute("arguments", array(node("instructionArgumentNode")), {
+      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."
+    }),
+    optionalAttribute("remainingAccounts", array(node("instructionRemainingAccountsNode")), {
+      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."
+    }),
+    optionalAttribute("discriminators", array(union("DiscriminatorNode")), {
+      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."
+    }),
+    optionalAttribute("subInstructions", array(node("instructionNode")), {
+      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`.",
+  members: ["accountLinkNode", "argumentValueNode", "numberValueNode", "resolverValueNode"]
+});
+var instructionRemainingAccountsValueUnion = defineUnion("InstructionRemainingAccountsValue", {
+  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.',
+  attributes: [
+    optionalAttribute("isOptional", boolean(), {
+      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.'
+    }),
+    optionalAttribute("isWritable", boolean(), {
+      docs: "Whether the instruction may write to each remaining account."
+    }),
+    optionalAttribute("docs", docs(), {
+      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."
+    })
+  ]
+});
+
+// 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.",
+  attributes: [
+    attribute("lifecycle", enumeration("InstructionLifecycle"), {
+      docs: "The lifecycle stage."
+    }),
+    optionalAttribute("message", string(), {
+      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.",
+  attributes: [
+    optionalAttribute("program", node("programLinkNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/linkNodes/DefinedTypeLinkNode.ts
+var definedTypeLinkNode = defineNode("definedTypeLinkNode", {
+  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."
+    }),
+    attribute("name", stringIdentifier(), {
+      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.",
+  attributes: [
+    optionalAttribute("instruction", node("instructionLinkNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/linkNodes/InstructionArgumentLinkNode.ts
+var instructionArgumentLinkNode = defineNode("instructionArgumentLinkNode", {
+  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."
+    }),
+    attribute("name", stringIdentifier(), {
+      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.",
+  attributes: [
+    optionalAttribute("program", node("programLinkNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/linkNodes/LinkNode.ts
+var registeredLinkNodeUnion = defineUnion("RegisteredLinkNode", {
+  docs: "Every node tagged as a link to another part of the IDL.",
+  members: [
+    "accountLinkNode",
+    "definedTypeLinkNode",
+    "instructionAccountLinkNode",
+    "instructionArgumentLinkNode",
+    "instructionLinkNode",
+    "pdaLinkNode",
+    "programLinkNode"
+  ]
+});
+var linkNodeUnion = defineUnion("LinkNode", {
+  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.",
+  attributes: [
+    optionalAttribute("program", node("programLinkNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/linkNodes/ProgramLinkNode.ts
+var programLinkNode = defineNode("programLinkNode", {
+  docs: "A reference to a program by name.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the referenced program."
+    })
+  ]
+});
+
+// src/v1/nodes/linkNodes/index.ts
+var ALL_LINK_NODES = [
+  accountLinkNode,
+  definedTypeLinkNode,
+  instructionAccountLinkNode,
+  instructionArgumentLinkNode,
+  instructionLinkNode,
+  pdaLinkNode,
+  programLinkNode
+];
+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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the PDA."
+    }),
+    optionalAttribute("docs", docs(), {
+      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."
+    }),
+    attribute("seeds", array(union("PdaSeedNode")), {
+      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).",
+  attributes: [
+    attribute("type", union("TypeNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/pdaSeedNodes/PdaSeedNode.ts
+var registeredPdaSeedNodeUnion = defineUnion("RegisteredPdaSeedNode", {
+  docs: "Every node tagged as a PDA seed.",
+  members: ["constantPdaSeedNode", "variablePdaSeedNode"]
+});
+var pdaSeedNodeUnion = defineUnion("PdaSeedNode", {
+  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.",
+  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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the seed variable."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the seed variable."
+    }),
+    attribute("type", union("TypeNode"), {
+      docs: "The expected type of the seed value."
+    })
+  ]
+});
+
+// src/v1/nodes/pdaSeedNodes/index.ts
+var ALL_PDA_SEED_NODES = [constantPdaSeedNode, variablePdaSeedNode];
+var ALL_PDA_SEED_NODE_UNIONS = [
+  registeredPdaSeedNodeUnion,
+  pdaSeedNodeUnion,
+  constantPdaSeedValueUnion
+];
+
+// 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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the program."
+    }),
+    attribute("publicKey", string(), {
+      docs: "The base58-encoded program ID."
+    }),
+    attribute("version", stringVersion(), {
+      docs: "The version of the program, in semver form."
+    }),
+    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")), {
+      docs: "The accounts owned by the program."
+    }),
+    attribute("instructions", array(node("instructionNode")), {
+      docs: "The instructions exposed by the program."
+    }),
+    attribute("definedTypes", array(node("definedTypeNode")), {
+      docs: "The reusable types defined by the program."
+    }),
+    attribute("pdas", array(node("pdaNode")), {
+      docs: "The PDAs derived by the program."
+    }),
+    attribute("events", array(node("eventNode")), {
+      docs: "The events emitted by the program."
+    }),
+    attribute("errors", array(node("errorNode")), {
+      docs: "The errors returned by the program."
+    }),
+    attribute("constants", array(node("constantNode")), {
+      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.",
+  attributes: [
+    attribute("standard", literal("codama"), {
+      docs: "A literal marker identifying the document as a Codama IDL."
+    }),
+    attribute("version", codamaVersion(), {
+      docs: "The Codama spec version this document conforms to."
+    }),
+    attribute("program", node("programNode"), {
+      docs: "The primary program described by the document."
+    }),
+    attribute("additionalPrograms", array(node("programNode")), {
+      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.",
+  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."
+    }),
+    optionalAttribute("unit", string(), {
+      docs: 'The unit of the amount \u2014 e.g. "USD" or "%".'
+    }),
+    attribute("number", 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.",
+  attributes: [
+    attribute("item", union("TypeNode"), {
+      docs: "The type of each item in the array."
+    }),
+    attribute("count", union("CountNode"), {
+      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.",
+  attributes: [
+    attribute("size", 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.",
+  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.",
+  attributes: [
+    attribute("number", 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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the variant."
+    }),
+    optionalAttribute("discriminator", u32(), {
+      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).",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the variant."
+    }),
+    optionalAttribute("discriminator", u32(), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/typeNodes/EnumTupleVariantTypeNode.ts
+var enumTupleVariantTypeNode = defineNode("enumTupleVariantTypeNode", {
+  docs: "A variant of an enum that carries a tuple payload (positional fields).",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the variant."
+    }),
+    optionalAttribute("discriminator", u32(), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/typeNodes/EnumTypeNode.ts
+var enumTypeNode = defineNode("enumTypeNode", {
+  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."
+    }),
+    attribute("size", 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.",
+  attributes: [
+    attribute("size", u64(), {
+      docs: "The total byte size the wrapped type must occupy."
+    }),
+    attribute("type", union("TypeNode"), {
+      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.",
+  attributes: [
+    attribute("type", union("TypeNode"), {
+      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."
+    })
+  ]
+});
+
+// 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.",
+  attributes: [
+    attribute("type", union("TypeNode"), {
+      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."
+    })
+  ]
+});
+
+// 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.",
+  attributes: [
+    attribute("key", union("TypeNode"), {
+      docs: "The type of each entry key."
+    }),
+    attribute("value", union("TypeNode"), {
+      docs: "The type of each entry value."
+    }),
+    attribute("count", union("CountNode"), {
+      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.",
+  attributes: [
+    attribute("format", enumeration("NumberFormat"), {
+      docs: "The wire format used to serialise the number."
+    }),
+    attribute("endian", enumeration("Endianness"), {
+      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.",
+  attributes: [
+    optionalAttribute("fixed", boolean(), {
+      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."
+    }),
+    attribute("prefix", 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.",
+  attributes: [
+    attribute("offset", i64(), {
+      docs: "The signed byte offset to apply after the wrapped type runs."
+    }),
+    attribute("strategy", enumeration("PostOffsetStrategy"), {
+      docs: "How the `offset` value is interpreted."
+    }),
+    attribute("type", union("TypeNode"), {
+      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.",
+  attributes: [
+    attribute("offset", i64(), {
+      docs: "The signed byte offset to apply before the wrapped type runs."
+    }),
+    attribute("strategy", enumeration("PreOffsetStrategy"), {
+      docs: "How the `offset` value is interpreted."
+    }),
+    attribute("type", union("TypeNode"), {
+      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.",
+  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.",
+  attributes: [
+    attribute("item", union("TypeNode"), {
+      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.",
+  attributes: [
+    attribute("type", union("TypeNode"), {
+      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."
+    })
+  ]
+});
+
+// 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.",
+  attributes: [
+    attribute("item", union("TypeNode"), {
+      docs: "The type of each item in the set."
+    }),
+    attribute("count", union("CountNode"), {
+      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.",
+  attributes: [
+    attribute("type", union("TypeNode"), {
+      docs: "The wrapped type whose serialisation is preceded by its size."
+    }),
+    attribute("prefix", 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.",
+  attributes: [
+    attribute("number", 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`.",
+  attributes: [
+    attribute("encoding", enumeration("BytesEncoding"), {
+      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.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      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."
+    }),
+    optionalAttribute("docs", docs(), {
+      docs: "Markdown documentation for the field."
+    }),
+    attribute("type", union("TypeNode"), {
+      docs: "The type of the field."
+    }),
+    optionalAttribute("defaultValue", union("ValueNode"), {
+      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.",
+  attributes: [
+    attribute("fields", array(node("structFieldTypeNode")), {
+      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.",
+  attributes: [
+    attribute("items", array(union("TypeNode")), {
+      docs: "The type of each positional slot, in order."
+    })
+  ]
+});
+
+// src/v1/nodes/typeNodes/TypeNode.ts
+var STANDALONE_TYPE_NODE_KINDS = [
+  "amountTypeNode",
+  "arrayTypeNode",
+  "booleanTypeNode",
+  "bytesTypeNode",
+  "dateTimeTypeNode",
+  "enumTypeNode",
+  "fixedSizeTypeNode",
+  "hiddenPrefixTypeNode",
+  "hiddenSuffixTypeNode",
+  "mapTypeNode",
+  "numberTypeNode",
+  "optionTypeNode",
+  "postOffsetTypeNode",
+  "preOffsetTypeNode",
+  "publicKeyTypeNode",
+  "remainderOptionTypeNode",
+  "sentinelTypeNode",
+  "setTypeNode",
+  "sizePrefixTypeNode",
+  "solAmountTypeNode",
+  "stringTypeNode",
+  "structTypeNode",
+  "tupleTypeNode",
+  "zeroableOptionTypeNode"
+];
+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", {
+  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`.",
+  members: [union("StandaloneTypeNode"), "definedTypeLinkNode"]
+});
+var registeredTypeNodeUnion = defineUnion("RegisteredTypeNode", {
+  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.",
+  attributes: [
+    attribute("item", union("TypeNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/typeNodes/index.ts
+var ALL_TYPE_NODES = [
+  amountTypeNode,
+  arrayTypeNode,
+  booleanTypeNode,
+  bytesTypeNode,
+  dateTimeTypeNode,
+  enumEmptyVariantTypeNode,
+  enumStructVariantTypeNode,
+  enumTupleVariantTypeNode,
+  enumTypeNode,
+  fixedSizeTypeNode,
+  hiddenPrefixTypeNode,
+  hiddenSuffixTypeNode,
+  mapTypeNode,
+  numberTypeNode,
+  optionTypeNode,
+  postOffsetTypeNode,
+  preOffsetTypeNode,
+  publicKeyTypeNode,
+  remainderOptionTypeNode,
+  sentinelTypeNode,
+  setTypeNode,
+  sizePrefixTypeNode,
+  solAmountTypeNode,
+  stringTypeNode,
+  structFieldTypeNode,
+  structTypeNode,
+  tupleTypeNode,
+  zeroableOptionTypeNode
+];
+var ALL_TYPE_NODE_UNIONS = [
+  standaloneTypeNodeUnion,
+  enumVariantTypeNodeUnion,
+  typeNodeUnion,
+  registeredTypeNodeUnion
+];
+
+// src/v1/nodes/valueNodes/ArrayValueNode.ts
+var arrayValueNode = defineNode("arrayValueNode", {
+  docs: "A concrete array value: a list of value nodes.",
+  attributes: [
+    attribute("items", array(union("ValueNode")), {
+      docs: "The items of the array, in order."
+    })
+  ]
+});
+
+// src/v1/nodes/valueNodes/BooleanValueNode.ts
+var booleanValueNode = defineNode("booleanValueNode", {
+  docs: "A concrete boolean value.",
+  attributes: [
+    attribute("boolean", boolean(), {
+      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.",
+  attributes: [
+    attribute("data", string(), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/valueNodes/ConstantValueNode.ts
+var constantValueNode = defineNode("constantValueNode", {
+  docs: "A typed constant: a type node paired with a concrete value node.",
+  attributes: [
+    attribute("type", union("TypeNode"), {
+      docs: "The type of the constant."
+    }),
+    attribute("value", union("ValueNode"), {
+      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.",
+  attributes: [
+    attribute("variant", stringIdentifier(), {
+      docs: "The name of the selected variant."
+    }),
+    attribute("enum", node("definedTypeLinkNode"), {
+      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."
+    })
+  ]
+});
+
+// src/v1/nodes/valueNodes/MapEntryValueNode.ts
+var mapEntryValueNode = defineNode("mapEntryValueNode", {
+  docs: "A single (key, value) pair inside a `mapValueNode`.",
+  attributes: [
+    attribute("key", union("ValueNode"), {
+      docs: "The entry key."
+    }),
+    attribute("value", union("ValueNode"), {
+      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.",
+  attributes: [
+    attribute("entries", array(node("mapEntryValueNode")), {
+      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.',
+  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.",
+  attributes: [
+    attribute("number", f64(), {
+      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.",
+  attributes: [
+    attribute("publicKey", string(), {
+      docs: "The base58-encoded public key."
+    }),
+    optionalAttribute("identifier", stringIdentifier(), {
+      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.",
+  attributes: [
+    attribute("items", array(union("ValueNode")), {
+      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.',
+  attributes: [
+    attribute("value", union("ValueNode"), {
+      docs: "The wrapped value."
+    })
+  ]
+});
+
+// src/v1/nodes/valueNodes/StringValueNode.ts
+var stringValueNode = defineNode("stringValueNode", {
+  docs: "A concrete string value.",
+  attributes: [
+    attribute("string", string(), {
+      docs: "The string value."
+    })
+  ]
+});
+
+// src/v1/nodes/valueNodes/StructFieldValueNode.ts
+var structFieldValueNode = defineNode("structFieldValueNode", {
+  docs: "A named field of a `structValueNode`.",
+  attributes: [
+    attribute("name", stringIdentifier(), {
+      docs: "The name of the field."
+    }),
+    attribute("value", union("ValueNode"), {
+      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.",
+  attributes: [
+    attribute("fields", array(node("structFieldValueNode")), {
+      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.",
+  attributes: [
+    attribute("items", array(union("ValueNode")), {
+      docs: "The positional items of the tuple, in order."
+    })
+  ]
+});
+
+// src/v1/nodes/valueNodes/ValueNode.ts
+var STANDALONE_VALUE_NODE_KINDS = [
+  "arrayValueNode",
+  "booleanValueNode",
+  "bytesValueNode",
+  "constantValueNode",
+  "enumValueNode",
+  "mapValueNode",
+  "noneValueNode",
+  "numberValueNode",
+  "publicKeyValueNode",
+  "setValueNode",
+  "someValueNode",
+  "stringValueNode",
+  "structValueNode",
+  "tupleValueNode"
+];
+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", {
+  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.",
+  members: [union("StandaloneValueNode"), "mapEntryValueNode", "structFieldValueNode"]
+});
+var enumValuePayloadUnion = defineUnion("EnumValuePayload", {
+  docs: "The payload kinds an `enumValueNode` may carry \u2014 struct fields or positional tuple slots.",
+  members: ["structValueNode", "tupleValueNode"]
+});
+
+// src/v1/nodes/valueNodes/index.ts
+var ALL_VALUE_NODES = [
+  arrayValueNode,
+  booleanValueNode,
+  bytesValueNode,
+  constantValueNode,
+  enumValueNode,
+  mapEntryValueNode,
+  mapValueNode,
+  noneValueNode,
+  numberValueNode,
+  publicKeyValueNode,
+  setValueNode,
+  someValueNode,
+  stringValueNode,
+  structFieldValueNode,
+  structValueNode,
+  tupleValueNode
+];
+var ALL_VALUE_NODE_UNIONS = [
+  standaloneValueNodeUnion,
+  valueNodeUnion,
+  registeredValueNodeUnion,
+  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 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
+  };
+  const errors = validate(built);
+  if (errors.length > 0) {
+    throw new Error(`Invalid Codama v1 spec:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  cached = built;
+  return cached;
+}
+function getNode(kind) {
+  return getSpec().nodes.find((n) => n.kind === kind);
+}
+function getUnion(name) {
+  return getSpec().unions.find((u) => u.name === name);
+}
+function getEnumeration(name) {
+  return getSpec().enumerations.find((e) => e.name === name);
+}
+
+export { SPEC_VERSION, getEnumeration, getNode, getSpec, getUnion, isChildAttribute };
 //# sourceMappingURL=index.browser.mjs.map
 //# sourceMappingURL=index.browser.mjs.map