@openclaw/lobster 2026.9.6 → 2026.9.8

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/lib/schemes.js

@@ -290,6 +290,7 @@ const DTEXT_IRI = allowSet(DTEXT_ALLOWED, true)
 const HEX_PAIR = /^[\da-f]{2}$/iu
 const MAILTO_DOMAIN_LITERAL = /^\[[\x21-\x5A\x5E-\x7E]*\]$/u
 const MAILTO_DOMAIN_ERROR = 'URI mailto has an invalid recipient domain.'
+const MAILTO_AUTHORITY_ERROR = 'URI mailto must not have an authority component.'
 const HAS_SURROGATE = /[\uD800-\uDFFF]/u
 
 /**
@@ -495,29 +496,51 @@ function mailtoParse (component, options) {
         mailtoComponent.error = mailtoComponent.error || 'URI mailto has malformed header fields.'
         continue
       }
-      const name = eqIdx === -1 ? token : token.slice(0, eqIdx)
+      const name = decodeHex(eqIdx === -1 ? token : token.slice(0, eqIdx))
+      const normalizedName = name.toLowerCase()
       const value = eqIdx === -1 ? '' : token.slice(eqIdx + 1)
-      if (name === 'to') {
+      if (normalizedName === 'to') {
         const addrs = value.split(',')
         for (let j = 0; j < addrs.length; j++) to.push(addrs[j])
         continue
       }
-      if (name === 'subject') {
+      if (normalizedName === 'subject') {
         mailtoComponent.subject = decodeHex(value)
         continue
       }
-      if (name === 'body') {
+      if (normalizedName === 'body') {
         mailtoComponent.body = decodeHex(value)
         continue
       }
       if (headers === null) headers = /** @type {Record<string,string>} */ (Object.create(null))
-      headers[decodeHex(name)] = decodeHex(value)
+      headers[name] = decodeHex(value)
     }
     if (headers !== null) mailtoComponent.headers = headers
   }
 
   mailtoComponent.query = undefined
 
