agentic-mermaid 0.1.1 → 0.1.2

package/src/agent/sequence-body.ts

@@ -1,345 +0,0 @@
-// ============================================================================
-// Sequence structured body: parse / serialize / mutate (FamilyPlugin hooks).
-//
-// BUILD-18 — segment-preserving structured body. The v4 "all-or-nothing opaque
-// cliff" is gone: a sequence diagram with Note/alt/loop/par/activate/
-// autonumber/title keeps its participant/message mutation ops while unmodeled
-// lines ride along VERBATIM as opaque-block segments.
-//
-//   - Structured lines  = participant/actor declarations + simple messages.
-//   - Block constructs  = alt|opt|loop|par|critical|break|rect … end (nesting-
-//                         tracked) → ONE opaque-block segment, inner lines kept
-//                         byte-for-byte (original indentation).
-//   - Other single lines = Note…, activate/deactivate, autonumber, title… →
-//                         each joins an adjacent opaque-block segment.
-//   - Unbalanced `end` / unclosed block / un-segmentable input → return null
-//                         so the caller falls back to a whole-body opaque body
-//                         (the old behavior, still lossless).
-//
-// The serializer emits statements in order: opaque-block lines verbatim,
-// structured lines canonical. Round-trip guarantee: every original non-blank
-// line's content survives in original order (whitespace canonicalized ONLY on
-// structured lines).
-// ============================================================================
-
-import { unknownOpMessage } from './mutation-ops.ts'
-import type {
-  SequenceBody, SequenceParticipant, SequenceMessage, SequenceMessageStyle,
-  SequenceStatement, SequenceMutationOp, MutationError, Result,
-} from './types.ts'
-import { ok, err } from './types.ts'
-
-// ---- Parser -----------------------------------------------------------------
-
-const PARTICIPANT_RE = /^(participant|actor)\s+([A-Za-z_][\w]*)(?:\s+as\s+(.+))?$/i
-const MESSAGE_RE = /^([A-Za-z_][\w]*)\s*(-->>|--x|-->|->>|->|-x)\s*([A-Za-z_][\w]*)\s*:\s*(.+)$/
-
-// Keywords that OPEN a nestable block (closed by a matching `end`).
-const BLOCK_OPEN_RE = /^(alt|opt|loop|par|critical|break|rect)\b/i
-// Continuation keywords valid only INSIDE an open block — never open/close one.
-const BLOCK_CONT_RE = /^(else|and|option)\b/i
-const BLOCK_END_RE = /^end\b/i
-
-/**
- * Parse the body lines of a sequence diagram into a segment-preserving
- * structured body. `trimmedLines` are the normalized (trimmed, comment-
- * stripped) body lines; `rawLines` are the original body lines WITH their
- * indentation preserved (opaque-block segments are emitted from these so the
- * verbatim round-trip holds). Pass the same array for both when raw lines are
- * unavailable.
- *
- * Returns null if the body cannot be cleanly segmented (unbalanced `end`,
- * unclosed block) so the caller falls back to a lossless whole-body opaque
- * body.
- */
-export function parseSequenceBody(trimmedLines: string[], rawLines?: string[]): SequenceBody | null {
-  const participants: SequenceParticipant[] = []
-  const messages: SequenceMessage[] = []
-  const statements: SequenceStatement[] = []
-  const seen = new Set<string>()
-
-  // Align raw (indented) lines with trimmed lines. `rawLines` has the same
-  // logical content but keeps indentation/blank lines; we walk it in lockstep
-  // by skipping its blank/comment lines, which `trimmedLines` already drops.
-  const raw = rawLines ?? trimmedLines
-
-  // NB: do NOT name this `declare` — that's a TypeScript keyword and bun's
-  // transpiler misparses `declare(x)` as an ambient declaration.
-  const ensureKnown = (id: string) => {
-    if (!seen.has(id)) { participants.push({ id, label: id, kind: 'participant' }); seen.add(id) }
-  }
-
-  // Walk the raw lines so opaque segments capture original indentation. Track a
-  // parallel index into trimmedLines is unnecessary: we trim each raw line for
-  // structural matching but store the raw text in opaque segments.
-  let i = 0
-  while (i < raw.length) {
-    const rawLine = raw[i]!
-    const line = rawLine.trim()
-    if (!line || line.startsWith('%%')) { i++; continue }
-
-    const part = line.match(PARTICIPANT_RE)
-    if (part) {
-      const kind = part[1]!.toLowerCase() === 'actor' ? 'actor' : 'participant'
-      const id = part[2]!.trim()
-      const label = part[3]?.trim() ?? id
-      if (!seen.has(id)) {
-        participants.push({ id, label, kind }); seen.add(id)
-        statements.push({ kind: 'participant', ref: participants.length - 1 })
-      } else {
-        // Update an implicitly-declared participant with explicit info, and add
-        // a statement so the explicit declaration round-trips in position.
-        const idx = participants.findIndex(p => p.id === id)
-        participants[idx]!.label = label
-        participants[idx]!.kind = kind
-        statements.push({ kind: 'participant', ref: idx })
-      }
-      i++
-      continue
-    }
-
-    const msg = line.match(MESSAGE_RE)
-    if (msg) {
-      const from = msg[1]!.trim()
-      const arrow = msg[2]!.trim()
-      const to = msg[3]!.trim()
-      const text = msg[4]!.trim()
-      ensureKnown(from)
-      ensureKnown(to)
-      messages.push({ from, to, text, style: styleForArrow(arrow) })
-      statements.push({ kind: 'message', ref: messages.length - 1 })
-      i++
-      continue
-    }
-
-    // A stray `end` or block-continuation with no open block can't be cleanly
-    // segmented → whole-body opaque fallback.
-    if (BLOCK_END_RE.test(line) || BLOCK_CONT_RE.test(line)) return null
-
-    if (BLOCK_OPEN_RE.test(line)) {
-      // Capture start → matching end as ONE opaque-block (verbatim, nested).
-      const blockLines: string[] = [rawLine]
-      let depth = 1
-      i++
-      while (i < raw.length && depth > 0) {
-        const inner = raw[i]!
-        const innerTrim = inner.trim()
-        if (innerTrim && !innerTrim.startsWith('%%')) {
-          if (BLOCK_OPEN_RE.test(innerTrim)) depth++
-          else if (BLOCK_END_RE.test(innerTrim)) depth--
-        }
-        blockLines.push(inner)
-        i++
-      }
-      if (depth !== 0) return null // unclosed block → opaque fallback
-      appendOpaque(statements, dropBlankEdges(blockLines))
-      continue
-    }
-
-    // Any other unmodeled single line (Note…, activate/deactivate, autonumber,
-    // title…) joins an adjacent opaque-block segment, kept verbatim.
-    appendOpaque(statements, [rawLine])
-    i++
-  }
-
-  return { kind: 'sequence', participants, messages, statements }
-}
-
-// Append verbatim lines to the last statement if it's an opaque-block, else
-// start a new one. Coalescing keeps adjacent unmodeled lines in one segment.
-function appendOpaque(statements: SequenceStatement[], lines: string[]): void {
-  const last = statements[statements.length - 1]
-  if (last && last.kind === 'opaque-block') last.lines.push(...lines)
-  else statements.push({ kind: 'opaque-block', lines: [...lines] })
-}
-
-// Trim trailing blank lines from a captured block (the matching `end` is the
-// real terminator); leading content already starts at the block keyword.
-function dropBlankEdges(lines: string[]): string[] {
-  const out = [...lines]
-  while (out.length && out[out.length - 1]!.trim() === '') out.pop()
-  return out
-}
-
-function styleForArrow(a: string): SequenceMessageStyle {
-  switch (a) {
-    case '->>': return 'sync'
-    case '-->>': return 'reply'
-    case '->': return 'async'
-    case '-->': return 'async-dashed'
-    case '-x': return 'lost'
-    case '--x': return 'lost-dashed'
-    default: return 'sync'
-  }
-}
-
-// ---- Serializer -------------------------------------------------------------
-
-export function renderSequence(body: SequenceBody): string {
-  const lines: string[] = ['sequenceDiagram']
-
-  if (body.statements && body.statements.length > 0) {
-    // Segment-preserving path: emit statements in order.
-    for (const st of body.statements) {
-      if (st.kind === 'opaque-block') {
-        for (const l of st.lines) lines.push(l)
-      } else if (st.kind === 'participant') {
-        const p = body.participants[st.ref]
-        if (p) lines.push(renderParticipant(p))
-      } else {
-        const m = body.messages[st.ref]
-        if (m) lines.push(renderMessage(m))
-      }
-    }
-    return lines.join('\n') + '\n'
-  }
-
-  // Legacy / synthesized path (no statements): participants then messages.
-  for (const p of body.participants) {
-    if (p.label !== p.id || p.kind === 'actor') lines.push(renderParticipant(p))
-  }
-  for (const m of body.messages) lines.push(renderMessage(m))
-  return lines.join('\n') + '\n'
-}
-
-function renderParticipant(p: SequenceParticipant): string {
-  const tag = p.kind === 'actor' ? 'actor' : 'participant'
-  return `  ${tag} ${p.id}${p.label !== p.id ? ` as ${p.label}` : ''}`
-}
-
-function renderMessage(m: SequenceMessage): string {
-  return `  ${m.from}${arrowForStyle(m.style)}${m.to}: ${m.text}`
-}
-
-export function arrowForStyle(s: SequenceMessageStyle): string {
-  switch (s) {
-    case 'sync': return '->>'
-    case 'reply': return '-->>'
-    case 'async': return '->'
-    case 'async-dashed': return '-->'
-    case 'lost': return '-x'
-    case 'lost-dashed': return '--x'
-  }
-}
-
-// ---- Mutator ----------------------------------------------------------------
-//
-// Index semantics (backward compatible): remove_message / set_message_text
-// indexes address the `messages` array exactly as before — TOP-LEVEL
-// structured messages only. Messages inside opaque blocks are invisible to ops
-// and are never touched. The statements list is updated consistently on every
-// op and refs are re-indexed when a message is removed.
-
-export function mutateSequence(body: SequenceBody, op: SequenceMutationOp): Result<SequenceBody, MutationError> {
-  const participants = body.participants.map(p => ({ ...p }))
-  const messages = body.messages.map(m => ({ ...m }))
-  const statements: SequenceStatement[] = (body.statements ?? deriveStatements(body)).map(cloneStatement)
-
-  switch (op.kind) {
-    case 'add_participant': {
-      if (participants.some(p => p.id === op.id)) return err({ code: 'DUPLICATE_PARTICIPANT', message: `Participant "${op.id}" already exists` })
-      participants.push({ id: op.id, label: op.label ?? op.id, kind: op.participantKind ?? 'participant' })
-      const ref = participants.length - 1
-      insertParticipantStatement(statements, { kind: 'participant', ref })
-      break
-    }
-    case 'remove_participant': {
-      const idx = participants.findIndex(p => p.id === op.id)
-      if (idx < 0) return err({ code: 'PARTICIPANT_NOT_FOUND', message: `Participant "${op.id}" not found` })
-      participants.splice(idx, 1)
-      // Drop messages touching the participant, then rebuild statements over
-      // the surviving messages/participants (opaque blocks are preserved).
-      const removedMsgIdx = new Set<number>()
-      messages.forEach((m, mi) => { if (m.from === op.id || m.to === op.id) removedMsgIdx.add(mi) })
-      const keptMessages = messages.filter((_, mi) => !removedMsgIdx.has(mi))
-      const rebuilt = rebuildStatements(statements, idx, removedMsgIdx)
-      return ok({ kind: 'sequence', participants, messages: keptMessages, statements: rebuilt })
-    }
-    case 'add_message': {
-      ensureParticipant(participants, statements, op.from)
-      ensureParticipant(participants, statements, op.to)
-      messages.push({ from: op.from, to: op.to, text: op.text, style: op.style ?? 'sync' })
-      statements.push({ kind: 'message', ref: messages.length - 1 })
-      break
-    }
-    case 'remove_message': {
-      if (op.index < 0 || op.index >= messages.length) return err({ code: 'MESSAGE_NOT_FOUND', message: `No message at index ${op.index}` })
-      messages.splice(op.index, 1)
-      removeMessageStatement(statements, op.index)
-      break
-    }
-    case 'set_message_text': {
-      if (op.index < 0 || op.index >= messages.length) return err({ code: 'MESSAGE_NOT_FOUND', message: `No message at index ${op.index}` })
-      messages[op.index]!.text = op.text
-      break
-    }
-    default: {
-      const _x: never = op
-      return err({ code: 'INVALID_OP', message: unknownOpMessage('sequence', _x) })
-    }
-  }
-  return ok({ kind: 'sequence', participants, messages, statements })
-}
-
-function cloneStatement(s: SequenceStatement): SequenceStatement {
-  return s.kind === 'opaque-block' ? { kind: 'opaque-block', lines: [...s.lines] } : { ...s }
-}
-
-// Build a default statements list (participants then messages) for a body that
-// lacks one — e.g. a synthesized payload mutated directly.
-function deriveStatements(body: SequenceBody): SequenceStatement[] {
-  const out: SequenceStatement[] = []
-  body.participants.forEach((p, i) => { if (p.label !== p.id || p.kind === 'actor') out.push({ kind: 'participant', ref: i }) })
-  body.messages.forEach((_, i) => out.push({ kind: 'message', ref: i }))
-  return out
-}
-
-// Insert a participant declaration statement after the last participant
-// statement, or at the top of the body (before everything) when there is none.
-function insertParticipantStatement(statements: SequenceStatement[], st: SequenceStatement): void {
-  let lastPart = -1
-  for (let i = 0; i < statements.length; i++) if (statements[i]!.kind === 'participant') lastPart = i
-  if (lastPart >= 0) statements.splice(lastPart + 1, 0, st)
-  else statements.unshift(st)
-}
-
-function ensureParticipant(ps: SequenceParticipant[], statements: SequenceStatement[], id: string): void {
-  if (ps.some(p => p.id === id)) return
-  ps.push({ id, label: id, kind: 'participant' })
-  // Implicit participants are not declared with their own line, so no
-  // statement entry is needed (the message line carries the participant id).
-}
-
-// Remove the message statement for a removed top-level message and shift all
-// later message refs down by one so refs stay aligned with the messages array.
-function removeMessageStatement(statements: SequenceStatement[], index: number): void {
-  const pos = statements.findIndex(s => s.kind === 'message' && s.ref === index)
-  if (pos >= 0) statements.splice(pos, 1)
-  for (const s of statements) if (s.kind === 'message' && s.ref > index) s.ref--
-}
-
-// Rebuild statements after a participant removal: drop the removed
-// participant's declaration statement and any message statements whose message
-// was removed, then re-index surviving participant/message refs. Opaque blocks
-// pass through untouched (their inner messages were never in the arrays).
-function rebuildStatements(
-  statements: SequenceStatement[],
-  removedParticipantIdx: number,
-  removedMsgIdx: Set<number>,
-): SequenceStatement[] {
-  const out: SequenceStatement[] = []
-  for (const s of statements) {
-    if (s.kind === 'opaque-block') { out.push({ kind: 'opaque-block', lines: [...s.lines] }); continue }
-    if (s.kind === 'participant') {
-      if (s.ref === removedParticipantIdx) continue
-      out.push({ kind: 'participant', ref: s.ref > removedParticipantIdx ? s.ref - 1 : s.ref })
-      continue
-    }
-    // message
-    if (removedMsgIdx.has(s.ref)) continue
-    let shift = 0
-    for (const r of removedMsgIdx) if (r < s.ref) shift++
-    out.push({ kind: 'message', ref: s.ref - shift })
-  }
-  return out
-}

