@nictool/dns-resource-record 1.6.1 → 1.7.0

package/lib/wire.js

@@ -0,0 +1,519 @@
+import { base64ToBytes, bytesToBase64, bytesToHex, hexToBytes } from './binary.js'
+import { expandIPv6 } from './tinydns.js'
+
+// ── Name encoding/decoding ────────────────────────────────────────────────────
+
+export function encodeName(name) {
+  const labels = name.replace(/\.$/, '').split('.')
+  const parts = labels.map((l) => {
+    const b = Buffer.from(l)
+    return Buffer.concat([Buffer.from([b.length]), b])
+  })
+  return Buffer.concat([...parts, Buffer.from([0])])
+}
+
+/**
+ * Read a (possibly pointer-compressed) DNS name from a packet.
+ * Returns { bytes: Buffer (uncompressed wire name), end: offset after name }.
+ */
+export function readWireName(packet, offset) {
+  const labels = []
+  let pos = offset
+  let end = -1
+
+  while (pos < packet.length) {
+    const len = packet[pos]
+    if (len === 0) {
+      if (end === -1) end = pos + 1
+      labels.push(Buffer.from([0]))
+      break
+    }
+    if ((len & 0xc0) === 0xc0) {
+      if (end === -1) end = pos + 2
+      pos = ((len & 0x3f) << 8) | packet[pos + 1]
+      continue
+    }
+    const label = packet.slice(pos, pos + 1 + len)
+    labels.push(label)
+    pos += 1 + len
+  }
+
+  return { bytes: Buffer.concat(labels), end }
+}
+
+/**
+ * Decompress rdata for types that embed domain names (RFC 1035 §3.3).
+ * For all other types, returns the raw rdata bytes unchanged.
+ */
+export function decompressRdata(packet, rdataOffset, rdlen, typeId) {
+  const raw = packet.slice(rdataOffset, rdataOffset + rdlen)
+
+  switch (typeId) {
+    // Single name: NS, CNAME, PTR, DNAME
+    case 2:
+    case 5:
+    case 12:
+    case 39: {
+      const { bytes } = readWireName(packet, rdataOffset)
+      return bytes
+    }
+
+    // SOA: mname + rname + 5 × uint32
+    case 6: {
+      const { bytes: mname, end: e1 } = readWireName(packet, rdataOffset)
+      const { bytes: rname, end: e2 } = readWireName(packet, e1)
+      const tail = packet.slice(e2, rdataOffset + rdlen) // 20 bytes
+      return Buffer.concat([mname, rname, tail])
+    }
+
+    // preference(2) + name: MX, KX
+    case 15:
+    case 36: {
+      const pref = raw.slice(0, 2)
+      const { bytes } = readWireName(packet, rdataOffset + 2)
+      return Buffer.concat([pref, bytes])
+    }
+
+    // priority(2) + weight(2) + port(2) + name: SRV
+    case 33: {
+      const head = raw.slice(0, 6)
+      const { bytes } = readWireName(packet, rdataOffset + 6)
+      return Buffer.concat([head, bytes])
+    }
+
+    // mbox + txt (two names): RP
+    case 17: {
+      const { bytes: mbox, end: e1 } = readWireName(packet, rdataOffset)
+      const { bytes: txt } = readWireName(packet, e1)
+      return Buffer.concat([mbox, txt])
+    }
+
+    // order(2)+pref(2)+flags_str+svc_str+regexp_str+name: NAPTR
+    case 35: {
+      const head = raw.slice(0, 4)
+      let pos = rdataOffset + 4
+      const strings = []
+      for (let i = 0; i < 3; i++) {
+        const slen = packet[pos]
+        strings.push(packet.slice(pos, pos + 1 + slen))
+        pos += 1 + slen
+      }
+      const { bytes: name } = readWireName(packet, pos)
+      return Buffer.concat([head, ...strings, name])
+    }
+
+    default:
+      return raw
+  }
+}
+
+// ── Query building and parsing ────────────────────────────────────────────────
+
+export function buildQuery(name, typeId, classId = 1) {
+  const nameBytes = encodeName(name)
+  const header = Buffer.alloc(12)
+  header.writeUInt16BE(Math.floor(Math.random() * 65536), 0)
+  header.writeUInt16BE(0x0100, 2) // RD=1
+  header.writeUInt16BE(1, 4) // QDCOUNT=1
+  header.writeUInt16BE(1, 10) // ARCOUNT=1 (OPT record)
+  const question = Buffer.alloc(nameBytes.length + 4)
+  nameBytes.copy(question)
+  question.writeUInt16BE(typeId, nameBytes.length)
+  question.writeUInt16BE(classId, nameBytes.length + 2)
+  // EDNS0 OPT record: root name, type=OPT(41), class=4096 (UDP payload), TTL=0, RDLEN=0
+  const opt = Buffer.alloc(11)
+  opt[0] = 0x00 // owner = root
+  opt.writeUInt16BE(41, 1) // type = OPT
+  opt.writeUInt16BE(4096, 3) // UDP payload size
+  opt.writeUInt32BE(0, 5) // extended RCODE and flags
+  opt.writeUInt16BE(0, 9) // RDLENGTH = 0
+  return Buffer.concat([header, question, opt])
+}
+
+export function parseResponse(packet) {
+  const rcode = packet.readUInt16BE(2) & 0xf
+  const qdcount = packet.readUInt16BE(4)
+  const ancount = packet.readUInt16BE(6)
+
+  if (rcode !== 0) return { rcode, answers: [] }
+
+  let offset = 12
+  for (let i = 0; i < qdcount; i++) {
+    const { end } = readWireName(packet, offset)
+    offset = end + 4
+  }
+
+  const answers = []
+  for (let i = 0; i < ancount; i++) {
+    const { bytes: ownerBytes, end: nameEnd } = readWireName(packet, offset)
+    offset = nameEnd
+    const typeId = packet.readUInt16BE(offset)
+    const cls = packet.readUInt16BE(offset + 2)
+    const rdlen = packet.readUInt16BE(offset + 8)
+    const rdataOffset = offset + 10
+    const rdataBytes = decompressRdata(packet, rdataOffset, rdlen, typeId)
+    offset += 10 + rdlen
+    answers.push({ ownerBytes, typeId, cls, rdataBytes })
+  }
+
+  return { rcode: 0, answers }
+}
+
+// ── Uncompressed domain name decoding ────────────────────────────────────────
+
+/**
+ * Decode a length-prefixed (uncompressed) DNS name from a Uint8Array.
+ * Returns { fqdn: string, end: number } where end is the offset after the name.
+ */
+export function wireUnpackDomain(bytes, offset = 0) {
+  const labels = []
+  let pos = offset
+  while (pos < bytes.length) {
+    const len = bytes[pos]
+    if (len === 0) {
+      pos++
+      break
+    }
+    labels.push(new TextDecoder().decode(bytes.subarray(pos + 1, pos + 1 + len)))
+    pos += 1 + len
+  }
+  return { fqdn: labels.length ? labels.join('.') + '.' : '.', end: pos }
+}
+
+/**
+ * Pack a fully qualified domain name into wire format (Uint8Array).
+ * Domain labels are prefixed with their length; the name ends with a zero byte.
+ */
+export function wirePackDomain(fqdn) {
+  if (fqdn === '.') return new Uint8Array([0])
+  const enc = new TextEncoder()
+  const labels = fqdn
+    .split('.')
+    .filter((p) => p.length > 0)
+    .map((p) => {
+      const b = enc.encode(p)
+      if (b.length > 63) throw new Error(`DNS label exceeds 63 bytes: ${p}`)
+      return b
+    })
+
+  const buf = new Uint8Array(labels.reduce((n, b) => n + b.length + 1, 1))
+  let offset = 0
+  for (const b of labels) {
+    buf[offset++] = b.length
+    buf.set(b, offset)
+    offset += b.length
+  }
+  buf[offset] = 0
+  return buf
+}
+
+/**
+ * Get wire format rdata for an RR instance.
+ * Derived classes should override this with direct RFC 1035 wire encoding.
+ * Fallback uses toTinydns() as an intermediate (less efficient but works for all types).
+ */
+export function getWireRdata(rrInstance) {
+  const line = rrInstance.toTinydns()
+  if (!line.startsWith(':')) {
+    throw new Error(
+      `${rrInstance.get('type')}: getWireRdata() not implemented. Override in rr/${rrInstance.get('type').toLowerCase()}.js`,
+    )
+  }
+  // line: :fqdn:typeId:rdata:ttl:ts:loc\n
+  // Extract octal-encoded rdata and decode
+  const rdata = line.split(':')[3]
+  return rrInstance.octalToUint8Array(rdata ?? '')
+}
+
+/**
+ * Serialize an RR instance to DNS wire format (RFC 1035).
+ * Combines owner name, type, class, TTL, and rdata.
+ */
+export function toWire(rrInstance, RRClasses) {
+  const rdata = rrInstance.getWireRdata()
+  const owner = wirePackDomain(rrInstance.get('owner'))
+  const result = new Uint8Array(owner.length + 10 + rdata.length)
+  result.set(owner, 0)
+  const meta = new DataView(result.buffer, owner.length, 10)
+  meta.setUint16(0, rrInstance.getTypeId())
+  meta.setUint16(2, RRClasses[rrInstance.get('class')] ?? 1)
+  meta.setUint32(4, rrInstance.get('ttl'))
+  meta.setUint16(8, rdata.length)
+  result.set(rdata, owner.length + 10)
+  return result
+}
+
+/**
+ * Deserialize wire format bytes into an RR instance.
+ * Static method wrapper for RR.fromWire().
+ */
+export function fromWireBytes(RRConstructor, wireBytes, wireUnpackFn) {
+  const instance = new RRConstructor(null)
+  const bytes = wireBytes instanceof Uint8Array ? wireBytes : new Uint8Array(wireBytes)
+  const { fqdn: owner, end } = wireUnpackFn(bytes, 0)
+  const view = new DataView(bytes.buffer, bytes.byteOffset)
+  const classNum = view.getUint16(end + 2)
+  const RRClasses = { IN: 1, CS: 2, CH: 3, HS: 4, NONE: 254, ANY: 255 }
+  const cls = Object.keys(RRClasses).find((k) => RRClasses[k] === classNum) ?? 'IN'
+  const ttl = view.getUint32(end + 4)
+  const rdlen = view.getUint16(end + 8)
+  const rdata = bytes.slice(end + 10, end + 10 + rdlen)
+  return instance.fromWire({ owner, cls, ttl, rdata })
+}
+
+/**
+ * Generic fromWire decoder driven by rdataFields type annotations.
+ * Supports u8, u16, u32, fqdn, hex, base64, str, qstr, charstr, qcharstr, charstrs, svcparams, ipv4, ipv6.
+ * See rr/TEMPLATE.js for descriptions and example type usage.
+ * Last typed field consumes all remaining bytes.
+ */
+export function fromWireGeneric(rrInstance, { owner, cls, ttl, rdata }) {
+  const result = { owner, ttl, class: cls, type: rrInstance.constructor.typeName }
+  const rdataFields = rrInstance.constructor.rdataFields ?? []
+  const dv = new DataView(rdata.buffer, rdata.byteOffset)
+  let pos = 0
+
+  for (let i = 0; i < rdataFields.length; i++) {
+    const entry = rdataFields[i]
+    const fieldName = Array.isArray(entry) ? entry[0] : entry
+    const fieldType = Array.isArray(entry) ? entry[1] : null
+
+    switch (fieldType) {
+      case 'u8':
+        result[fieldName] = rdata[pos++]
+        break
+      case 'u16':
+        result[fieldName] = dv.getUint16(pos)
+        pos += 2
+        break
+      case 'certtype': {
+        const certTypeNum = dv.getUint16(pos)
+        const reverse = rrInstance.constructor.CERT_TYPES_REVERSE
+        result[fieldName] = reverse?.[certTypeNum] ?? certTypeNum
+        pos += 2
+        break
+      }
+      case 'u32':
+        result[fieldName] = dv.getUint32(pos)
+        pos += 4
+        break
+      case 'fqdn': {
+        const { fqdn, end } = wireUnpackDomain(rdata, pos)
+        result[fieldName] = fqdn
+        pos = end
+        break
+      }
+      case 'hex':
+        result[fieldName] = bytesToHex(rdata.subarray(pos)).toUpperCase()
+        pos = rdata.length
+        break
+      case 'base64':
+        result[fieldName] = bytesToBase64(rdata.subarray(pos))
+        pos = rdata.length
+        break
+      case 'str':
+        result[fieldName] = new TextDecoder().decode(rdata.subarray(pos))
+        pos = rdata.length
+        break
+      case 'qstr':
+        result[fieldName] = new TextDecoder().decode(rdata.subarray(pos))
+        pos = rdata.length
+        break
+      case 'charstr': {
+        const strLen = rdata[pos++]
+        result[fieldName] = new TextDecoder().decode(rdata.subarray(pos, pos + strLen))
+        pos += strLen
+        break
+      }
+      case 'qcharstr': {
+        const strLen = rdata[pos++]
+        result[fieldName] = new TextDecoder().decode(rdata.subarray(pos, pos + strLen))
+        pos += strLen
+        break
+      }
+      case 'charstrs': {
+        const parts = []
+        while (pos < rdata.length) {
+          const strLen = rdata[pos++]
+          parts.push(new TextDecoder().decode(rdata.subarray(pos, pos + strLen)))
+          pos += strLen
+        }
+        result[fieldName] = parts.join('')
+        break
+      }
+      case 'svcparams':
+        result[fieldName] = svcParamsFromWire(rdata.subarray(pos))
+        pos = rdata.length
+        break
+      case 'ipv4':
+        result[fieldName] = [...rdata.subarray(pos, pos + 4)].join('.')
+        pos += 4
+        break
+      case 'ipv6': {
+        const parts = []
+        for (let j = 0; j < 16; j += 2) {
+          parts.push(
+            dv
+              .getUint16(pos + j)
+              .toString(16)
+              .padStart(4, '0'),
+          )
+        }
+        result[fieldName] = parts.join(':')
+        pos += 16
+        break
+      }
+      default:
+        result[fieldName] = rdata[pos++]
+        break
+    }
+  }
+
+  return new rrInstance.constructor(result)
+}
+
+// ── SVCB/HTTPS parameter encoding (RFC 9460) ─────────────────────────────────
+
+const SVCPARAM_KEYS = {
+  mandatory: 0,
+  alpn: 1,
+  'no-default-alpn': 2,
+  port: 3,
+  ipv4hint: 4,
+  ech: 5,
+  ipv6hint: 6,
+}
+
+/**
+ * Encode SVCB/HTTPS params string (e.g. 'alpn="h2,h3" port="8443"') to wire bytes.
+ */
+export function svcParamsToWire(paramsStr) {
+  if (!paramsStr || !paramsStr.trim()) return new Uint8Array(0)
+
+  const parts = []
+  // Match: key, key=unquoted, or key="quoted" tokens
+  const re = /([^\s=]+)(?:=(?:"([^"]*)"|(\S*)))?(?=\s|$)/g
+  let m
+  while ((m = re.exec(paramsStr.trim())) !== null) {
+    const key = m[1].toLowerCase()
+    const val = m[2] ?? m[3] ?? ''
+    const keyId = SVCPARAM_KEYS[key]
+    if (keyId === undefined) continue
+
+    let valBytes
+    if (keyId === 1) {
+      // alpn: comma-separated list, each entry length-prefixed
+      const enc = new TextEncoder()
+      const entries = val.split(',').map((e) => enc.encode(e.trim()))
+      const total = entries.reduce((s, e) => s + 1 + e.length, 0)
+      valBytes = new Uint8Array(total)
+      let p = 0
+      for (const e of entries) {
+        valBytes[p++] = e.length
+        valBytes.set(e, p)
+        p += e.length
+      }
+    } else if (keyId === 2) {
+      // no-default-alpn: no value
+      valBytes = new Uint8Array(0)
+    } else if (keyId === 3) {
+      // port: uint16
+      valBytes = new Uint8Array(2)
+      new DataView(valBytes.buffer).setUint16(0, parseInt(val, 10))
+    } else if (keyId === 4) {
+      // ipv4hint: one or more IPv4 addresses
+      const addrs = val.split(',').map((a) => a.trim().split('.').map(Number))
+      valBytes = new Uint8Array(addrs.length * 4)
+      addrs.forEach((addr, i) => addr.forEach((b, j) => (valBytes[i * 4 + j] = b)))
+    } else if (keyId === 5) {
+      // ech: base64-encoded ECH config
+      valBytes = base64ToBytes(val)
+    } else if (keyId === 6) {
+      // ipv6hint: one or more IPv6 addresses (expand compressed form before encoding)
+      const addrs = val.split(',').map((a) => hexToBytes(expandIPv6(a.trim(), '')))
+      valBytes = new Uint8Array(addrs.length * 16)
+      addrs.forEach((addr, i) => valBytes.set(addr, i * 16))
+    } else {
+      valBytes = new TextEncoder().encode(val)
+    }
+
+    const param = new Uint8Array(4 + valBytes.length)
+    new DataView(param.buffer).setUint16(0, keyId)
+    new DataView(param.buffer).setUint16(2, valBytes.length)
+    param.set(valBytes, 4)
+    parts.push(param)
+  }
+
+  // Sort by key ID (SvcParams MUST be in ascending order per RFC 9460)
+  parts.sort((a, b) => new DataView(a.buffer).getUint16(0) - new DataView(b.buffer).getUint16(0))
+
+  const total = parts.reduce((s, p) => s + p.length, 0)
+  const result = new Uint8Array(total)
+  let pos = 0
+  for (const p of parts) {
+    result.set(p, pos)
+    pos += p.length
+  }
+  return result
+}
+
+const SVCPARAM_KEY_NAMES = {
+  0: 'mandatory',
+  1: 'alpn',
+  2: 'no-default-alpn',
+  3: 'port',
+  4: 'ipv4hint',
+  5: 'ech',
+  6: 'ipv6hint',
+}
+
+/**
+ * Decode SVCB/HTTPS wire params bytes back to a human-readable params string.
+ */
+export function svcParamsFromWire(bytes) {
+  if (!bytes || bytes.length === 0) return ''
+  const parts = []
+  let pos = 0
+  while (pos + 4 <= bytes.length) {
+    const dv = new DataView(bytes.buffer, bytes.byteOffset + pos)
+    const keyId = dv.getUint16(0)
+    const valLen = dv.getUint16(2)
+    const val = bytes.subarray(pos + 4, pos + 4 + valLen)
+    pos += 4 + valLen
+
+    const keyName = SVCPARAM_KEY_NAMES[keyId] ?? `key${keyId}`
+    if (keyId === 1) {
+      // alpn: comma-separated length-prefixed entries
+      const entries = []
+      let p = 0
+      while (p < val.length) {
+        const len = val[p++]
+        entries.push(new TextDecoder().decode(val.subarray(p, p + len)))
+        p += len
+      }
+      parts.push(`alpn="${entries.join(',')}"`)
+    } else if (keyId === 2) {
+      parts.push('no-default-alpn')
+    } else if (keyId === 3) {
+      parts.push(`port=${new DataView(val.buffer, val.byteOffset).getUint16(0)}`)
+    } else if (keyId === 4) {
+      const addrs = []
+      for (let i = 0; i < val.length; i += 4) addrs.push([...val.subarray(i, i + 4)].join('.'))
+      parts.push(`ipv4hint=${addrs.join(',')}`)
+    } else if (keyId === 5) {
+      parts.push(`ech=${btoa([...val].map((b) => String.fromCharCode(b)).join(''))}`)
+    } else if (keyId === 6) {
+      const addrs = []
+      for (let i = 0; i < val.length; i += 16) {
+        const dv16 = new DataView(val.buffer, val.byteOffset + i)
+        const groups = []
+        for (let j = 0; j < 16; j += 2) groups.push(dv16.getUint16(j).toString(16).padStart(4, '0'))
+        addrs.push(groups.join(':'))
+      }
+      parts.push(`ipv6hint=${addrs.join(',')}`)
+    } else {
+      parts.push(`${keyName}=${[...val].map((b) => b.toString(16).padStart(2, '0')).join('')}`)
+    }
+  }
+  return parts.join(' ')
+}

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@nictool/dns-resource-record",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "DNS Resource Records",
   "main": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./dist/dns-rr.min.js",