+  // RFC 6068 defines no authority for the `mailto` scheme. A `mailto://` input
+  // that retains an authority and also carries recipients (from the path or a
+  // `to=` hfield) folds a leading "/" into the recipient local part on the
+  // next parse; the generic serializer then reinserts a "/" before that path
+  // on every pass, so serialize(parse(x)) is not a fixpoint and a
+  // renormalize-to-fixpoint loop accretes one "%2F" per pass. Drop the
+  // retained authority so the parse -> serialize round trip is stable. A bare
+  // `mailto://host` with no recipients is left as-is: it is idempotent and host
+  // normalization for skip-normalize schemes stays intact.
+  if (
+    to.length > 0 &&
+    (mailtoComponent.userinfo !== undefined ||
+      mailtoComponent.host !== undefined ||
+      mailtoComponent.port !== undefined)
+  ) {
+    mailtoComponent.userinfo = undefined
+    mailtoComponent.host = undefined
+    mailtoComponent.port = undefined
+    mailtoComponent.error = mailtoComponent.error || MAILTO_AUTHORITY_ERROR
+  }
+
   for (let i = 0; i < to.length; i++) {
     const rawAddr = to[i]
     const atIdx = rawAddr.lastIndexOf('@')
@@ -536,6 +559,18 @@ function mailtoParse (component, options) {
   return mailtoComponent
 }
 
+/**
+ * Encodes a decoded mailto header name. Unlike `encodeWithAllow`, a percent
+ * sign is always data here, even when followed by two hex digits. Preserving
+ * such a sequence as an existing escape would decode the name again on the
+ * next parse and could turn a generic header into `to`, `subject`, or `body`.
+ * @param {string} name
+ * @returns {string}
+ */
+function mailtoEncodeHeaderName (name) {
+  return encodeWithAllow(name.replace(/%/gu, '%25'), HFNAME)
+}
+
 /**
  * @param {import('../types/index').URIComponent} component
  * @param {import('../types/index').Options} options
@@ -544,7 +579,40 @@ function mailtoParse (component, options) {
 function mailtoSerialize (component, options) {
   const mailtoComponent = component
   const to = Array.isArray(mailtoComponent.to) ? mailtoComponent.to.slice() : []
+  const sourceHeaders = mailtoComponent.headers && typeof mailtoComponent.headers === 'object'
+    ? Object.assign(Object.create(null), mailtoComponent.headers)
+    : Object.create(null)
+  const headers = Object.create(null)
+
+  // Header field names are case-insensitive. Canonicalize the fields with
+  // dedicated component properties so callers cannot smuggle a second spelling
+  // through `headers`. As during parsing, all `to` fields are accumulated;
+  // repeated subject/body fields use the last value.
+  for (const name in sourceHeaders) {
+    const normalizedName = name.toLowerCase()
+    if (normalizedName === 'to') {
+      const addrs = String(sourceHeaders[name]).split(',')
+      for (let i = 0; i < addrs.length; i++) to.push(addrs[i])
+    } else if (normalizedName === 'subject' || normalizedName === 'body') {
+      headers[normalizedName] = sourceHeaders[name]
+    } else {
+      headers[name] = sourceHeaders[name]
+    }
+  }
+
+  if (mailtoComponent.subject !== undefined) headers.subject = mailtoComponent.subject
+  if (mailtoComponent.body !== undefined) headers.body = mailtoComponent.body
+  mailtoComponent.headers = headers
+
   if (to.length) {
+    // RFC 6068 defines no authority for the `mailto` scheme. If an
+    // application constructs a component with both an authority and recipients,
+    // drop the authority before the generic serializer can insert a "/" path
+    // separator that becomes part of the first recipient on the next parse.
+    mailtoComponent.userinfo = undefined
+    mailtoComponent.host = undefined
+    mailtoComponent.port = undefined
+
     for (let i = 0; i < to.length; i++) {
       const addr = String(to[i])
       const atIdx = addr.lastIndexOf('@')
@@ -570,21 +638,13 @@ function mailtoSerialize (component, options) {
     mailtoComponent.path = undefined
   }
 
-  const headers = mailtoComponent.headers && typeof mailtoComponent.headers === 'object'
-    ? Object.assign(Object.create(null), mailtoComponent.headers)
-    : Object.create(null)
-
-  if (mailtoComponent.subject) headers.subject = mailtoComponent.subject
-  if (mailtoComponent.body) headers.body = mailtoComponent.body
-  mailtoComponent.headers = headers
-
-  // `headers` has a null prototype and was filled via Object.assign, so every
-  // enumerable key is an own property and no hasOwnProperty guard is needed.
+  // `headers` has a null prototype, so every enumerable key is an own property
+  // and no hasOwnProperty guard is needed.
   let query = ''
   let count = 0
   for (const name in headers) {
     if (count++ !== 0) query += '&'
-    query += encodeWithAllow(name, HFNAME) + '=' + encodeWithAllow(String(headers[name]), HFNAME)
+    query += mailtoEncodeHeaderName(name) + '=' + encodeWithAllow(String(headers[name]), HFNAME)
   }
 
   if (count !== 0) {

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/lib/utils.js

@@ -740,6 +740,37 @@ function escapePreservingEscapes (input) {
   return output
 }
 
+/**
+ * Rebuilds the bracketed form of a zoned IPv6 authority from the current
+ * `component.host` and its zone identifier (`component.ipv6Zone`), but only
+ * when they are consistent and describe a real zoned IPv6 literal that
+ * normalizes back to `component.host`. This validates the zone on use, so a
+ * caller-supplied `ipv6Zone` that does not match the host (or a host
+ * reassigned after `parse`) is never trusted and recomposition falls back to
+ * the normal path.
+ *
+ * @param {import('../types/index').URIComponent} component
+ * @returns {string|undefined}
+ */
+function recomposeZonedIPv6Host (component) {
+  const zone = component.ipv6Zone
+  // Without an ipv6Zone the single-"%" host form is genuinely ambiguous when
+  // the zone begins with "25", so we fall through to the best-effort heuristic
+  // (which matches the pre-existing behavior for hand-built components that do
+  // not carry a zone).
+  if (zone === undefined) return undefined
+  const host = component.host
+  const separator = host.indexOf('%')
+  if (separator === -1) return undefined
+  const address = host.slice(0, separator)
+  const escaped = address + '%25' + zone
+  const derived = normalizeIPv6('[' + escaped + ']')
+  if (derived.isIPV6 === true && derived.host === host) {
+    return '[' + escaped + ']'
+  }
+  return undefined
+}
+
 /**
  * @param {import('../types/index').URIComponent} component
  * @returns {string|undefined}
@@ -755,17 +786,30 @@ function recomposeAuthority (component) {
   if (component.host !== undefined) {
     let host = component.host
     if (!isIPv4(host)) {
-      let ipV6res = normalizeIPv6(host)
-      if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
-        // Decode only unreserved bytes, once. In particular, keep %25 encoded
-        // so it cannot introduce a second escape during recomposition.
-        host = normalizePercentEncoding(host, true)
-        ipV6res = normalizeIPv6(host)
-      }
-      if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
-        host = `[${ipV6res.escapedHost}]`
+      // A parse-time zone identifier is authoritative only while it still
+      // describes the current host. Re-deriving an IPv6 zone from the
+      // single-"%" component form is ambiguous when the zone begins with
+      // "25": it is misread as a %25 separator, rewriting e.g. zone
+      // "25eth0" into "eth0" (or destroying a zone of just "25"). A
+      // validated zone keeps parse, normalize, serialize and equal in
+      // agreement.
+      const zonedHost = recomposeZonedIPv6Host(component)
+      if (zonedHost !== undefined) {
+        host = zonedHost
       } else {
-        host = reescapeHostDelimiters(host, false)
+        let ipV6res = normalizeIPv6(host)
+        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+          // Decode only unreserved bytes, once. In particular, keep %25
+          // encoded so it cannot introduce a second escape during
+          // recomposition.
+          host = normalizePercentEncoding(host, true)
+          ipV6res = normalizeIPv6(host)
+        }
+        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
+          host = `[${ipV6res.escapedHost}]`
+        } else {
+          host = reescapeHostDelimiters(host, false)
+        }
       }
     }
     uriTokens.push(host)

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fast-uri",
   "description": "Dependency-free RFC 3986 URI toolbox",
-  "version": "4.1.4",
+  "version": "4.2.1",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/fixtures/uri-js-parse.json

@@ -43,6 +43,7 @@
     "//[2001:db8::7%en0]",
     {
       "host": "2001:db8::7%en0",
+      "ipv6Zone": "en0",
       "path": "",
       "reference": "relative"
     }

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/ipv6-validation.test.js

@@ -119,6 +119,136 @@ test('IPv6 zone identifiers are validated correctly', (t) => {
   t.end()
 })
 
+test('zoned IPv6 hosts beginning with "25" round-trip through parse/normalize/serialize/equal', (t) => {
+  const cases = [
+    // zones beginning with "25" (once ambiguous with a %25 separator)
+    ['http://[fe80::1%2525]/', 'fe80::1%25', 'http://[fe80::1%2525]/'],
+    ['http://[fe80::1%2525eth0]/', 'fe80::1%25eth0', 'http://[fe80::1%2525eth0]/'],
+    ['http://[fe80::1%2525en1]/', 'fe80::1%25en1', 'http://[fe80::1%2525en1]/'],
+    // zones that do not begin with "25" must stay idempotent
+    ['http://[fe80::1%25eth0]/', 'fe80::1%eth0', 'http://[fe80::1%25eth0]/'],
+    ['http://[fe80::a%en1]/', 'fe80::a%en1', 'http://[fe80::a%25en1]/'],
+    ['http://[fe80::a%25eth%2D0]/', 'fe80::a%eth%2D0', 'http://[fe80::a%25eth%2D0]/']
+  ]
+
+  for (const [input, host, normalized] of cases) {
+    const parsed = fastURI.parse(input)
+    t.equal(parsed.error, undefined, `${input} parses without error`)
+    t.equal(parsed.host, host, `${input} exposes the expected host`)
+    t.equal(fastURI.normalize(input), normalized, `${input} normalizes to the canonical form`)
+    t.equal(fastURI.serialize(parsed), normalized, `${input} serializes to the canonical form`)
+    const reparsed = fastURI.parse(normalized)
+    t.equal(reparsed.error, undefined, `${input} canonical output reparses without error`)
+    t.equal(reparsed.host, host, `${input} parse-after-normalize is stable`)
+  }
+
+  // distinct zones must not be conflated by equal
+  t.equal(
+    fastURI.equal('http://[fe80::1%2525eth0]/', 'http://[fe80::1%25eth0]/'),
+    false,
+    'equal distinguishes zones "25eth0" and "eth0"'
+  )
+  t.equal(
+    fastURI.equal('http://[fe80::1%2525]/', 'http://[fe80::1%25eth0]/'),
+    false,
+    'equal distinguishes zones "25" and "eth0"'
+  )
+  // the same zone still compares equal
+  t.equal(
+    fastURI.equal('http://[fe80::1%2525eth0]/', 'http://[fe80::1%2525eth0]/'),
+    true,
+    'an identical zoned authority is equal'
+  )
+  t.equal(
+    fastURI.equal('http://[fe80::1%2525]/', 'http://[fe80::1%2525]/'),
+    true,
+    'zone "25" equals itself'
+  )
+
+  // resolve must preserve the zone too
+  t.equal(
+    fastURI.resolve('http://example.com/', 'http://[fe80::1%2525eth0]/path'),
+    'http://[fe80::1%2525eth0]/path',
+    'resolve preserves a zone beginning with "25"'
+  )
+  t.equal(
+    fastURI.resolve('http://[fe80::1%2525eth0]/', 'child'),
+    'http://[fe80::1%2525eth0]/child',
+    'resolve preserves a zoned base'
+  )
+
+  t.end()
+})
+
+test('serialize only trusts the parse-derived IPv6 zone while the host is unchanged', (t) => {
+  // Reassigning `host` after parse must take effect for serialize.
+  const parsed = fastURI.parse('http://[::1]/admin')
+  parsed.host = 'example.com'
+  t.equal(
+    fastURI.serialize(parsed),
+    'http://example.com/admin',
+    'a host reassigned after parse wins over the stale zone'
+  )
+
+  // A caller-supplied `ipv6Zone` that does not match `host` must be ignored.
+  const forged = fastURI.serialize({
+    scheme: 'http',
+    host: 'fe80::1%25en1',
+    ipv6Zone: 'eth0',
+    path: '/'
+  })
+  t.equal(forged, 'http://[fe80::1%25en1]/', 'a mismatched ipv6Zone is ignored')
+  t.equal(fastURI.parse(forged).host, 'fe80::1%en1', 'mismatched ipv6Zone cannot redirect the parsed host')
+
+  // A caller-supplied `ipv6Zone` on a non-zoned host must be ignored too.
+  const noZone = fastURI.serialize({
+    scheme: 'http',
+    host: 'good.example',
+    ipv6Zone: 'eth0',
+    path: '/'
+  })
+  t.equal(noZone, 'http://good.example/', 'ipv6Zone on a non-zoned host is ignored')
+
+  // Reassigning a zoned host to a different zone must recompute, not reuse.
+  const zoned = fastURI.parse('http://[fe80::1%2525eth0]/')
+  zoned.host = 'fe80::1%25en1'
+  t.equal(
+    fastURI.serialize(zoned),
+    'http://[fe80::1%25en1]/',
+    'rewriting the zone recomposes from the new host'
+  )
+
+  // A consistent caller-supplied zone is honored (explicit disambiguation).
+  const disambiguated = fastURI.serialize({
+    scheme: 'http',
+    host: 'fe80::1%25eth0',
+    ipv6Zone: '25eth0',
+    path: '/'
+  })
+  t.equal(
+    disambiguated,
+    'http://[fe80::1%2525eth0]/',
+    'a consistent ipv6Zone disambiguates the component host'
+  )
+
+  // Without ipv6Zone, an ambiguous single-"%" host falls back to the
+  // best-effort heuristic (documented behavior for hand-built components).
+  t.equal(
+    fastURI.serialize({ host: 'fe80::1%25eth0' }),
+    '//[fe80::1%25eth0]',
+    'an ambiguous host without ipv6Zone uses the best-effort heuristic'
+  )
+
+  // Mutating the host must not poison resolve either.
+  t.equal(
+    fastURI.resolve('http://example.com/', 'http://[fe80::1%2525eth0]/path'),
+    'http://[fe80::1%2525eth0]/path',
+    'resolve preserves the parse-derived zone'
+  )
+
+  t.end()
+})
+
 test('hosts with unbalanced or misplaced IP-literal brackets are rejected', (t) => {
   const malformed = [
     'http://[fe80',

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/mailto-authority-security.test.js

@@ -0,0 +1,125 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+// GHSA-88VG-QFHM-JX5Q: `mailto://h/a` carries an authority (which RFC 6068 does
+// not define for `mailto`) and a path. `mailtoParse` used to retain that
+// authority and fold the path's leading "/" into the recipient local part; the
+// generic serializer then reinserted a "/" separator on every pass, so
+// serialize(parse(x)) was not a fixpoint and normalize() accreted one "%2F" per
+// pass (unbounded growth for a renormalize-to-fixpoint consumer).
+
+const authorityForms = [
+  ['mailto://h/a', 'mailto:%2Fa@'],
+  ['mailto://h/a@b', 'mailto:%2Fa@b'],
+  ['mailto://h/', 'mailto:%2F@'],
+  ['mailto://h/a,b', 'mailto:%2Fa@,b@'],
+  ['mailto://user@h/a', 'mailto:%2Fa@'],
+  ['mailto://h:8080/a', 'mailto:%2Fa@'],
+  ['mailto://', 'mailto://'],
+  // recipients can come from a `to=` hfield even when the path is empty
+  ['mailto://h?to=x@y', 'mailto:x@y'],
+  ['mailto://h?to=x@y&to=a@b', 'mailto:x@y,a@b']
+]
+
+test('mailto with a retained authority and a path normalizes to a fixpoint', (t) => {
+  t.plan(authorityForms.length * 2)
+
+  for (const [input] of authorityForms) {
+    const once = fastURI.normalize(input)
+    const twice = fastURI.normalize(once)
+
+    t.equal(twice, once, input + ' normalize is idempotent')
+    t.equal(fastURI.equal(input, once), true, input + ' equals its normalized form')
+  }
+})
+
+test('mailto serialize(parse()) is a stable round trip for the authority form', (t) => {
+  t.plan(authorityForms.length)
+
+  for (const [input, expected] of authorityForms) {
+    t.equal(fastURI.serialize(fastURI.parse(input)), expected, input + ' round trips to a stable value')
+  }
+})
+
+test('mailto authority form does not grow without bound under renormalization', (t) => {
+  // A renormalize-to-fixpoint loop must terminate instead of growing forever.
+  // A single normalize call already terminates, so this guards the fixpoint.
+  const inputs = ['mailto://h/a', 'mailto://h/a@b', 'mailto://h/a,b']
+
+  t.plan(inputs.length * 2)
+
+  for (const input of inputs) {
+    const first = fastURI.normalize(input)
+    let s = input
+    let iters = 0
+    let stable = false
+    while (iters < 1000) {
+      const next = fastURI.normalize(s)
+      if (next === s) {
+        stable = true
+        break
+      }
+      s = next
+      iters++
+    }
+
+    t.equal(stable, true, input + ' reaches a fixpoint')
+    t.equal(s.length, first.length, input + ' does not grow')
+  }
+})
+
+test('mailto authority handling preserves host normalization for skip-normalize schemes', (t) => {
+  // Regression: a bare `mailto://host` with no path must keep its host and stay
+  // idempotent, so the generic host normalization path is unaffected.
+  const encodedHost = 'mailto://%41.com'
+  const literalHost = 'mailto://a.com'
+
+  t.equal(fastURI.parse(encodedHost).host, fastURI.parse(literalHost).host, 'parse results have consistent hosts')
+  t.equal(fastURI.normalize(encodedHost), fastURI.normalize(literalHost), 'normalize results are consistent')
+  t.equal(fastURI.equal(encodedHost, literalHost), true, 'encoded and literal hosts compare equal')
+  t.equal(fastURI.normalize(literalHost), literalHost, 'bare authority mailto is idempotent')
+  t.end()
+})
+
+test('mailto authority form is reported as malformed on the parsed component', (t) => {
+  t.equal(
+    fastURI.parse('mailto://h/a').error,
+    'URI mailto must not have an authority component.',
+    'the retained authority is surfaced as an error'
+  )
+
+  // A valid, authority-free mailto must not be flagged.
+  t.equal(fastURI.parse('mailto:user@host.com').error, undefined, 'well-formed mailto has no error')
+  t.end()
+})
+
+test('mailto serializer drops caller-supplied authority when recipients are present', (t) => {
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h', to: ['a@b'] }),
+    'mailto:a@b',
+    'authority is dropped for direct recipients'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', userinfo: 'u', host: 'h', port: 8080, to: ['a@b'] }),
+    'mailto:a@b',
+    'userinfo, host, and port are dropped for direct recipients'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h', headers: { to: 'a@b' } }),
+    'mailto:a@b',
+    'authority is dropped for recipients supplied through a to hfield'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h', to: ['a@b'], subject: 'hello' }),
+    'mailto:a@b?subject=hello',
+    'dropping authority preserves header fields'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h' }),
+    'mailto://h',
+    'bare authority without recipients remains idempotent'
+  )
+  t.end()
+})

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/mailto-field-name-security.test.js

@@ -0,0 +1,151 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+function encodeCharacter (value, index, lowercaseHex) {
+  let hex = value.charCodeAt(index).toString(16)
+  if (!lowercaseHex) hex = hex.toUpperCase()
+  return value.slice(0, index) + '%' + hex + value.slice(index + 1)
+}
+
+function mailtoState (component) {
+  return {
+    to: component.to,
+    subject: component.subject,
+    body: component.body,
+    headers: component.headers && { ...component.headers }
+  }
+}
+
+test('mailto parsing classifies decoded, case-insensitive reserved field names', (t) => {
+  const cases = [
+    { name: 'to', value: 'attacker@evil.test', property: 'to' },
+    { name: 'subject', value: 'injected subject', property: 'subject' },
+    { name: 'body', value: 'injected body', property: 'body' }
+  ]
+
+  for (const entry of cases) {
+    const variants = new Set([entry.name.toUpperCase()])
+    for (let i = 0; i < entry.name.length; i++) {
+      variants.add(encodeCharacter(entry.name, i, false))
+      variants.add(encodeCharacter(entry.name, i, true))
+    }
+
+    for (const name of variants) {
+      const parsed = fastURI.parse(`mailto:alice@example.test?${name}=${entry.value}`)
+      if (entry.property === 'to') {
+        t.deepEqual(parsed.to, ['alice@example.test', entry.value], name + ' is classified as a recipient')
+      } else {
+        t.equal(parsed[entry.property], entry.value, name + ' is classified as ' + entry.property)
+      }
+      t.equal(parsed.headers, undefined, name + ' is not exposed as a generic header')
+
+      const reparsed = fastURI.parse(fastURI.serialize(parsed))
+      t.deepEqual(mailtoState(reparsed), mailtoState(parsed), name + ' keeps its meaning after a roundtrip')
+    }
+  }
+
+  t.end()
+})
+
+test('mailto generic field names are decoded exactly once across roundtrips', (t) => {
+  const cases = [
+    ['%2574o', '%74o'],
+    ['%2573ubject', '%73ubject'],
+    ['%2562ody', '%62ody'],
+    ['x%2520y', 'x%20y'],
+    ['%26to', '&to'],
+    ['%25GGto', '%GGto']
+  ]
+
+  for (const [encodedName, decodedName] of cases) {
+    let serialized = `mailto:alice@example.test?${encodedName}=value`
+    for (let round = 0; round < 3; round++) {
+      const parsed = fastURI.parse(serialized)
+      t.deepEqual({ ...parsed.headers }, { [decodedName]: 'value' }, encodedName + ' stays generic in round ' + round)
+      t.deepEqual(parsed.to, ['alice@example.test'], encodedName + ' does not add a recipient in round ' + round)
+      t.equal(parsed.subject, undefined, encodedName + ' does not set a subject in round ' + round)
+      t.equal(parsed.body, undefined, encodedName + ' does not set a body in round ' + round)
+      serialized = fastURI.serialize(parsed)
+    }
+    t.equal(serialized, `mailto:alice@example.test?${encodedName}=value`, encodedName + ' serializes idempotently')
+  }
+
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', to: ['alice@example.test'], headers: { '%74o': 'value' } }),
+    'mailto:alice@example.test?%2574o=value',
+    'a percent sequence in a decoded component key is encoded as data'
+  )
+  t.end()
+})
+
+test('mailto serialization canonicalizes reserved generic header names', (t) => {
+  const serialized = fastURI.serialize({
+    scheme: 'mailto',
+    to: ['alice@example.test'],
+    subject: 'safe subject',
+    body: 'safe body',
+    headers: {
+      TO: 'attacker@evil.test',
+      Subject: 'hidden subject',
+      BODY: 'hidden body',
+      cc: 'copy@example.test'
+    }
+  })
+
+  t.equal(
+    serialized,
+    'mailto:alice@example.test,attacker@evil.test?subject=safe%20subject&body=safe%20body&cc=copy@example.test',
+    'dedicated properties override header variants and all recipients are visible in the path'
+  )
+
+  const parsed = fastURI.parse(serialized)
+  t.deepEqual(parsed.to, ['alice@example.test', 'attacker@evil.test'], 'canonical recipients are classified consistently')
+  t.equal(parsed.subject, 'safe subject', 'the dedicated subject wins')
+  t.equal(parsed.body, 'safe body', 'the dedicated body wins')
+  t.deepEqual({ ...parsed.headers }, { cc: 'copy@example.test' }, 'only generic headers remain generic')
+
+  const empty = fastURI.serialize({
+    scheme: 'mailto',
+    to: ['alice@example.test'],
+    subject: '',
+    body: '',
+    headers: { Subject: 'hidden subject', BODY: 'hidden body' }
+  })
+  t.equal(empty, 'mailto:alice@example.test?subject=&body=', 'explicit empty properties override header variants')
+  const emptyParsed = fastURI.parse(empty)
+  t.equal(emptyParsed.subject, '', 'an empty subject round-trips')
+  t.equal(emptyParsed.body, '', 'an empty body round-trips')
+  t.end()
+})
+
+test('mailto duplicate reserved fields have deterministic parsing semantics', (t) => {
+  const parsed = fastURI.parse(
+    'mailto:alice@example.test?subject=first&%53UBJECT=last&body=first&%42ODY=last&to=one@example.test&%54O=two@example.test'
+  )
+
+  t.equal(parsed.subject, 'last', 'the last subject wins')
+  t.equal(parsed.body, 'last', 'the last body wins')
+  t.deepEqual(
+    parsed.to,
+    ['alice@example.test', 'one@example.test', 'two@example.test'],
+    'all recipient fields are accumulated'
+  )
+  t.equal(parsed.headers, undefined, 'no reserved spelling remains generic')
+  t.end()
+})
+
+test('encoded reserved field names expose decoded control characters immediately', (t) => {
+  const input = 'mailto:alice@example.test?%73ubject=hello%0D%0Aworld'
+  const parsed = fastURI.parse(input)
+
+  t.equal(parsed.subject, 'hello\r\nworld', 'the first parse exposes CRLF in the dedicated property')
+  t.equal(parsed.headers, undefined, 'the subject is not hidden as a generic header')
+  t.equal(
+    fastURI.parse(fastURI.serialize(parsed)).subject,
+    parsed.subject,
+    'the decoded subject remains stable after a roundtrip'
+  )
+  t.end()
+})