dsh-ptc-plus 0.4.1 → 0.4.3

package/internal/value-wire.js

@@ -1,4 +1,5 @@
 import { assertFields, isRecord } from './record-utils.js'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
 import {
   VALUE_CODEC,
   DEFAULT_VALUE_LIMITS,
@@ -12,12 +13,24 @@ import {
 } from './value-wire-schema.js'
 
 export { VALUE_CODEC, DEFAULT_VALUE_LIMITS } from './value-wire-schema.js'
+const { Object, Reflect, Array, Map, Set, WeakMap, WeakSet, TypeError,
+  isArray, numberIsFinite, numberIsNaN, numberIsSafeInteger, toBigInt,
+  toNumber, toString, regexpTest, mapGet, mapHas, mapSet, setHas, setAdd,
+  setDelete, weakMapGet, weakMapSet, weakSetHas, weakSetAdd,
+  appendArray, popArray, join } = internal
 const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+const intrinsicFunctionToString = Function.prototype.toString
+const reflectApply = Reflect.apply
+const bufferByteLength = internal.bufferByteLength
+const jsonStringify = JSON.stringify
 
 function limitsOf(options = {}) {
   const limits = { ...DEFAULT_VALUE_LIMITS, ...options }
-  for (const [name, value] of Object.entries(limits)) {
-    if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`invalid PTC value limit ${name}`)
+  const entries = Object.entries(limits)
+  for (let index = 0; index < entries.length; index += 1) {
+    const name = entries[index][0]
+    const value = entries[index][1]
+    if (!numberIsSafeInteger(value) || value < 1) throw new TypeError(`invalid PTC value limit ${name}`)
   }
   return limits
 }
@@ -28,7 +41,7 @@ function hasIntrinsicConstructor(prototype, name) {
   try {
     return constructor.name === name
       && constructor.prototype === prototype
-      && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`
+      && reflectApply(intrinsicFunctionToString, constructor, []) === `function ${name}() { [native code] }`
   } catch {
     return false
   }
@@ -47,7 +60,7 @@ function plainObjectPrototype(value) {
 
 function hasPlainArrayPrototype(value) {
   const prototype = Object.getPrototypeOf(value)
-  if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, 'Array')) return false
+  if (!isArray(prototype) || !hasIntrinsicConstructor(prototype, 'Array')) return false
   const objectPrototype = Object.getPrototypeOf(prototype)
   return objectPrototype !== null && typeof objectPrototype === 'object'
     && isIntrinsicObjectPrototype(objectPrototype)
@@ -58,7 +71,7 @@ function invalid(path, detail) {
 }
 
 function stringBytes(value) {
-  return Buffer.byteLength(value, 'utf8')
+  return bufferByteLength(value, 'utf8')
 }
 
 /** Encode one supported JavaScript graph into the project-owned JSON-safe wire. */
@@ -68,6 +81,7 @@ export function encodeValue(value, options = {}) {
   const pending = []
   const nodes = []
   let edgeCount = 0
+  let arraySlotCount = 0
   let textBytes = 0
 
   const accountText = (text, path) => {
@@ -82,7 +96,7 @@ export function encodeValue(value, options = {}) {
       return current
     }
     if (typeof current === 'number') {
-      if (Number.isNaN(current)) return { tag: 'number', value: 'nan' }
+      if (numberIsNaN(current)) return { tag: 'number', value: 'nan' }
       if (current === Infinity) return { tag: 'number', value: 'infinity' }
       if (current === -Infinity) return { tag: 'number', value: '-infinity' }
       if (Object.is(current, -0)) return { tag: 'number', value: '-0' }
@@ -90,20 +104,20 @@ export function encodeValue(value, options = {}) {
     }
     if (current === undefined) return { tag: 'undefined' }
     if (typeof current === 'bigint') {
-      const text = String(current)
+      const text = toString(current)
       const digits = text[0] === '-' ? text.length - 1 : text.length
       if (digits > limits.maxBigIntDigits) invalid(path, `BigInt exceeds ${limits.maxBigIntDigits} digits`)
       accountText(text, path)
       return { tag: 'bigint', value: text }
     }
     if (typeof current !== 'object') invalid(path, typeof current)
-    const prior = seen.get(current)
+    const prior = weakMapGet(seen, current)
     if (prior !== undefined) return { tag: 'reference', index: prior }
     if (nodes.length >= limits.maxNodes) invalid(path, `node budget exceeds ${limits.maxNodes}`)
     const index = nodes.length
-    seen.set(current, index)
-    nodes.push(undefined)
-    pending.push({ value: current, index, path })
+    weakMapSet(seen, current, index)
+    appendArray(nodes, undefined)
+    appendArray(pending, { value: current, index, path })
     return { tag: 'reference', index }
   }
 
@@ -111,24 +125,30 @@ export function encodeValue(value, options = {}) {
   for (let cursor = 0; cursor < pending.length; cursor += 1) {
     const item = pending[cursor]
     const current = item.value
-    if (Array.isArray(current)) {
+    if (isArray(current)) {
       if (!hasPlainArrayPrototype(current)) invalid(item.path, 'non-plain array')
       if (current.length > limits.maxArrayLength) invalid(item.path, `array length exceeds ${limits.maxArrayLength}`)
+      arraySlotCount += current.length
+      if (arraySlotCount > limits.maxArrayLength) {
+        invalid(item.path, `array slot budget exceeds ${limits.maxArrayLength}`)
+      }
       const entries = []
-      for (const key of Reflect.ownKeys(current)) {
+      const keys = Reflect.ownKeys(current)
+      for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
+        const key = keys[keyIndex]
         if (key === 'length') continue
-        if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/.test(key)) {
+        if (typeof key !== 'string' || !regexpTest(/^(0|[1-9][0-9]*)$/, key)) {
           invalid(item.path, 'array has a symbol or non-index property')
         }
-        const index = Number(key)
-        if (!Number.isSafeInteger(index) || index >= current.length) invalid(`${item.path}[${key}]`, 'invalid array index')
+        const index = toNumber(key)
+        if (!numberIsSafeInteger(index) || index >= current.length) invalid(`${item.path}[${key}]`, 'invalid array index')
         const descriptor = Object.getOwnPropertyDescriptor(current, key)
         if (descriptor === undefined || !Object.hasOwn(descriptor, 'value') || descriptor.enumerable !== true) {
           invalid(`${item.path}[${key}]`, 'array index must be an enumerable data property')
         }
         edgeCount += 1
         if (edgeCount > limits.maxEdges) invalid(item.path, `edge budget exceeds ${limits.maxEdges}`)
-        entries.push([index, atom(descriptor.value, `${item.path}[${key}]`)])
+        appendArray(entries, [index, atom(descriptor.value, `${item.path}[${key}]`)])
       }
       nodes[item.index] = { type: 'array', length: current.length, entries }
       continue
@@ -137,7 +157,9 @@ export function encodeValue(value, options = {}) {
     const prototype = plainObjectPrototype(current)
     if (prototype === undefined) invalid(item.path, 'non-plain object')
     const entries = []
-    for (const key of Reflect.ownKeys(current)) {
+    const keys = Reflect.ownKeys(current)
+    for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
+      const key = keys[keyIndex]
       if (typeof key !== 'string') invalid(item.path, 'object has a symbol key')
       const descriptor = Object.getOwnPropertyDescriptor(current, key)
       if (descriptor === undefined || !Object.hasOwn(descriptor, 'value') || descriptor.enumerable !== true) {
@@ -146,14 +168,14 @@ export function encodeValue(value, options = {}) {
       accountText(key, `${item.path}.${key}`)
       edgeCount += 1
       if (edgeCount > limits.maxEdges) invalid(item.path, `edge budget exceeds ${limits.maxEdges}`)
-      entries.push([key, atom(descriptor.value, `${item.path}.${key}`)])
+      appendArray(entries, [key, atom(descriptor.value, `${item.path}.${key}`)])
     }
     nodes[item.index] = { type: 'object', prototype, entries }
   }
   return { codec: VALUE_CODEC, root, nodes }
 }
 
-function decodeAtom(atom, nodes, limits, budget, path) {
+function validateAtom(atom, nodeCount, limits, budget, path) {
   if (atom === null || typeof atom === 'boolean') return atom
   if (typeof atom === 'string') {
     budget.textBytes += stringBytes(atom)
@@ -161,114 +183,176 @@ function decodeAtom(atom, nodes, limits, budget, path) {
     return atom
   }
   if (typeof atom === 'number') {
-    if (!Number.isFinite(atom) || Object.is(atom, -0)) throw new TypeError(`invalid PTC value number at ${path}`)
+    if (!numberIsFinite(atom) || Object.is(atom, -0)) throw new TypeError(`invalid PTC value number at ${path}`)
     return atom
   }
   if (!isRecord(atom) || typeof atom.tag !== 'string') throw new TypeError(`invalid PTC value atom at ${path}`)
   if (atom.tag === 'undefined') {
     assertFields(atom, UNDEFINED_FIELDS, 'PTC undefined atom')
-    return undefined
+    return { tag: 'undefined' }
   }
   if (atom.tag === 'number') {
     assertFields(atom, NUMBER_FIELDS, 'PTC number atom')
-    if (atom.value === 'nan') return NaN
-    if (atom.value === 'infinity') return Infinity
-    if (atom.value === '-infinity') return -Infinity
-    if (atom.value === '-0') return -0
+    if (atom.value === 'nan' || atom.value === 'infinity'
+      || atom.value === '-infinity' || atom.value === '-0') {
+      return { tag: 'number', value: atom.value }
+    }
     throw new TypeError('invalid PTC special number')
   }
   if (atom.tag === 'bigint') {
     assertFields(atom, BIGINT_FIELDS, 'PTC BigInt atom')
-    if (typeof atom.value !== 'string' || !/^(0|-[1-9][0-9]*|[1-9][0-9]*)$/.test(atom.value)) {
+    if (typeof atom.value !== 'string' || !regexpTest(/^(0|-[1-9][0-9]*|[1-9][0-9]*)$/, atom.value)) {
       throw new TypeError('invalid PTC BigInt')
     }
     const digits = atom.value[0] === '-' ? atom.value.length - 1 : atom.value.length
     if (digits > limits.maxBigIntDigits) throw new TypeError('PTC BigInt digit budget exceeded')
     budget.textBytes += stringBytes(atom.value)
     if (budget.textBytes > limits.maxStringBytes) throw new TypeError('PTC value string budget exceeded')
-    return BigInt(atom.value)
+    return { tag: 'bigint', value: atom.value }
   }
   if (atom.tag === 'reference') {
     assertFields(atom, REFERENCE_FIELDS, 'PTC reference atom')
-    if (!Number.isSafeInteger(atom.index) || atom.index < 0 || atom.index >= nodes.length) {
+    if (!numberIsSafeInteger(atom.index) || atom.index < 0 || atom.index >= nodeCount) {
       throw new TypeError('dangling PTC value reference')
     }
-    budget.reachable.add(atom.index)
-    return nodes[atom.index]
+    if (atom.index >= budget.nextReference) {
+      if (atom.index !== budget.nextReference) throw new TypeError('non-canonical PTC value envelope')
+      budget.nextReference += 1
+    }
+    return { tag: 'reference', index: atom.index }
   }
-  throw new TypeError(`unknown PTC value atom tag ${JSON.stringify(atom.tag)}`)
+  throw new TypeError(`unknown PTC value atom tag ${jsonStringify(atom.tag)}`)
 }
 
-/** Validate, hydrate, and own one canonical PTC value envelope without recursive stack growth. */
-function decodeCanonicalValue(wire, options = {}) {
-  const limits = limitsOf(options)
+function canonicalArrayIndex(key) {
+  if (!regexpTest(/^(0|[1-9][0-9]*)$/, key)) return undefined
+  const index = toNumber(key)
+  return numberIsSafeInteger(index) && index < 0xffffffff && toString(index) === key ? index : undefined
+}
+
+const MAX_ARRAY_LENGTH = 0xffffffff
+
+/** Validate and detach the complete envelope before allocating hydrated arrays. */
+function validateCanonicalWire(wire, limits) {
   assertFields(wire, ENVELOPE_FIELDS, 'PTC value envelope')
-  if (wire.codec !== VALUE_CODEC || !Array.isArray(wire.nodes)) throw new TypeError('invalid PTC value codec')
+  if (wire.codec !== VALUE_CODEC || !isArray(wire.nodes)) throw new TypeError('invalid PTC value codec')
   if (wire.nodes.length > limits.maxNodes) throw new TypeError('PTC value node budget exceeded')
-  const targets = new Array(wire.nodes.length)
+  const nodes = new Array(wire.nodes.length)
+  let arraySlots = 0
   for (let index = 0; index < wire.nodes.length; index += 1) {
     const node = wire.nodes[index]
     if (!isRecord(node)) throw new TypeError(`invalid PTC value node ${index}`)
     if (node.type === 'array') {
       assertFields(node, ARRAY_NODE_FIELDS, `PTC array node ${index}`)
-      if (!Number.isSafeInteger(node.length) || node.length < 0 || node.length > limits.maxArrayLength) {
+      if (!numberIsSafeInteger(node.length) || node.length < 0
+        || node.length > MAX_ARRAY_LENGTH || node.length > limits.maxArrayLength) {
         throw new TypeError(`invalid PTC array length at node ${index}`)
       }
-      if (!Array.isArray(node.entries)) throw new TypeError(`invalid PTC array entries at node ${index}`)
-      targets[index] = new Array(node.length)
+      if (!isArray(node.entries)) throw new TypeError(`invalid PTC array entries at node ${index}`)
+      arraySlots += node.length
+      if (arraySlots > limits.maxArrayLength) throw new TypeError('PTC value array slot budget exceeded')
+      nodes[index] = { type: 'array', length: node.length, entries: node.entries }
     } else if (node.type === 'object') {
       assertFields(node, OBJECT_NODE_FIELDS, `PTC object node ${index}`)
-      if (!['object', 'null'].includes(node.prototype) || !Array.isArray(node.entries)) {
+      if ((node.prototype !== 'object' && node.prototype !== 'null') || !isArray(node.entries)) {
         throw new TypeError(`invalid PTC object node ${index}`)
       }
-      targets[index] = node.prototype === 'null' ? Object.create(null) : {}
+      nodes[index] = { type: 'object', prototype: node.prototype, entries: node.entries }
     } else {
       throw new TypeError(`unknown PTC value node type at ${index}`)
     }
   }
 
-  const budget = { edges: 0, textBytes: 0, reachable: new Set() }
-  const root = decodeAtom(wire.root, targets, limits, budget, '$')
-  for (let nodeIndex = 0; nodeIndex < wire.nodes.length; nodeIndex += 1) {
-    const node = wire.nodes[nodeIndex]
-    const target = targets[nodeIndex]
+  const budget = { edges: 0, textBytes: 0, nextReference: 0 }
+  const root = validateAtom(wire.root, nodes.length, limits, budget, '$')
+  for (let nodeIndex = 0; nodeIndex < budget.nextReference; nodeIndex += 1) {
+    const node = nodes[nodeIndex]
+    const entries = []
     if (node.type === 'array') {
       let previous = -1
-      for (const entry of node.entries) {
-        if (!Array.isArray(entry) || entry.length !== 2 || !Number.isSafeInteger(entry[0])
+      for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+        const entry = node.entries[entryIndex]
+        if (!isArray(entry) || entry.length !== 2 || !numberIsSafeInteger(entry[0])
           || entry[0] <= previous || entry[0] < 0 || entry[0] >= node.length) {
           throw new TypeError(`invalid PTC array entry at node ${nodeIndex}`)
         }
         previous = entry[0]
         budget.edges += 1
         if (budget.edges > limits.maxEdges) throw new TypeError('PTC value edge budget exceeded')
-        Object.defineProperty(target, entry[0], {
-          value: decodeAtom(entry[1], targets, limits, budget, `$nodes[${nodeIndex}][${entry[0]}]`),
-          enumerable: true, configurable: true, writable: true,
-        })
+        appendArray(entries, [entry[0], validateAtom(entry[1], nodes.length, limits, budget,
+          `$nodes[${nodeIndex}][${entry[0]}]`)])
       }
+      nodes[nodeIndex] = { type: 'array', length: node.length, entries }
       continue
     }
     const keys = new Set()
-    for (const entry of node.entries) {
-      if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== 'string' || keys.has(entry[0])) {
+    let previousIndex = -1
+    let ordinaryKeySeen = false
+    for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+      const entry = node.entries[entryIndex]
+      if (!isArray(entry) || entry.length !== 2 || typeof entry[0] !== 'string' || setHas(keys, entry[0])) {
         throw new TypeError(`invalid PTC object entry at node ${nodeIndex}`)
       }
-      keys.add(entry[0])
+      const index = canonicalArrayIndex(entry[0])
+      if (index === undefined) ordinaryKeySeen = true
+      else if (ordinaryKeySeen || index <= previousIndex) {
+        throw new TypeError('non-canonical PTC value envelope')
+      } else previousIndex = index
+      setAdd(keys, entry[0])
       budget.textBytes += stringBytes(entry[0])
       if (budget.textBytes > limits.maxStringBytes) throw new TypeError('PTC value string budget exceeded')
       budget.edges += 1
       if (budget.edges > limits.maxEdges) throw new TypeError('PTC value edge budget exceeded')
+      appendArray(entries, [entry[0], validateAtom(entry[1], nodes.length, limits, budget,
+        `$nodes[${nodeIndex}].${entry[0]}`)])
+    }
+    nodes[nodeIndex] = { type: 'object', prototype: node.prototype, entries }
+  }
+  if (budget.nextReference !== nodes.length) throw new TypeError('PTC value envelope contains unreachable nodes')
+  const normalized = { codec: VALUE_CODEC, root, nodes }
+  const serialization = jsonStringify(normalized)
+  if (serialization !== jsonStringify(wire)) throw new TypeError('non-canonical PTC value envelope')
+  return { wire: normalized, serialization }
+}
+
+function hydrateAtom(atom, nodes) {
+  if (atom === null || typeof atom === 'boolean' || typeof atom === 'string' || typeof atom === 'number') return atom
+  if (atom.tag === 'undefined') return undefined
+  if (atom.tag === 'number') {
+    if (atom.value === 'nan') return NaN
+    if (atom.value === 'infinity') return Infinity
+    if (atom.value === '-infinity') return -Infinity
+    return -0
+  }
+  if (atom.tag === 'bigint') return toBigInt(atom.value)
+  return nodes[atom.index]
+}
+
+/** Validate, hydrate, and own one canonical PTC value envelope without recursive stack growth. */
+function decodeCanonicalValue(wire, options = {}) {
+  const limits = limitsOf(options)
+  const validated = validateCanonicalWire(wire, limits)
+  const targets = new Array(validated.wire.nodes.length)
+  for (let index = 0; index < validated.wire.nodes.length; index += 1) {
+    const node = validated.wire.nodes[index]
+    targets[index] = node.type === 'array' ? new Array(node.length)
+      : node.prototype === 'null' ? Object.create(null) : {}
+  }
+  const root = hydrateAtom(validated.wire.root, targets)
+  for (let nodeIndex = 0; nodeIndex < validated.wire.nodes.length; nodeIndex += 1) {
+    const node = validated.wire.nodes[nodeIndex]
+    const target = targets[nodeIndex]
+    for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+      const entry = node.entries[entryIndex]
       Object.defineProperty(target, entry[0], {
-        value: decodeAtom(entry[1], targets, limits, budget, `$nodes[${nodeIndex}].${entry[0]}`),
+        value: hydrateAtom(entry[1], targets),
         enumerable: true, configurable: true, writable: true,
       })
     }
   }
-  if (budget.reachable.size !== wire.nodes.length) throw new TypeError('PTC value envelope contains unreachable nodes')
   const canonical = encodeValue(root, limits)
-  const serialization = JSON.stringify(canonical)
-  if (serialization !== JSON.stringify(wire)) throw new TypeError('non-canonical PTC value envelope')
+  const serialization = jsonStringify(canonical)
+  if (serialization !== validated.serialization) throw new TypeError('non-canonical PTC value envelope')
   return { value: root, wire: canonical, serialization }
 }
 
@@ -295,31 +379,32 @@ export function isPlainJsonTree(value) {
   const pending = [value]
   const seen = new WeakSet()
   while (pending.length > 0) {
-    const current = pending.pop()
+    const current = popArray(pending)
     if (current === null || typeof current === 'string' || typeof current === 'boolean') continue
-    if (typeof current === 'number' && Number.isFinite(current) && !Object.is(current, -0)) continue
+    if (typeof current === 'number' && numberIsFinite(current) && !Object.is(current, -0)) continue
     if (typeof current !== 'object') return false
-    if (seen.has(current)) return false
-    seen.add(current)
-    if (Array.isArray(current)) {
+    if (weakSetHas(seen, current)) return false
+    weakSetAdd(seen, current)
+    if (isArray(current)) {
       for (let index = 0; index < current.length; index += 1) {
         if (!Object.hasOwn(current, index)) return false
-        pending.push(current[index])
+        appendArray(pending, current[index])
       }
     } else {
-      for (const key of Object.keys(current)) pending.push(current[key])
+      const keys = Object.keys(current)
+      for (let index = 0; index < keys.length; index += 1) appendArray(pending, current[keys[index]])
     }
   }
   return true
 }
 
 function renderKey(key) {
-  return IDENTIFIER.test(key) ? key : JSON.stringify(key)
+  return regexpTest(IDENTIFIER, key) ? key : jsonStringify(key)
 }
 
 function atomText(atom) {
-  if (atom === null || typeof atom === 'boolean' || typeof atom === 'number') return String(atom)
-  if (typeof atom === 'string') return JSON.stringify(atom)
+  if (atom === null || typeof atom === 'boolean' || typeof atom === 'number') return toString(atom)
+  if (typeof atom === 'string') return jsonStringify(atom)
   if (atom.tag === 'undefined') return 'undefined'
   if (atom.tag === 'number') {
     return atom.value === 'nan' ? 'NaN'
@@ -337,16 +422,20 @@ export function renderValueWire(wire, options = {}) {
 }
 
 function renderCanonicalValue(normalized, limits) {
-  const references = new Array(normalized.nodes.length).fill(0)
+  const references = new Array(normalized.nodes.length)
+  for (let index = 0; index < references.length; index += 1) references[index] = 0
   const count = (atom) => {
     if (isRecord(atom) && atom.tag === 'reference') references[atom.index] += 1
   }
   count(normalized.root)
-  for (const node of normalized.nodes) for (const entry of node.entries) count(entry[1])
+  for (let nodeIndex = 0; nodeIndex < normalized.nodes.length; nodeIndex += 1) {
+    const entries = normalized.nodes[nodeIndex].entries
+    for (let entryIndex = 0; entryIndex < entries.length; entryIndex += 1) count(entries[entryIndex][1])
+  }
   const labels = new Map()
   let nextLabel = 0
   for (let index = 0; index < references.length; index += 1) {
-    if (references[index] > 1) labels.set(index, ++nextLabel)
+    if (references[index] > 1) mapSet(labels, index, ++nextLabel)
   }
 
   const chunks = []
@@ -354,19 +443,19 @@ function renderCanonicalValue(normalized, limits) {
   const append = (text) => {
     bytes += stringBytes(text)
     if (bytes > limits.maxStringBytes) throw new TypeError(`rendered PTC value exceeds ${limits.maxStringBytes} bytes`)
-    chunks.push(text)
+    appendArray(chunks, text)
   }
   const emitted = new Set()
   const active = new Set()
   const tasks = [{ kind: 'atom', atom: normalized.root }]
   while (tasks.length > 0) {
-    const task = tasks.pop()
+    const task = popArray(tasks)
     if (task.kind === 'text') {
       append(task.text)
       continue
     }
     if (task.kind === 'leave') {
-      active.delete(task.index)
+      setDelete(active, task.index)
       continue
     }
     const primitive = atomText(task.atom)
@@ -375,38 +464,44 @@ function renderCanonicalValue(normalized, limits) {
       continue
     }
     const index = task.atom.index
-    const label = labels.get(index)
-    if (emitted.has(index)) {
-      append(active.has(index) ? `[Circular *${label}]` : `[Reference *${label}]`)
+    const label = mapGet(labels, index)
+    if (setHas(emitted, index)) {
+      append(setHas(active, index) ? `[Circular *${label}]` : `[Reference *${label}]`)
       continue
     }
-    emitted.add(index)
-    active.add(index)
+    setAdd(emitted, index)
+    setAdd(active, index)
     if (label !== undefined) append(`<ref *${label}> `)
     const node = normalized.nodes[index]
-    tasks.push({ kind: 'leave', index })
+    appendArray(tasks, { kind: 'leave', index })
     if (node.type === 'array') {
       append('[')
-      tasks.push({ kind: 'text', text: ']' })
-      const entries = new Map(node.entries)
-      if (node.length > 0 && !entries.has(node.length - 1)) tasks.push({ kind: 'text', text: ',' })
+      appendArray(tasks, { kind: 'text', text: ']' })
+      const entries = new Map()
+      for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+        const entry = node.entries[entryIndex]
+        mapSet(entries, entry[0], entry[1])
+      }
+      if (node.length > 0 && !mapHas(entries, node.length - 1)) appendArray(tasks, { kind: 'text', text: ',' })
       for (let item = node.length - 1; item >= 0; item -= 1) {
-        if (item < node.length - 1) tasks.push({ kind: 'text', text: ', ' })
-        const value = entries.get(item)
-        if (value !== undefined) tasks.push({ kind: 'atom', atom: value })
+        if (item < node.length - 1) appendArray(tasks, { kind: 'text', text: ', ' })
+        const value = mapGet(entries, item)
+        if (value !== undefined) appendArray(tasks, { kind: 'atom', atom: value })
       }
       continue
     }
     append('{')
-    tasks.push({ kind: 'text', text: '}' })
+    appendArray(tasks, { kind: 'text', text: '}' })
     for (let entryIndex = node.entries.length - 1; entryIndex >= 0; entryIndex -= 1) {
-      const [key, value] = node.entries[entryIndex]
-      if (entryIndex < node.entries.length - 1) tasks.push({ kind: 'text', text: ', ' })
-      tasks.push({ kind: 'atom', atom: value })
-      tasks.push({ kind: 'text', text: `${renderKey(key)}: ` })
+      const entry = node.entries[entryIndex]
+      const key = entry[0]
+      const value = entry[1]
+      if (entryIndex < node.entries.length - 1) appendArray(tasks, { kind: 'text', text: ', ' })
+      appendArray(tasks, { kind: 'atom', atom: value })
+      appendArray(tasks, { kind: 'text', text: `${renderKey(key)}: ` })
     }
   }
-  return chunks.join('')
+  return join(chunks, '')
 }
 
 /**