@nelsonlongxiang/dsh-open-a2a-net 0.6.38 → 0.6.39

package/nexus-stage/src/edges.ts

@@ -1,72 +1,72 @@
-/**
- * Star-shaped membership edges for the 2D planning canvas: one spoke per
- * (team frame -> member card), replacing the O(n^2) pairwise mesh. All
- * geometry is world-space so the SVG layer can emit raw coordinates - the
- * transformed #world container carries them to the screen for free.
- *
- * Anchor contract (must stay in lockstep with planning.css):
- * - origin   = the frame titlebar's bottom-edge midpoint. The head is a
- *   24px border-box straddling the frame's top border at top:-13px, so
- *   its bottom edge sits at fy + 11, horizontally centered at fx + fw/2.
- * - target   = the member card's top-edge midpoint {nx, ny - NODE_H/2}.
- *
- * Cross-team members draw solid from their first membership (state order)
- * and dashed from every later one - the many-to-many invariant made
- * visible. Edges are derived only; there is no freehand edge in this
- * canvas. Pure: no DOM, no three.
- * @module nexus-stage/edges
- */
-
-import { NODE_H } from './world'
-import type { FrameGeom } from './world'
-
-/** Titlebar border-box height (planning.css .frame-head must match). */
-export const FRAME_HEAD_H = 24
-/** Titlebar CSS top offset, negative - straddles the frame's top border. */
-export const FRAME_HEAD_TOP = -13
-/** Origin anchor: frame top + the head's bottom edge offset. */
-export const FRAME_HEAD_LIFT = FRAME_HEAD_TOP + FRAME_HEAD_H
-
-/** Minimal team shape (topology.CanvasTeam satisfies it). */
-export interface EdgeTeam { name: string; members: ReadonlyArray<{ id: string }> }
-
-/** One derived spoke, ready for the SVG layer. */
-export interface StarEdge {
-  x1: number
-  y1: number
-  x2: number
-  y2: number
-  /** True from a member's second membership on (cross-team many-to-many). */
-  dashed: boolean
-  /** Team name and member id, for keyed diffing. */
-  team: string
-  id: string
-}
-
-/**
- * Compute every membership spoke for the current world. Frames without a
- * rect and member ids without a position are skipped - dangling rows are
- * a polling transient, not an error.
- */
-export function starEdges(
-  teams: ReadonlyArray<EdgeTeam>,
-  frames: ReadonlyMap<string, FrameGeom>,
-  positions: ReadonlyMap<string, { readonly x: number; readonly y: number }>,
-): StarEdge[] {
-  const out: StarEdge[] = []
-  const seen = new Set<string>()
-  for (const team of teams) {
-    const rect = frames.get(team.name)
-    if (rect === undefined) continue
-    const x1 = rect.x + rect.w / 2
-    const y1 = rect.y + FRAME_HEAD_LIFT
-    for (const member of team.members) {
-      const pos = positions.get(member.id)
-      if (pos === undefined) continue
-      const dashed = seen.has(member.id)
-      seen.add(member.id)
-      out.push({ x1, y1, x2: pos.x, y2: pos.y - NODE_H / 2, dashed, team: team.name, id: member.id })
-    }
-  }
-  return out
-}
+/**
+ * Star-shaped membership edges for the 2D planning canvas: one spoke per
+ * (team frame -> member card), replacing the O(n^2) pairwise mesh. All
+ * geometry is world-space so the SVG layer can emit raw coordinates - the
+ * transformed #world container carries them to the screen for free.
+ *
+ * Anchor contract (must stay in lockstep with planning.css):
+ * - origin   = the frame titlebar's bottom-edge midpoint. The head is a
+ *   24px border-box straddling the frame's top border at top:-13px, so
+ *   its bottom edge sits at fy + 11, horizontally centered at fx + fw/2.
+ * - target   = the member card's top-edge midpoint {nx, ny - NODE_H/2}.
+ *
+ * Cross-team members draw solid from their first membership (state order)
+ * and dashed from every later one - the many-to-many invariant made
+ * visible. Edges are derived only; there is no freehand edge in this
+ * canvas. Pure: no DOM, no three.
+ * @module nexus-stage/edges
+ */
+
+import { NODE_H } from './world'
+import type { FrameGeom } from './world'
+
+/** Titlebar border-box height (planning.css .frame-head must match). */
+export const FRAME_HEAD_H = 24
+/** Titlebar CSS top offset, negative - straddles the frame's top border. */
+export const FRAME_HEAD_TOP = -13
+/** Origin anchor: frame top + the head's bottom edge offset. */
+export const FRAME_HEAD_LIFT = FRAME_HEAD_TOP + FRAME_HEAD_H
+
+/** Minimal team shape (topology.CanvasTeam satisfies it). */
+export interface EdgeTeam { name: string; members: ReadonlyArray<{ id: string }> }
+
+/** One derived spoke, ready for the SVG layer. */
+export interface StarEdge {
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+  /** True from a member's second membership on (cross-team many-to-many). */
+  dashed: boolean
+  /** Team name and member id, for keyed diffing. */
+  team: string
+  id: string
+}
+
+/**
+ * Compute every membership spoke for the current world. Frames without a
+ * rect and member ids without a position are skipped - dangling rows are
+ * a polling transient, not an error.
+ */
+export function starEdges(
+  teams: ReadonlyArray<EdgeTeam>,
+  frames: ReadonlyMap<string, FrameGeom>,
+  positions: ReadonlyMap<string, { readonly x: number; readonly y: number }>,
+): StarEdge[] {
+  const out: StarEdge[] = []
+  const seen = new Set<string>()
+  for (const team of teams) {
+    const rect = frames.get(team.name)
+    if (rect === undefined) continue
+    const x1 = rect.x + rect.w / 2
+    const y1 = rect.y + FRAME_HEAD_LIFT
+    for (const member of team.members) {
+      const pos = positions.get(member.id)
+      if (pos === undefined) continue
+      const dashed = seen.has(member.id)
+      seen.add(member.id)
+      out.push({ x1, y1, x2: pos.x, y2: pos.y - NODE_H / 2, dashed, team: team.name, id: member.id })
+    }
+  }
+  return out
+}