package/src/agent/serialize.ts

@@ -1,214 +0,0 @@
-// ============================================================================
-// serializeMermaid: ValidDiagram → canonical Mermaid source.
-// synthesizeFromGraph: build a ValidDiagram from a JSON payload (no re-parse).
-// ============================================================================
-
-import type {
-  ValidDiagram, ValidDiagramMeta, DiagramBody,
-  ValidDiagramPayload, ParseError, Result,
-} from './types.ts'
-import { ok, err } from './types.ts'
-import YAML from 'yaml'
-import { getFamily, knownFamilies } from './families.ts'
-import './families-builtin.ts'  // registers built-in family serialize hooks
-
-// Re-export for callers that used the previous in-tree serializer home.
-export { renderTimeline } from './timeline-body.ts'
-
-export interface SerializeOptions {
-  /**
-   * Wrapper emission policy. 'verbatim' (default) re-emits the leading source
-   * wrapper (frontmatter, init directives, comments) byte-identically from
-   * `meta.wrapperSource`. 'canonical' synthesizes Mermaid's documented shape
-   * instead: one frontmatter block with `title`/`displayMode` at the top
-   * level and everything else nested under `config:`, init directives folded
-   * in (re-emitted raw only when their payload could not be folded), and
-   * wrapper comments dropped. Diagrams without a captured wrapper (e.g.
-   * synthesized from JSON payloads) always use canonical synthesis.
-   */
-  wrapper?: 'verbatim' | 'canonical'
-}
-
-export function serializeMermaid(d: ValidDiagram, opts: SerializeOptions = {}): string {
-  return wrapperPrefix(d.meta, opts.wrapper ?? 'verbatim') + renderBody(d.body, d.kind)
-}
-
-/** The wrapper text to emit before the diagram body for the given policy. */
-export function wrapperPrefix(meta: ValidDiagramMeta, mode: 'verbatim' | 'canonical' = 'verbatim'): string {
-  if (mode === 'verbatim' && meta.wrapperSource !== undefined) return meta.wrapperSource
-  return renderMeta(meta)
-}
-
-/**
- * Canonical wrapper synthesis (Mermaid's documented frontmatter shape):
- * `title`/`displayMode` stay top-level, all other keys nest under `config:`.
- * Init directives whose parsed payload is already represented in the
- * frontmatter map are folded (not re-emitted); unparseable directives are
- * preserved raw so canonicalization never silently loses them.
- */
-export function renderMeta(meta: ValidDiagramMeta): string {
-  const parts: string[] = []
-  if (meta.frontmatter && Object.keys(meta.frontmatter).length > 0) {
-    const top: Record<string, unknown> = {}
-    const config: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(meta.frontmatter)) {
-      if (key === 'title' || key === 'displayMode') top[key] = value
-      else config[key] = value
-    }
-    const doc: Record<string, unknown> = { ...top }
-    if (Object.keys(config).length > 0) doc.config = config
-    parts.push(`---\n${YAML.stringify(doc).trimEnd()}\n---\n`)
-  }
-  for (const d of meta.initDirectives) {
-    if (frontmatterRepresents(meta.frontmatter, d.parsed)) continue
-    parts.push(d.raw.trimEnd() + '\n')
-  }
-  return parts.join('')
-}
-
-/** True when every leaf of `sub` is present with an equal value in `map`. */
-function frontmatterRepresents(map: Record<string, unknown> | undefined, sub: Record<string, unknown>): boolean {
-  const keys = Object.keys(sub)
-  if (keys.length === 0) return false  // unparseable payload — never foldable
-  if (!map) return false
-  for (const key of keys) {
-    const a = map[key], b = sub[key]
-    if (b && typeof b === 'object' && !Array.isArray(b)) {
-      if (!a || typeof a !== 'object' || Array.isArray(a)) return false
-      if (!frontmatterRepresents(a as Record<string, unknown>, b as Record<string, unknown>)) return false
-      continue
-    }
-    if (JSON.stringify(a) !== JSON.stringify(b)) return false
-  }
-  return true
-}
-
-function renderBody(body: DiagramBody, kind: ValidDiagram['kind']): string {
-  // Opaque bodies re-emit preserved source verbatim. Every structured body
-  // serializes through its FamilyPlugin hook — looked up by DIAGRAM kind,
-  // not body kind. State diagrams (BUILD-19) own a dedicated StateBody and the
-  // state plugin emits the stateDiagram-v2 header.
-  if (body.kind === 'opaque') return body.source.endsWith('\n') ? body.source : body.source + '\n'
-  const plugin = getFamily(kind)
-  if (plugin?.serialize) return plugin.serialize(body)
-  throw new Error(`No serializer registered for diagram kind "${kind}"`)
-}
-
-// ---- synthesizeFromGraph --------------------------------------------------
-
-export function synthesizeFromGraph(payload: ValidDiagramPayload): Result<ValidDiagram, ParseError[]> {
-  const meta: ValidDiagramMeta = {
-    initDirectives: payload.meta?.initDirectives ?? [],
-    comments: payload.meta?.comments ?? [],
-    accessibility: payload.meta?.accessibility ?? {},
-    frontmatter: payload.meta?.frontmatter,
-    wrapperSource: payload.meta?.wrapperSource,
-  }
-
-  let body: DiagramBody
-  if (payload.body.kind === 'flowchart') {
-    const sg = payload.body.graph
-    const nodesMap = Array.isArray(sg.nodes) ? new Map(sg.nodes) : new Map(Object.entries(sg.nodes))
-    body = {
-      kind: 'flowchart',
-      graph: {
-        direction: sg.direction,
-        nodes: nodesMap,
-        edges: sg.edges ?? [],
-        // Defensive: the SDK-declared subgraph shape omits `children`/`direction`.
-        // Normalize recursively so cloneSubgraph / findSubgraphById never hit
-        // `undefined.map`. (A crash reachable straight from the documented SDK.)
-        subgraphs: normalizeSubgraphs(sg.subgraphs),
-        // Round-trip styling too, so `am parse | am serialize` is lossless.
-        classDefs: toMap(sg.classDefs),
-        classAssignments: toMap(sg.classAssignments),
-        nodeStyles: toMap(sg.nodeStyles),
-        linkStyles: toLinkStyleMap(sg.linkStyles),
-      },
-    }
-  } else if (payload.body.kind === 'opaque' || knownFamilies().includes(payload.body.kind)) {
-    // Structured bodies pass through verbatim (flowchart is rebuilt above).
-    // Membership is derived from the family registry rather than a hand-kept
-    // kind list — the old list silently dropped pie and quadrant payloads to
-    // INVALID_PAYLOAD, and would have done the same to any new family.
-    body = payload.body
-  } else {
-    return err([{ code: 'INVALID_PAYLOAD', message: 'unknown body kind' }])
-  }
-
-  const draft: ValidDiagram = {
-    kind: payload.kind, meta, body,
-    source: { nodes: new Map(), edges: new Map(), groups: new Map(), labels: new Map() },
-    canonicalSource: '',
-  }
-  return ok({ ...draft, canonicalSource: serializeMermaid(draft) })
-}
-
-interface LooseSubgraph {
-  id: string
-  label?: string
-  nodeIds?: string[]
-  children?: LooseSubgraph[]
-  direction?: import('../types.ts').Direction
-}
-
-function normalizeSubgraphs(input: unknown, seen: Set<unknown> = new Set()): import('../types.ts').MermaidSubgraph[] {
-  if (!Array.isArray(input)) return []
-  const out: import('../types.ts').MermaidSubgraph[] = []
-  for (const sg of input as Array<LooseSubgraph | null | undefined>) {
-    // Skip null/undefined elements rather than crashing.
-    if (!sg || typeof sg !== 'object') continue
-    // Cycle guard: a subgraph that points at itself (transitively) would
-    // recurse forever. Drop the cyclic edge by returning [] for children
-    // we've already visited on this branch.
-    if (seen.has(sg)) continue
-    seen.add(sg)
-    out.push({
-      id: String(sg.id ?? ''),
-      label: sg.label ?? String(sg.id ?? ''),
-      nodeIds: Array.isArray(sg.nodeIds) ? sg.nodeIds.map(String) : [],
-      children: normalizeSubgraphs(sg.children, seen),
-      direction: sg.direction,
-    })
-    seen.delete(sg)
-  }
-  return out
-}
-
-function toMap<V>(input: unknown): Map<string, V> {
-  if (input instanceof Map) {
-    // Coerce keys to string so callers can look up by string consistently.
-    const out = new Map<string, V>()
-    for (const [k, v] of input as Map<unknown, V>) out.set(String(k), v)
-    return out
-  }
-  if (Array.isArray(input)) {
-    // Only accept well-formed [k, v] tuples; ignore the rest rather than
-    // throwing 'Iterator value X is not an entry object'.
-    const out = new Map<string, V>()
-    for (const entry of input as unknown[]) {
-      if (Array.isArray(entry) && entry.length >= 2) {
-        out.set(String((entry as unknown[])[0]), (entry as unknown[])[1] as V)
-      }
-    }
-    return out
-  }
-  if (input && typeof input === 'object') {
-    return new Map(Object.entries(input as Record<string, V>))
-  }
-  return new Map()
-}
-
-function toLinkStyleMap(input: unknown): Map<number | 'default', Record<string, string>> {
-  const raw = toMap<Record<string, string>>(input)
-  const out = new Map<number | 'default', Record<string, string>>()
-  for (const [k, v] of raw) {
-    if (k === 'default') { out.set('default', v); continue }
-    // Only accept non-negative integer keys; silently drop anything else
-    // rather than producing NaN- or float-keyed entries that downstream
-    // index lookups can never find.
-    const n = Number(k)
-    if (Number.isInteger(n) && n >= 0) out.set(n, v)
-  }
-  return out
-}