+      "default": "./index.js"
+    }
+  },
   "files": [
+    "dist",
     "lib",
     "rr",
     "CHANGELOG.md",
@@ -11,14 +18,15 @@
   ],
   "type": "module",
   "scripts": {
-    "build": "node lib/readme.js",
-    "clean": "rm -rf coverage node_modules package-lock.json",
+    "build": "npm run build:browser",
+    "build:browser": "npx rollup -i index.js -o dist/dns-rr.js -f es && esbuild dist/dns-rr.js --minify --sourcemap --outfile=dist/dns-rr.min.js && rm dist/dns-rr.js",
+    "clean": "rm -rf coverage dist node_modules package-lock.json",
     "format:check": "npm run prettier; npm run lint",
     "format": "npm run prettier -- --write && npm run lint:fix",
-    "lint": "npx eslint **/*.js",
+    "lint": "npx eslint **/*.js --no-warn-ignored",
     "lint:fix": "npm run lint -- --fix",
-    "prettier": "npx prettier --ignore-path .gitignore --check .",
-    "prettier:fix": "npx prettier --ignore-path .gitignore --write .",
+    "prettier": "npx prettier --check .",
+    "prettier:fix": "npx prettier --write .",
     "test": "node --test",
     "test:coverage": "node --test --experimental-test-coverage",
     "test:coverage:lcov": "mkdir -p coverage && node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info",
@@ -49,6 +57,15 @@
     "url": "https://github.com/NicTool/dns-resource-record/issues"
   },
   "homepage": "https://github.com/NicTool/dns-resource-record#readme",