package/nexus-stage/src/layout-wire.ts

@@ -1,158 +1,158 @@
-/**
- * The planning canvas's layout save loop: debounce dirty flags into one
- * POST, drive the save lamp (idle -> pending -> saved | error), and adopt
- * the host's normalized snapshot without ever fighting an in-flight drag.
- *
- * Discipline (born of the review's "empty catch" incidents):
- * - the payload is read at SEND time, so edits during the debounce window
- *   ride the same request;
- * - on success the sent document is compared against the live one - if
- *   they differ, the user edited during flight: positions are NOT touched
- *   (the live model is authoritative), the lamp stays pending, and the
- *   loop chains the follow-up save. Only an unchanged document adopts the
- *   host's normalized response, and because the client pre-clamps with
- *   the host-mirror discipline, our own echo is byte-equal and adoption
- *   is a no-op in the common case;
- * - failures surface (lamp error + the stage's throttled fault reporter),
- *   never swallowed - retry is explicit (click) or implicit (next edit).
- *
- * Pure control flow: the transport, the timer, and the clock are all
- * injected, so tests pin the ladder without a network or real time.
- * @module nexus-stage/layout-wire
- */
-
-/** Save-lamp states: grey=start, amber=unsaved, green=stored, red=failed. */
-export type LampState = 'idle' | 'pending' | 'saved' | 'error'
-
-/** Debounce window collapsing nudge storms into one request. */
-export const SAVE_DEBOUNCE_MS = 800
-
-/** What send() must resolve to: the host's {ok, layout?, error?} body. */
-export interface SaveResponse { ok: boolean; layout?: unknown; error?: string }
-
-export interface SaveLoopDeps {
-  /** The current layout document, read at send time. */
-  snapshot(): unknown
-  /** POST the document; resolve with the parsed host body, throw on transport failure. */
-  send(doc: unknown, opts: { keepalive: boolean }): Promise<SaveResponse>
-  /** Timer injection: schedule(fn, ms) returns its cancel function. */
-  schedule(fn: () => void, ms: number): () => void
-  /** Injectable clock (reserved for throttle semantics parity with fault.ts). */
-  now(): number
-  /** Lamp transitions; never called with the same state twice in a row. */
-  onLamp(state: LampState): void
-  /** Adopt the host's normalized layout (only on unchanged-document success). */
-  onAdopt(layout: unknown): void
-  /** Transport/refusal failures, for the stage's fault surface. */
-  onHttpError(message: string): void
-}
-
-export interface SaveLoop {
-  /** Something moved: lamp pending, debounced save (re-)armed. */
-  markDirty(): void
-  /** Explicit retry after an error (lamp click). */
-  retry(): void
-  /** Fire now with keepalive - the pagehide path. */
-  flush(): void
-  /** True while a request is in flight. */
-  isBusy(): boolean
-  /** Cancel the armed timer; the loop stops. */
-  dispose(): void
-}
-
-/** Create the save loop over the given dependencies. */
-export function createSaveLoop(deps: SaveLoopDeps): SaveLoop {
-  let cancelTimer: (() => void) | undefined
-  let busy = false
-  let dirty = false
-  let flushAfterSettle = false
-  let lamp: LampState = 'idle'
-
-  function setLamp(next: LampState): void {
-    if (next === lamp) return
-    lamp = next
-    deps.onLamp(next)
-  }
-
-  function clearTimer(): void {
-    if (cancelTimer !== undefined) { cancelTimer(); cancelTimer = undefined }
-  }
-
-  function arm(): void {
-    clearTimer()
-    cancelTimer = deps.schedule(() => { cancelTimer = undefined; void fire(false) }, SAVE_DEBOUNCE_MS)
-  }
-
-  async function fire(keepalive: boolean): Promise<void> {
-    if (busy) { dirty = true; return }
-    busy = true
-    clearTimer()
-    const sent = deps.snapshot()
-    let sentJson: string
-    try {
-      sentJson = JSON.stringify(sent)
-    } catch {
-      busy = false
-      setLamp('error')
-      deps.onHttpError('layout document is not JSON-serializable')
-      return
-    }
-    try {
-      const res = await deps.send(sent, { keepalive })
-      if (res === null || typeof res !== 'object' || res.ok !== true) {
-        setLamp('error')
-        const reason = res !== null && typeof res === 'object' && typeof res.error === 'string' ? res.error : 'layout save refused'
-        deps.onHttpError(`layout save: ${reason}`)
-      } else if (JSON.stringify(deps.snapshot()) === sentJson) {
-        deps.onAdopt(res.layout)
-        setLamp('saved')
-      } else {
-        // Edited mid-flight: the live model stays authoritative; the dirty
-        // handling below chains the follow-up save.
-      }
-    } catch (error) {
-      setLamp('error')
-      deps.onHttpError(`layout save unreachable: ${String((error as Error | undefined)?.message ?? error).slice(0, 80)}`)
-    }
-    busy = false
-    if (lamp === 'error') {
-      // The flush request was consumed by the failed save: retry is
-      // explicit — do not let the stale flag chain an extra keepalive.
-      flushAfterSettle = false
-      return
-    }
-    // pagehide raced a busy save: the queued edits must not wait for a
-    // debounce that a closing page will never fire — flush immediately.
-    if (flushAfterSettle) {
-      flushAfterSettle = false
-      void fire(true)
-      return
-    }
-    if (dirty) {
-      dirty = false
-      setLamp('pending')
-      arm()
-    }
-  }
-
-  return {
-    markDirty() {
-      dirty = false
-      setLamp('pending')
-      if (busy) { dirty = true; return }
-      arm()
-    },
-    retry() {
-      if (lamp !== 'error' || busy) return
-      setLamp('pending')
-      void fire(false)
-    },
-    flush() {
-      if (busy) { flushAfterSettle = true; dirty = true; return }
-      clearTimer()
-      void fire(true)
-    },
-    isBusy() { return busy },
-    dispose() { clearTimer() },
-  }
-}
+/**
+ * The planning canvas's layout save loop: debounce dirty flags into one
+ * POST, drive the save lamp (idle -> pending -> saved | error), and adopt
+ * the host's normalized snapshot without ever fighting an in-flight drag.
+ *
+ * Discipline (born of the review's "empty catch" incidents):
+ * - the payload is read at SEND time, so edits during the debounce window
+ *   ride the same request;
+ * - on success the sent document is compared against the live one - if
+ *   they differ, the user edited during flight: positions are NOT touched
+ *   (the live model is authoritative), the lamp stays pending, and the
+ *   loop chains the follow-up save. Only an unchanged document adopts the
+ *   host's normalized response, and because the client pre-clamps with
+ *   the host-mirror discipline, our own echo is byte-equal and adoption
+ *   is a no-op in the common case;
+ * - failures surface (lamp error + the stage's throttled fault reporter),
+ *   never swallowed - retry is explicit (click) or implicit (next edit).
+ *
+ * Pure control flow: the transport, the timer, and the clock are all
+ * injected, so tests pin the ladder without a network or real time.
+ * @module nexus-stage/layout-wire
+ */
+
+/** Save-lamp states: grey=start, amber=unsaved, green=stored, red=failed. */
+export type LampState = 'idle' | 'pending' | 'saved' | 'error'
+
+/** Debounce window collapsing nudge storms into one request. */
+export const SAVE_DEBOUNCE_MS = 800
+
+/** What send() must resolve to: the host's {ok, layout?, error?} body. */
+export interface SaveResponse { ok: boolean; layout?: unknown; error?: string }
+
+export interface SaveLoopDeps {
+  /** The current layout document, read at send time. */
+  snapshot(): unknown
+  /** POST the document; resolve with the parsed host body, throw on transport failure. */
+  send(doc: unknown, opts: { keepalive: boolean }): Promise<SaveResponse>
+  /** Timer injection: schedule(fn, ms) returns its cancel function. */
+  schedule(fn: () => void, ms: number): () => void
+  /** Injectable clock (reserved for throttle semantics parity with fault.ts). */
+  now(): number
+  /** Lamp transitions; never called with the same state twice in a row. */
+  onLamp(state: LampState): void
+  /** Adopt the host's normalized layout (only on unchanged-document success). */
+  onAdopt(layout: unknown): void
+  /** Transport/refusal failures, for the stage's fault surface. */
+  onHttpError(message: string): void
+}
+
+export interface SaveLoop {
+  /** Something moved: lamp pending, debounced save (re-)armed. */
+  markDirty(): void
+  /** Explicit retry after an error (lamp click). */
+  retry(): void
+  /** Fire now with keepalive - the pagehide path. */
+  flush(): void
+  /** True while a request is in flight. */
+  isBusy(): boolean
+  /** Cancel the armed timer; the loop stops. */
+  dispose(): void
+}
+
+/** Create the save loop over the given dependencies. */
+export function createSaveLoop(deps: SaveLoopDeps): SaveLoop {
+  let cancelTimer: (() => void) | undefined
+  let busy = false
+  let dirty = false
+  let flushAfterSettle = false
+  let lamp: LampState = 'idle'
+
+  function setLamp(next: LampState): void {
+    if (next === lamp) return
+    lamp = next
+    deps.onLamp(next)
+  }
+
+  function clearTimer(): void {
+    if (cancelTimer !== undefined) { cancelTimer(); cancelTimer = undefined }
+  }
+
+  function arm(): void {
+    clearTimer()
+    cancelTimer = deps.schedule(() => { cancelTimer = undefined; void fire(false) }, SAVE_DEBOUNCE_MS)
+  }
+
+  async function fire(keepalive: boolean): Promise<void> {
+    if (busy) { dirty = true; return }
+    busy = true
+    clearTimer()
+    const sent = deps.snapshot()
+    let sentJson: string
+    try {
+      sentJson = JSON.stringify(sent)
+    } catch {
+      busy = false
+      setLamp('error')
+      deps.onHttpError('layout document is not JSON-serializable')
+      return
+    }
+    try {
+      const res = await deps.send(sent, { keepalive })
+      if (res === null || typeof res !== 'object' || res.ok !== true) {
+        setLamp('error')
+        const reason = res !== null && typeof res === 'object' && typeof res.error === 'string' ? res.error : 'layout save refused'
+        deps.onHttpError(`layout save: ${reason}`)
+      } else if (JSON.stringify(deps.snapshot()) === sentJson) {
+        deps.onAdopt(res.layout)
+        setLamp('saved')
+      } else {
+        // Edited mid-flight: the live model stays authoritative; the dirty
+        // handling below chains the follow-up save.
+      }
+    } catch (error) {
+      setLamp('error')
+      deps.onHttpError(`layout save unreachable: ${String((error as Error | undefined)?.message ?? error).slice(0, 80)}`)
+    }
+    busy = false
+    if (lamp === 'error') {
+      // The flush request was consumed by the failed save: retry is
+      // explicit — do not let the stale flag chain an extra keepalive.
+      flushAfterSettle = false
+      return
+    }
+    // pagehide raced a busy save: the queued edits must not wait for a
+    // debounce that a closing page will never fire — flush immediately.
+    if (flushAfterSettle) {
+      flushAfterSettle = false
+      void fire(true)
+      return
+    }
+    if (dirty) {
+      dirty = false
+      setLamp('pending')
+      arm()
+    }
+  }
+
+  return {
+    markDirty() {
+      dirty = false
+      setLamp('pending')
+      if (busy) { dirty = true; return }
+      arm()
+    },
+    retry() {
+      if (lamp !== 'error' || busy) return
+      setLamp('pending')
+      void fire(false)
+    },
+    flush() {
+      if (busy) { flushAfterSettle = true; dirty = true; return }
+      clearTimer()
+      void fire(true)
+    },
+    isBusy() { return busy },
+    dispose() { clearTimer() },
+  }
+}

package/nexus-stage/src/seat.ts

@@ -1,35 +1,35 @@
-/**
- * Deterministic fallback seating: a session id hashes to a stable polar
- * seat, so a reload reproduces the same star map even when no layout is
- * persisted (saved layouts still win - main.ts checks them first). This
- * replaces three Math.random() calls whose only product was a star map
- * that reshuffled on every reload, making screenshots and sessions
- * incomparable. Same hash family as getHue (FNV-1a 32-bit); zero
- * dependencies so the unit test pins stability/bounds without three.
- * @module nexus-stage/seat
- */
-
-/** Radial distance bounds, mirroring the historical random-seat envelope. */
-export const SEAT_DIST_MIN = 12
-export const SEAT_DIST_MAX = 30
-/** Vertical jitter bound in world units above/below the grid plane. */
-export const SEAT_Y_SPAN = 1
-
-/** FNV-1a 32-bit - the same determinism family as getHue. */
-export function hashId(sid: string): number {
-  let h = 0x811c9dc5
-  for (let i = 0; i < sid.length; i++) {
-    h ^= sid.charCodeAt(i)
-    h = Math.imul(h, 0x01000193) >>> 0
-  }
-  return h >>> 0
-}
-
-/** Deterministic world seat (x, vertical jitter, z) for one session id. */
-export function seatFor(sid: string): { x: number; y: number; z: number } {
-  const h = hashId(sid)
-  const angle = ((h % 3600) / 3600) * Math.PI * 2
-  const dist = SEAT_DIST_MIN + (((h >>> 9) % 1800) / 1800) * (SEAT_DIST_MAX - SEAT_DIST_MIN)
-  const y = (((h >>> 18) % 2000) / 1999) * 2 * SEAT_Y_SPAN - SEAT_Y_SPAN
-  return { x: Math.cos(angle) * dist, y, z: Math.sin(angle) * dist }
-}
+/**
+ * Deterministic fallback seating: a session id hashes to a stable polar
+ * seat, so a reload reproduces the same star map even when no layout is
+ * persisted (saved layouts still win - main.ts checks them first). This
+ * replaces three Math.random() calls whose only product was a star map
+ * that reshuffled on every reload, making screenshots and sessions
+ * incomparable. Same hash family as getHue (FNV-1a 32-bit); zero
+ * dependencies so the unit test pins stability/bounds without three.
+ * @module nexus-stage/seat
+ */
+
+/** Radial distance bounds, mirroring the historical random-seat envelope. */
+export const SEAT_DIST_MIN = 12
+export const SEAT_DIST_MAX = 30
+/** Vertical jitter bound in world units above/below the grid plane. */
+export const SEAT_Y_SPAN = 1
+
+/** FNV-1a 32-bit - the same determinism family as getHue. */
+export function hashId(sid: string): number {
+  let h = 0x811c9dc5
+  for (let i = 0; i < sid.length; i++) {
+    h ^= sid.charCodeAt(i)
+    h = Math.imul(h, 0x01000193) >>> 0
+  }
+  return h >>> 0
+}
+
+/** Deterministic world seat (x, vertical jitter, z) for one session id. */
+export function seatFor(sid: string): { x: number; y: number; z: number } {
+  const h = hashId(sid)
+  const angle = ((h % 3600) / 3600) * Math.PI * 2
+  const dist = SEAT_DIST_MIN + (((h >>> 9) % 1800) / 1800) * (SEAT_DIST_MAX - SEAT_DIST_MIN)
+  const y = (((h >>> 18) % 2000) / 1999) * 2 * SEAT_Y_SPAN - SEAT_Y_SPAN
+  return { x: Math.cos(angle) * dist, y, z: Math.sin(angle) * dist }
+}