+  "engines": {
+    "node": ">=22"
+  },
+  "browserslist": [
+    "chrome >= 74",
+    "firefox >= 90",
+    "safari >= 14.1",
+    "edge >= 79"
+  ],
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "eslint": "^10.2.1",

package/rr/TEMPLATE.js

@@ -0,0 +1,124 @@
+import RR from '../rr.js'
+
+/**
+ * DNS Resource Record Template
+ *
+ * Use this as a starting point for creating a new Resource Record (RR) class.
+ * Replace 'TEMPLATE' with the actual record type (e.g., 'MX', 'SRV').
+ *
+ * ## Mandates
+ * - Every new RR MUST extend the `RR` class.
+ * - 100% test coverage is required for all new PRs.
+ * - Follow established patterns for naming and implementation.
+ * - **Registration**: You MUST update `index.js` to import and export the new class and add it to the `classes` array.
+ * - **Tests**: You MUST create a corresponding test file in `test/rr/<type>.js` (mirroring an existing test file like `test/rr/a.js`).
+ *
+ * ## `rdataFields` and Avoiding Boilerplate
+ * The `rdataFields` static property defines the fields in the RDATA section.
+ * It is an array where each element can be:
+ *   - A string: The field name.
+ *   - An array: `[fieldName, type]`
+ *
+ * Supported types for `setTypedValue`:
+ *   - `u8`, `u16`, `u32`: Unsigned integers of 8, 16, or 32 bits.
+ *   - `fqdn`: A fully qualified domain name.
+ *   - `qstr`: Quoted string field (BIND quoting behavior).
+ *   - `charstr`: DNS length-prefixed character-string (max 255 bytes).
+ *   - `qcharstr`: Quoted DNS length-prefixed character-string.
+ *   - `charstrs`: Concatenated DNS character-strings.
+ *   - `svcparams`: SVCB/HTTPS params string.
+ *   - `base64`: Base64 encoded data.
+ *   - `hex`: Hexadecimal encoded data.
+ *   - `str`: A simple string.
+ *   - `ipv4`: An IPv4 address.
+ *   - `ipv6`: An IPv6 address.
+ *
+ * If you provide a type in `rdataFields`, the base `RR` class automatically
+ * handles validation and setting of that field. You only need to implement
+ * a custom `set<FieldName>` method if you need more complex validation
+ * logic than what the default types provide.
+ */
+
+export default class TEMPLATE extends RR {
+  // The DNS record type name (e.g., 'A', 'MX', 'TXT')
+  static typeName = 'TEMPLATE'
+  static typeId = 0
+  static RFCs = []
+  static tags = []
+
+  // The character used in tinydns format (optional)
+  static tinydnsType = 'T'
+
+  // Define the RDATA fields.
+  // Using types here avoids the need for manual setters in many cases.
+  static rdataFields = [
+    ['field1', 'u16'],
+    ['field2', 'fqdn'],
+  ]
+
+  constructor(opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+
+  /*
+  // Example of a custom setter. Only implement if default validation
+  // from `rdataFields` is insufficient.
+  setField1(val) {
+    if (val === undefined) val = this?.default?.field1
+    if (val === undefined) this.throwHelp('TEMPLATE: field1 is required')
+    this.is16bitInt('TEMPLATE', 'field1', val)
+    this.set('field1', parseInt(val, 10))
+  }
+  */
+
+  /****** Metadata (Required) *******/
+
+  getDescription() {
+    return 'Short description of the TEMPLATE record'
+  }
+
+  getCanonical() {
+    // Returns a sample object representing a valid record.
+    // This is used for documentation and testing.
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'TEMPLATE',
+      field1: 10,
+      field2: 'target.example.com.',
+    }
+  }
+
+  /******  IMPORTERS / EXPORTERS (Recommended) *******/
+
+  /*
+  // Optional: Override if generic implementation in RR.js is insufficient
+  fromTinydns({ tinyline }) {
+     // Implementation...
+  }
+  */
+
+  /*
+  // Optional: Override if generic implementation in RR.js is insufficient
+  toTinydns() {
+    // Implementation...
+  }
+  */
+
+  getWireRdata() {
+    // MUST be implemented for binary/wire format support.
+    // Returns a Uint8Array.
+    // Example:
+    /*
+    const domain = this.wirePackDomain(this.get('field2'))
+    const result = new Uint8Array(2 + domain.length)
+    new DataView(result.buffer).setUint16(0, this.get('field1'))
+    result.set(domain, 2)
+    return result
+    */
+    throw new Error('getWireRdata not implemented')
+  }
+}