package/nexus-stage/src/stage-name.ts

@@ -1,13 +1,13 @@
-/**
- * Display name for one stage node: the session title when present, then the
- * routable team label (`team/<id8>`), then the host fallback label
- * (`dsh-host-<node>-<id8>`). Untitled cold joined sessions carry no title and
- * without the middle step the canvas drowned in dsh-host-* noise (2026-08-30
- * user report: the planning canvas showed a dozen unreadable label cards).
- * @module nexus-stage/stage-name
- */
-
-/** One node's display title. */
-export function displayName(node: { readonly name?: string; readonly team?: string; readonly label?: string }): string {
-  return node.name ?? node.team ?? node.label ?? ''
-}
+/**
+ * Display name for one stage node: the session title when present, then the
+ * routable team label (`team/<id8>`), then the host fallback label
+ * (`dsh-host-<node>-<id8>`). Untitled cold joined sessions carry no title and
+ * without the middle step the canvas drowned in dsh-host-* noise (2026-08-30
+ * user report: the planning canvas showed a dozen unreadable label cards).
+ * @module nexus-stage/stage-name
+ */
+
+/** One node's display title. */
+export function displayName(node: { readonly name?: string; readonly team?: string; readonly label?: string }): string {
+  return node.name ?? node.team ?? node.label ?? ''
+}

package/nexus-stage/src/tokens.ts

@@ -1,32 +1,32 @@
-/**
- * A2A Nexus design tokens.
- * Three-layer: primitive(C) -> semantic(S) -> component-level inline styles.
- */
-
-export const C = {
-  bg0: '#060a12',
-  bg1: '#0d1322',
-  ink: '#dde3f0',
-  inkMuted: '#7a86a0',
-  accent: '#8b5cf6',
-  liveGreen: '#4ade80',
-  coldGrey: '#4a5568',
-  lineFederal: '#6366f1',
-  membershipLine: '#22d3ee',
-} as const;
-
-/**
- * Semantic layer: the scene-facing names the viewer actually consumes,
- * each pinned to its primitive above. This is the `S` main.ts reached for
- * as `T.S.*` — the layer was documented but never exported, so every seat
- * attempt threw and cycle()'s empty catch buried it: an eternally empty
- * stage behind a healthy-looking render loop.
- */
-export const S = {
-  /** Mesh color + emissive for live session nodes (primitive liveGreen). */
-  nodeLive: 0x4ade80,
-  /** Mesh color + emissive for cold/joined-offline nodes (primitive coldGrey). */
-  nodeCold: 0x4a5568,
-} as const;
-
+/**
+ * A2A Nexus design tokens.
+ * Three-layer: primitive(C) -> semantic(S) -> component-level inline styles.
+ */
+
+export const C = {
+  bg0: '#060a12',
+  bg1: '#0d1322',
+  ink: '#dde3f0',
+  inkMuted: '#7a86a0',
+  accent: '#8b5cf6',
+  liveGreen: '#4ade80',
+  coldGrey: '#4a5568',
+  lineFederal: '#6366f1',
+  membershipLine: '#22d3ee',
+} as const;
+
+/**
+ * Semantic layer: the scene-facing names the viewer actually consumes,
+ * each pinned to its primitive above. This is the `S` main.ts reached for
+ * as `T.S.*` — the layer was documented but never exported, so every seat
+ * attempt threw and cycle()'s empty catch buried it: an eternally empty
+ * stage behind a healthy-looking render loop.
+ */
+export const S = {
+  /** Mesh color + emissive for live session nodes (primitive liveGreen). */
+  nodeLive: 0x4ade80,
+  /** Mesh color + emissive for cold/joined-offline nodes (primitive coldGrey). */
+  nodeCold: 0x4a5568,
+} as const;
+
 export const FRAME_HUES = [0x8b5cf6, 0x3b82f6, 0x14b8a6, 0xf59e0b, 0xec4899, 0x84cc16];