deepclear-ui 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepClear UI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# DeepClear UI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+新会话欢迎页的点阵鲸鱼娘和 dsh 字样装饰。
+
+- 右侧：鲸鱼娘点阵人像
+- 左侧：`deepseek` / `harness` 点阵字标
+
+## 交互
+
+- 进入欢迎页时字标整体渐显（`deepseek` 先、`harness` 后）
+- 鼠标划过字标会提亮并留短尾迹；点击会扩散一圈涟漪
+
+## 自定义
+
+改图、改点阵、改遮罩的流程见 [`scripts/README.md`](scripts/README.md)：
+
+```
+scripts\rebuild.cmd    # 采样 → 拼接 → 注入
+scripts\preview.cmd    # 生成预览图
+```
+
+Tested against dsh `0.2.2-rc.3`.

package/client.js

@@ -0,0 +1,643 @@
+/**
+ * DeepClear UI — the blank New Session surface.
+ *
+ * The blank home becomes a dotted composition: a dot-matrix portrait on the
+ * right and the deepseek / harness wordmark on the left, both driven by one
+ * canvas layer registered into `conversation.hero.frame` (the HOC slot that
+ * wraps the Conversation scroll body and reports whether the blank home shows).
+ * The layer renders the wrapped `children` unchanged and paints below the
+ * content (`z-index: -1`, `pointer-events: none`).
+ *
+ * It also hides the stock home chrome it replaces: the headline, the brand mark,
+ * and the official pixel-whale canvas. A faint `deepclear-ui` signature sits in
+ * the page corner.
+ *
+ * Everything else — whale-blue bold text, the composer focus ring, the re-inked
+ * diff plates — lives in the companion bundle `deepclear-accent`.
+ */
+window.__ModuleLoader__.load({
+  id: 'deepclear-ui',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+
+    /* ------------------------------------------------------------ hero mascot */
+
+    /** Dot grid sampled from the mascot artwork: one hex digit per cell. */
+    const GIRL_COLUMNS = 104
+    const GIRL_ROWS = 73
+    const GIRL_GRID = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000121100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013133112320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000163116400000264223200000000000000000000000000000000000000000000000000000000000000000000000000000000000326000001000000a800134000000000000000000000000000000000000000000000000000000000000000000000000000000002500000001200020000000014000000000000000000000000000000000000000000000000000000000000000000000000000000353000310023201320020000050000000000000000000000000000000000000000000000000000000000000000000000000000003000003310000000001300001b33300000000000000000000000000000000000000000000000000000000000000000000000000100010110035457764200000022002400000000000000000000000000000000000000000000000000000000000000000000000030000300006aba999accb820022000003000000000000000000000000000000000000000000000000000000000000000000000031000000224abbaa976778bca300200008900000000000000000000000000000000000000000000000000000000000000000000a1031005789787777898777679c8000000055000000000000000000000000000000000000000000000000000000000000000000b800220a98b96777777788777777ab30001008100000000000000000000000000000000000000000000000000000000000000007f00002b97b97777777777777777768c402100460000000000000000000000000000000000000000000000000000000000000000ef4000a9699777777777777778777677b600000a2000000000000000000000000000000000000000000000000000000000000000820107a68978777777777777778766788b30000c220000000000000000000000000000000000000000000000000000000000000300003b77887877777777877777787677889220af30300000000000000000000000000000000000000000000000000000000000130000897787787777777797754778877779960025d002000000000000000000000000000000000000000000000000000000000040000297777778777875878a777677977777981000870300000000000000000000000000000000000000000000000000000000003101069878778777865578779777778977778a70105a0300000000000000000000000000000000000000000000000000000000000c60288778778877744778855977777987777994004b0401000000000000000000000000000000000000000000000000000000008d00596788777777757878880497777897777888009a059800000000000000000000000000000000000000000000000000000002e00077578878668777777899203987779777778931ea57780000000000000000000000000000000000000000000000000000000aa004956788784587777777894246988789787788648688681000000000000000000000000000000000000000000000000000000ec00784679878439877777868710049888a74778877667da30000000000000000000000000000000000000000000000000000002fe20964779878408877777856800005878836877877749dd800000000000000000000000000000000000000000000000000000003c01857679879305977777762910000327985487876a7bbad90000000000000000000000000000000000000000000000000000000e00778679878433887877782610001620864877786aecbaad700000000000000000000000000000000000000000000000000002dda47786798787005868867755205cffde4587778887bbbaaad7000000000000000000000000000000000000000000000000004dccdb677778979300076788777604fc5d48fa77778868aaaaaaad50000000000000000000000000000000000000000000000003c2bcc9677778976300046677777704cb7ca0b96777796bbaaaaaaad400000000000000000000000000000000000000000000000a91ebb8777777974300002477776460abe8a02387877889acbaaaaabc2000000000000000000000000000000000000000000000009edba77777779812039a7038678400687660058787689703accbaaabc1000000000000000000000000000000000000000000000004ba977777778900dffab603624520073430087886599c00037bccbabc000000000000000000000000000000000000000000000000ba878787778908c9c89b001100000121104789756a9a900000369ccdb0000000000000000000000000000000000000000000000aca88969777893f26bbe91000111111111347a8649a98b8100000015afc000000000000000000000000000000000000000000006caa8996a877786f01a6562011111111222237a669aa888cb7414600000aa0000000000000000000000000000000000000000002daaa89b6a96777b9502742111111000111110586999998799047558778698000000000000000000000000000000000000000000bbaabaa969a77778600022011110012201100177aa7999777a400000210210000000000000000000000000000000000000000009caaadc6078b877779501112111036666010028aaa76a9a777880000000000000000000000000000000000000000000000000006daabda144a7aa778777401211105a434201000bb996699a86778400000000000000000000000000000000000000000000000005daaca4002aa7898789777532111014343101009d987769aa9677781000000000000000000000000000000000000000000000003dbcc700006c99788977a8473001110011001009db877768a9976767700000000000000000000000000000000000000000000000ddc8200005c9998789a868acb20000000011004cbb777667a9a8676786000000000000000000000000000000000000000000000bb600008867aa88977899967abc8310000000235baa7774678a99666759600000000000000000000000000000000000000000000d6269893007b9787778a788779aabcba52213425cb898536889997667509700000000000000000000000000000000000000000000562020000b97788889a967898989bb65444433278aa7647798998666810780000000000000000000000000000000000000000000000000007b7777225bca7768b989b802333331015c977677a889966777004830000000000000000000000000000000000000000000000000b7778410007c8676898ac502122222203c9877669a88a97878400096000000000000000000000000000000000000000000000006878861220003957889984001019491111ba986569a99aa447781000991000000000000000000000000000000000000000000006878785022000047576608100107e1e6000069a5458bb82000777600008a300000000000000000000000000000000000000000498787787113a00017454607a8bbac969b676067264478200000576840000995000000000000000000000000000000000000005996888788620aa0100835b607edbbdb687bdcccc6295362000000576682000198520000000000000000000000000000000000587204876892004b00214834a904fcbba9677bcbacb07a844500000098666700006965300000000000000000000000000000005740001977799000ad000077446b00cdcbada09caaae702977662001009a7666600029706200000000000000000000000000000970000088768a8102ce200085448d101cbabd706eaabb002d967885300005966665101881060000000000000000000000000001a70000078777999206cda0028435c6002babcc201dcbb7002bea6889940006a8766662588303500000000000000000000000000990000079776898a609bce005634ac006fbabbb010bbbac7002de22878a810398875555779200710000000000000000000000007a50000797777989911bbbc006348f9003bdcac60e57cabcf6008d80877984607988755545700073000000000000000000000003995003897776987a503daae81659df6000047dc30005dbbb81002dd27777906259888854545510850000000000000000000000078894688777679789006caad9593aed0001100c901001cd2000000af8677771b429888885455566740000000000000000000000098777787777787789308cab97820df4001000021000008400011004c7778726d60398888974454566400000000000000000000019665687777678778787aab768300eb00010001011200100120000158857a20cf702987876985445768740000000000000000003666668777777877767bcab8679002f40001000100013500001000000af752005f706a7789008a53450488500000000000000038867667877787787777bbab9776bb02e00000000000009e000010000002fa00009d6099877930099634303783000000000000189402766787789778778baaaa89769fa2d000000000000000000000000000dc0006dc6059877870079973530486000000000005a4000766687889777777baaaaa8b757e52d000000000000100100000000000ad003fbc606787778008889745106700000000008a1000676568888877787abaaaaa9aa77901f3000000000001001000000000008c000acba3777877900977896550070000000008b00001756568888877787baaaaaaa9baba00f8002210000000000000000000009b000cbab967678785787788966305000000007a4000046466588888777769cbaaaaaaaabd10be1123232100106a001000000000c800ccaaaa767677788777a258556400000004980000065466579888777765acbbaaaaabbcc04f9012222321107c011011122005f200dbaaab96776777777880086561000000078700001654465688887775665bbbbaaaaabcd009f702222223221012233323321ec02bcbaaaab86776777788000475620'
+    const GIRL_LINES = '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001221000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050551247200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e601e8000001b624620000000000000000000000000000000000000000000000000000000000000000000000000000000000061f000000000000ff00068000000000000000000000000000000000000000000000000000000000000000000000000000000004b000000004000300000000090000000000000000000000000000000000000000000000000000000000000000000000000000006c5000600015100520030000080000000000000000000000000000000000000000000000000000000000000000000000000000005000005700000000000400000f55700000000000000000000000000000000000000000000000000000000000000000000000000100020000012125521100000021002800000000000000000000000000000000000000000000000000000000000000000000000070000600003fea779dfff910011000005000000000000000000000000000000000000000000000000000000000000000000000050000000112deb98422225efe10010000ff00000000000000000000000000000000000000000000000000000000000000000000f006000259b233233353322239fb000000099000000000000000000000000000000000000000000000000000000000000000000fd00110f95f52223222233323323cf1000000f000000000000000000000000000000000000000000000000000000000000000007f00001f82a43333333332333333324f2010005c0000000000000000000000000000000000000000000000000000000000000000ff1000f9254333333333333333333223f400000f1000000000000000000000000000000000000000000000000000000000000000f10008e23433333333333333323322333f10000f110000000000000000000000000000000000000000000000000000000000000300001f3333333333333332322234223335d110ff10400000000000000000000000000000000000000000000000000000000000060000983333333333333353222323422326920012f0010000000000000000000000000000000000000000000000000000000000700001d33333333334223239232232632323990000da0300000000000000000000000000000000000000000000000000000000004000059333333333322223337333323523324b70002f0100000000000000000000000000000000000000000000000000000000000f901b5333323333212233322b333326323336c1001f010000000000000000000000000000000000000000000000000000000000cf002b22333332332224343601a333236233237800bf02ee00000000000000000000000000000000000000000000000000000001f00085233324224333332369101a43326323334910fb246d0000000000000000000000000000000000000000000000000000000ff002c22333262273333333492116b733342333452152332b0000000000000000000000000000000000000000000000000000000ff00791234337119333333327a0002c533a31233332223f810000000000000000000000000000000000000000000000000000001ff10d22234338108633332422d00002735612433323313cf300000000000000000000000000000000000000000000000000000001f00a22235339102933322321f0000011287223333273743f80000000000000000000000000000000000000000000000000000000f005242343381118533222618000002104213333324f8433f400000000000000000000000000000000000000000000000000001ff813332243288004825322522102fffff1253323333654344f2000000000000000000000000000000000000000000000000001fc9d823332342b100082453224601fd2f13f9333233234333344f20000000000000000000000000000000000000000000000001f16683233323634100013233324901f72c90f82333342894333335f100000000000000000000000000000000000000000000000f90f453233323751100001163242270bdf3c011423323347e9433336f100000000000000000000000000000000000000000000000dfd4432333326801018d201b46b200572260025333233201afc84349f0000000000000000000000000000000000000000000000001a4323333334900fff7c2017129100b1110083432243f00013dfd97bf000000000000000000000000000000000000000000000000b5333233233806f3a36f000100000010002547322739900000128ffff0000000000000000000000000000000000000000000000cb533325322361f12ccfb0000000000000124b3225733e7000000002bff000000000000000000000000000000000000000000002f4433327322342f00e2251000000000111116b22584333ff9204a00000ff0000000000000000000000000000000000000000001f54433a2642323c9201a1100000000000001023243333325b03d86fced4fe000000000000000000000000000000000000000000f943548724822224200011000000001100000043662334223d100000100100000000000000000000000000000000000000000008e444ff2023932322b20000100002babe00001896932434322780000000000000000000000000000000000000000000000000002f548fa0119276333225100110009f214200000ea33224353222a200000000000000000000000000000000000000000000000002f66eb1001b72343235325211000005343000008f3332234432224a0000000000000000000000000000000000000000000000001fbdf300002e333333239322100000000000000af932222363422226a00000000000000000000000000000000000000000000000fff5100002f434333383238ff10000000000001f8722322353532223b8000000000000000000000000000000000000000000000ff20000ff45b5333323433228bf5100000000112e73232123343422222e900000000000000000000000000000000000000000000f515fef1003a3233223533322389dfff41102612fa33321233335222420fb00000000000000000000000000000000000000000000591010000f622557477323343333be36255411134662222343333222800cf0000000000000000000000000000000000000000000000000005f2236112ff922238333c601111111002f4332227333522246003f10000000000000000000000000000000000000000000000000f3337100006f52323437f201011111101f43322245338836491000fb000000000000000000000000000000000000000000000005623440110001d2253675100000c1f0000fa542224767ef1175b0000ff0000000000000000000000000000000000000000000004734352011000015242207000004f1f2000027d2125df9100065780000ff1000000000000000000000000000000000000000002e9343376001f00009121203b3dd8f324d222022121169100000272a10000ff3000000000000000000000000000000000000006ff2633269710ff0000c12f303fc66e72338eceef21c21410000002622b10001fa6100000000000000000000000000000000009fc1026323a1001f00102c11da02f744332237754ce03f6214000000e9222900005d46200000000000000000000000000000009f50000b3228a000cf0000b7112f00fc444d803a444f30172225100000fe222470001c70a100000000000000000000000000000fc00000b522398001ff1000d2126f000c444f302f444c001f6236a2100002922246000bc00d0000000000000000000000000000fc000008822246a102efb001d112f20018447f100f8463001ff9256ab20003c42224712ab102900000000000000000000000000ff000008b322354b20899f005511af005f9446c000b644d2001ff11536fc001c542222257e100f00000000000000000000000009f200009b3223536a10d46d006113f8001ffa4e20f22c45df7007f303328815056353222129000e3000000000000000000000001d92001aa3222433a201f44f30325ff2000013ff10002faafa0001ff12322904129334422222400d500000000000000000000000995a12a7222234338002e44f62c18ff0000000fd00000ff1000000cf3233440f2195334421223659100000000000000000000000c6322452222243337103a4632910ff100000001000000d200012001f2337712f2018333493112123610000000000000000000000c222242222233333232558325100ff00010000000400000010000025322f10ff201933432ca211287dc200000000000000000017322243222323333229a463228001f10001000000002700000000000df321002f202b323900ae212201cd60000000000000002fd6622243223323332375443222cf01f0000100010000ff000010000001fb00006f20b8322b100ab212101be10000000000000ff3016223322352333237444434225fb1f000000001000000000010000000ff0002fe20284228600598212101f8000000000007f500083223333432333364443439222f21f000000001000000000000000000ef001f9c20235324b008538313009d0000000000ef0000772223333332233554443434422500f1000000000000000000000000009f00089641323422a009234922400e000000000df00001922224333322233a44344443448900f900140000000000000000000000df000d547522233252242246a24109000000009f1000056242253333222323c4433444444f00ff001324200000cf000000000000fa00fc4446222223255222c12b229300000001eb000008312223433322232249444444445cf01fb00111241000df000000133002f100f64446322222322228900c32900000000ab80000082112224333223222244444444448f007f701111224110001246323310ff01fd44444832222322248000172810'
+
+    /** Grid aspect (width / height), used to keep the portrait undistorted. */
+    const GIRL_ASPECT = GIRL_COLUMNS / GIRL_ROWS
+
+    /** Wordmark set in dots on the left: two lines, sampled from live text. */
+    const LOCKUP_LINES = ['deepseek', 'harness']
+    const LOCKUP_COLUMNS = 140
+    const LOCKUP_ROWS = 58
+
+    /** Alpha buckets drawn per frame, so the twinkle costs one fill per level. */
+    const LEVELS = 7
+    const TAU = Math.PI * 2
+
+    /**
+     * Twinkle refresh rate. The field is dense, so the frame budget is kept
+     * loose: slow alpha breathing reads the same at 16 fps, and the canvas is
+     * only alive while the blank home is on screen.
+     */
+    const FRAME_MS = 1000 / 16
+
+    /** One dot's cell in CSS pixels: fixed, so dots never scale with the window. */
+    const DOT_PITCH = 9
+
+    /** Smallest dot pitch the wordmark may use before it is dropped. */
+    const TEXT_MIN_PITCH = 3.6
+
+    /** Wordmark assembly: dots reveal left to right over this long. */
+    const ASSEMBLY_MS = 1000
+
+    /** Each line's slice of the assembly, in timeline fractions: line 1 starts
+     *  while line 0 is still finishing, so the two never pop at once. */
+    const ASSEMBLY_SECOND_LINE = 0.42
+    const ASSEMBLY_LINE_SPAN = 0.58
+
+    /** Temporary on-canvas readout used to diagnose layout mismatches. */
+    const DEBUG = false
+
+    /** Dot model of the portrait for the light canvas (ink-weighted). */
+    let dotModel
+
+    /** Dot model of the portrait for the dark canvas (line-art weighted). */
+    let lineModel
+
+    /** Dot model of the wordmark, built once by rasterising live text. */
+    let lockupModel
+
+    /**
+     * Decode one hex grid into dots: one dot per non-empty cell, weight from the
+     * digit, each with its own twinkle phase and speed so the field never blinks
+     * in unison.
+     * @param cells - one hex digit per grid cell, row-major.
+     * @returns dots in normalised space (`u`/`v` 0..1, `a` weight 0..1).
+     */
+    function decodeGrid(cells) {
+      const dots = []
+      for (let index = 0; index < cells.length; index += 1) {
+        const weight = Number.parseInt(cells[index], 16)
+        if (!(weight > 0)) continue
+        const row = Math.floor(index / GIRL_COLUMNS)
+        const column = index % GIRL_COLUMNS
+        dots.push({
+          u: (column + 0.5) / GIRL_COLUMNS,
+          v: (row + 0.5) / GIRL_ROWS,
+          a: weight / 15,
+          phase: Math.random() * TAU,
+          speed: 0.5 + Math.random() * 0.8,
+        })
+      }
+      return dots
+    }
+
+    /**
+     * Light canvas: the artwork's ink drives dot weight, so dark hair and the
+     * dark dress read dark on the pale canvas.
+     * @returns dots in normalised space.
+     */
+    function mascotDots() {
+      if (dotModel === undefined) dotModel = decodeGrid(GIRL_GRID)
+      return dotModel
+    }
+
+    /**
+     * Dark canvas: the dots are light, so the artwork's ink is inverted — skin
+     * and the white apron become dense bright dots while ink-heavy hair and the
+     * dress fade back into the canvas. Cells with no ink but enclosed by the
+     * figure count as full weight, which is what keeps the face from turning
+     * into an empty hole.
+     * @returns dots in normalised space.
+     */
+    function invertedDots() {
+      if (lineModel !== undefined) return lineModel
+      const total = GIRL_COLUMNS * GIRL_ROWS
+      const occupied = new Uint8Array(total)
+      const weight = new Float32Array(total)
+      for (let index = 0; index < GIRL_GRID.length && index < total; index += 1) {
+        const value = Number.parseInt(GIRL_GRID[index], 16)
+        if (!(value > 0)) continue
+        occupied[index] = 1
+        weight[index] = value / 15
+      }
+      const rowFirst = new Int32Array(GIRL_ROWS).fill(-1)
+      const rowLast = new Int32Array(GIRL_ROWS).fill(-1)
+      const columnFirst = new Int32Array(GIRL_COLUMNS).fill(-1)
+      const columnLast = new Int32Array(GIRL_COLUMNS).fill(-1)
+      for (let row = 0; row < GIRL_ROWS; row += 1) {
+        for (let column = 0; column < GIRL_COLUMNS; column += 1) {
+          if (occupied[row * GIRL_COLUMNS + column] === 0) continue
+          if (rowFirst[row] < 0) rowFirst[row] = column
+          rowLast[row] = column
+          if (columnFirst[column] < 0) columnFirst[column] = row
+          columnLast[column] = row
+        }
+      }
+      const dots = []
+      for (let row = 0; row < GIRL_ROWS; row += 1) {
+        for (let column = 0; column < GIRL_COLUMNS; column += 1) {
+          if (row < columnFirst[column] || row > columnLast[column]) continue
+          if (column < rowFirst[row] || column > rowLast[row]) continue
+          const index = row * GIRL_COLUMNS + column
+          const alpha = occupied[index] === 1 ? 1 - weight[index] : 1
+          if (alpha < 0.45) continue
+          dots.push({
+            u: (column + 0.5) / GIRL_COLUMNS,
+            v: (row + 0.5) / GIRL_ROWS,
+            a: alpha,
+            phase: Math.random() * TAU,
+            speed: 0.5 + Math.random() * 0.8,
+          })
+        }
+      }
+      lineModel = dots
+      return dots
+    }
+
+    /**
+     * Rasterise the two wordmark lines with the UI font and reduce them to the
+     * same dotted grid the portrait uses.
+     * @returns dots in normalised block space (`u`/`v` 0..1, `a` weight 0..1).
+     */
+    function lockupDots() {
+      if (lockupModel !== undefined) return lockupModel
+      const supersample = 4
+      const family = '"Segoe UI", system-ui, sans-serif'
+      // Display treatment: heavy italic with wide tracking, filled solid. Each
+      // line is rasterised on its own canvas, so a descender that crosses the
+      // other line's band still belongs to its own colour.
+      const style = 'italic 700'
+      const probe = document.createElement('canvas').getContext('2d')
+      probe.font = `${style} 100px ${family}`
+      if ('letterSpacing' in probe) probe.letterSpacing = '6px'
+      const width = LOCKUP_COLUMNS * supersample
+      const height = LOCKUP_ROWS * supersample
+      const widest = Math.max(...LOCKUP_LINES.map(line => probe.measureText(line).width), 1)
+      const size = ((width * 0.94) / widest) * 100
+      const model = LOCKUP_LINES.map((line, lineIndex) => {
+        const big = document.createElement('canvas')
+        big.width = width
+        big.height = height
+        const bigContext = big.getContext('2d')
+        bigContext.textAlign = 'left'
+        bigContext.textBaseline = 'middle'
+        if ('letterSpacing' in bigContext) bigContext.letterSpacing = '6px'
+        bigContext.font = `${style} ${size.toFixed(1)}px ${family}`
+        bigContext.fillStyle = 'rgba(255, 255, 255, 0.92)'
+        bigContext.fillText(line, width * 0.02, height * (0.34 + 0.4 * lineIndex))
+
+        const small = document.createElement('canvas')
+        small.width = LOCKUP_COLUMNS
+        small.height = LOCKUP_ROWS
+        const smallContext = small.getContext('2d')
+        smallContext.drawImage(big, 0, 0, LOCKUP_COLUMNS, LOCKUP_ROWS)
+        const pixels = smallContext.getImageData(0, 0, LOCKUP_COLUMNS, LOCKUP_ROWS).data
+        const dots = []
+        for (let index = 0; index < LOCKUP_COLUMNS * LOCKUP_ROWS; index += 1) {
+          const alpha = pixels[index * 4 + 3] / 255
+          if (alpha < 0.08) continue
+          dots.push({
+            u: ((index % LOCKUP_COLUMNS) + 0.5) / LOCKUP_COLUMNS,
+            v: (Math.floor(index / LOCKUP_COLUMNS) + 0.5) / LOCKUP_ROWS,
+            a: Math.min(1, alpha * 1.25),
+            phase: Math.random() * TAU,
+            speed: 0.5 + Math.random() * 0.8,
+          })
+        }
+        return dots
+      })
+      lockupModel = model
+      return model
+    }
+
+    /**
+     * Paint the dot mascot and wordmark into a canvas, twinkling in place.
+     * @param canvas - the frame canvas sized to the conversation area.
+     * @returns disposer that cancels the animation and observers.
+     */
+    function attachMascot(canvas) {
+      const context = canvas.getContext('2d')
+      if (context === null) return () => {}
+      const portraitLight = mascotDots()
+      const portraitDark = invertedDots()
+      const wordmark = lockupDots()
+      const reduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches
+      const started = performance.now()
+      let width = 1
+      let height = 1
+      let dpr = 1
+      let frame = 0
+      let drawnAt = 0
+      let disposed = false
+      /** Composer card geometry in canvas coordinates; the composition's bound. */
+      let composerLeft = 0
+      let composerWidth = 0
+      let composerTop = 0
+      let composerNode = null
+      const composerObserver = new ResizeObserver(() => { readComposer() })
+
+      /** Re-read the composer card (it mounts with the hero and resizes with it). */
+      const readComposer = () => {
+        const canvasRect = canvas.getBoundingClientRect()
+        // Pick the composer card that actually overlaps this conversation area:
+        // hidden or off-screen cards (other panels, mounted shells) must not
+        // become the layout bound.
+        let node = null
+        let rect = null
+        for (const candidate of document.querySelectorAll('[data-composer-card]')) {
+          const box = candidate.getBoundingClientRect()
+          if (box.width < 80 || box.height < 20) continue
+          if (box.right <= canvasRect.left || box.left >= canvasRect.right) continue
+          if (rect === null || box.width > rect.width) {
+            node = candidate
+            rect = box
+          }
+        }
+        if (node !== composerNode) {
+          composerObserver.disconnect()
+          composerNode = node
+          if (node !== null) composerObserver.observe(node)
+        }
+        if (node === null || rect === null) {
+          composerLeft = 0
+          composerWidth = 0
+          composerTop = 0
+          return
+        }
+        composerLeft = rect.left - canvasRect.left
+        composerWidth = rect.width
+        composerTop = rect.top - canvasRect.top
+      }
+
+      /** Last canvas box in viewport coordinates, for pointer hit-testing. */
+      let boxLeft = 0
+      let boxTop = 0
+      let boxWidth = 0
+      let boxHeight = 0
+      /** Pointer position in canvas coordinates; inactive while outside. */
+      let pointerX = -1e6
+      let pointerY = -1e6
+      let pointerActive = false
+      const onPointerMove = (event) => {
+        pointerX = event.clientX - boxLeft
+        pointerY = event.clientY - boxTop
+        pointerActive = pointerX >= 0 && pointerY >= 0 && pointerX <= boxWidth && pointerY <= boxHeight
+        if (pointerActive) {
+          trail.push({ x: pointerX, y: pointerY, at: performance.now() })
+          if (trail.length > 8) trail.shift()
+        }
+        if (reduced) paint(performance.now())
+      }
+      const onPointerLeave = () => { pointerActive = false }
+      /** Recent pointer samples so the light leaves a short, fading trail. */
+      const trail = []
+      /** Click ripples: origin plus start time, oldest first. */
+      const ripples = []
+      const onPointerDown = (event) => {
+        const x = event.clientX - boxLeft
+        const y = event.clientY - boxTop
+        if (x < 0 || y < 0 || x > boxWidth || y > boxHeight) return
+        ripples.push({ x, y, at: performance.now() })
+        if (ripples.length > 5) ripples.shift()
+      }
+
+
+      const measure = () => {
+        const rect = canvas.getBoundingClientRect()
+        dpr = Math.min(window.devicePixelRatio || 1, 2)
+        width = Math.max(1, rect.width)
+        height = Math.max(1, rect.height)
+        canvas.width = Math.round(width * dpr)
+        canvas.height = Math.round(height * dpr)
+        boxLeft = rect.left
+        boxTop = rect.top
+        boxWidth = width
+        boxHeight = height
+        readComposer()
+      }
+
+      /**
+       * Draw one frame: both groups hold still and only their alpha breathes.
+       * @param now - frame timestamp.
+       */
+      const paint = (now) => {
+        if (disposed) return
+        // The assembly is a short, fast reveal: give it a smoother frame rate
+        // than the slow twinkle, then fall back to the cheap cadence.
+        const assembling = now - started < ASSEMBLY_MS + 80
+        const interval = (assembling ? 1000 / 60 : FRAME_MS) - 1
+        if (!reduced && now - drawnAt < interval) {
+          frame = requestAnimationFrame(paint)
+          return
+        }
+        drawnAt = now
+        const time = reduced ? 0 : (now - started) / 1000
+        const dark = document.body.hasAttribute('data-ds-dark-theme')
+        const ink = dark ? '236, 238, 242' : '102, 108, 120'
+        // The composer card is the layout's bound: the pair is centred on it and
+        // can never be wider than the input box.
+        const limit = composerWidth > 160 ? composerWidth : width * 0.94
+        const originX = composerWidth > 160 ? composerLeft : (width - limit) / 2
+
+        // One pitch drives both groups: the wordmark and the portrait always share
+        // the same dot size, and that pitch scales with the space available. Two
+        // hard bounds: the composer width (the pair never exceeds the input box)
+        // and the space above the composer (the pair hangs above it instead of
+        // being covered by it).
+        const availW = limit * 0.94
+        const pairCells = LOCKUP_COLUMNS + GIRL_COLUMNS - 30
+        const bandTop = composerTop > 140 ? composerTop : height * 0.86
+        const heightPitch = Math.max(1, bandTop - 8) / GIRL_ROWS
+        let pitch = Math.min(DOT_PITCH, availW / pairCells, heightPitch)
+        let showText = true
+        if (pitch < TEXT_MIN_PITCH) {
+          // Only when the type would fall below the readable floor: drop the
+          // wordmark and keep the portrait as large as it can be.
+          showText = false
+          pitch = Math.min(DOT_PITCH, availW / GIRL_COLUMNS, heightPitch)
+        }
+        if (pitch < 2.2) {
+          context.setTransform(dpr, 0, 0, dpr, 0, 0)
+          context.clearRect(0, 0, width, height)
+          return
+        }
+        const blockW = LOCKUP_COLUMNS * pitch
+        const blockH = LOCKUP_ROWS * pitch
+        const portraitW = GIRL_COLUMNS * pitch
+        const portraitH = GIRL_ROWS * pitch
+        const overlap = Math.max(8, pitch * 30)
+        const pairW = blockW + portraitW - overlap
+
+        // Hang the pair off the composer: the portrait's bottom edge sits on the
+        // composer's top edge, and the dot pitch above guaranteed it fits there.
+        const portraitY = Math.min(
+          Math.max(bandTop - portraitH / 2, 6 + portraitH / 2),
+          Math.max(6 + portraitH / 2, height - portraitH / 2 - 6),
+        )
+        let portraitX
+        let blockX = 0
+        if (showText) {
+          blockX = originX + Math.max(0, (limit - pairW) / 2)
+          portraitX = blockX + blockW - overlap + portraitW / 2
+        } else {
+          portraitX = originX + limit / 2
+        }
+        // Keep the pair inside the canvas even if the composer rect was odd.
+        const minX = portraitW / 2 + 6
+        const maxX = Math.max(minX, width - portraitW / 2 - 6)
+        portraitX = Math.min(Math.max(portraitX, minX), maxX)
+        const blockY = portraitY - blockH / 2
+        const portraitRadius = Math.max(0.8, pitch * 0.28)
+        const lockupRadius = Math.max(0.8, pitch * 0.34)
+
+        // The portrait runs one opacity notch brighter than the wordmark, so the
+        // two groups keep separate alpha ladders.
+        const portraitPaths = []
+        const wordmarkPaths = [[], []]
+        for (let level = 0; level < LEVELS; level += 1) {
+          portraitPaths.push(new Path2D())
+          wordmarkPaths[0].push(new Path2D())
+          wordmarkPaths[1].push(new Path2D())
+        }
+
+        // Wordmark assembly: dots light up left to right, with a bright front.
+        const assembly = reduced ? 1 : Math.min(1, (now - started) / ASSEMBLY_MS)
+        while (ripples.length > 0 && now - ripples[0].at > 760) ripples.shift()
+        const trailNow = trail.filter(sample => now - sample.at < 420)
+        const rippleBoost = (x, y) => {
+          let best = 0
+          for (const ripple of ripples) {
+            const age = (now - ripple.at) / 760
+            const radius = age * 640
+            const dx = x - ripple.x
+            const dy = y - ripple.y
+            if (dx * dx + dy * dy > (radius + 200) * (radius + 200)) continue
+            const distance = Math.sqrt(dx * dx + dy * dy)
+            if (Math.abs(distance - radius) > 160) continue
+            const band = Math.exp(-Math.pow((distance - radius) / 44, 2))
+            best = Math.max(best, band * (1 - age))
+          }
+          return 1 + 1.25 * best
+        }
+        const trailBoost = (x, y) => {
+          let best = 0
+          for (const sample of trailNow) {
+            const age = Math.max(0, (now - sample.at) / 420)
+            const dx = x - sample.x
+            const dy = y - sample.y
+            if (Math.abs(dx) > 260 || Math.abs(dy) > 260) continue
+            best = Math.max(best, Math.exp(-(dx * dx + dy * dy) / (2 * 95 * 95)) * (1 - age))
+          }
+          return 1 + 0.95 * best
+        }
+        const place = (target, dot, x, y, radius, kind, line) => {
+          // The portrait holds a steady level; only the wordmark breathes.
+          const breathe = reduced ? 0.6 : 0.5 + 0.5 * Math.sin(time * dot.speed + dot.phase)
+          let tone = kind === 'portrait' ? dot.a : dot.a * (0.35 + 0.65 * breathe)
+          if (kind === 'wordmark') {
+            if (assembly < 1) {
+              // Whole-word fade: the line rises as one piece, no left-to-right sweep.
+              const offset = line === 1 ? ASSEMBLY_SECOND_LINE : 0
+              const progress = Math.max(0, Math.min(1, (assembly - offset) / ASSEMBLY_LINE_SPAN))
+              const smooth = progress * progress * (3 - 2 * progress)
+              if (smooth <= 0.02) return
+              tone *= smooth
+            }
+            if (pointerActive) tone *= trailBoost(x, y)
+          }
+          // Ripples are a wordmark effect; the portrait stays untouched.
+          if (kind === 'wordmark') tone = Math.min(1, tone * rippleBoost(x, y))
+          const level = Math.min(LEVELS - 1, Math.max(0, Math.round(tone * (LEVELS - 1))))
+          // Halftone weighting: heavier cells draw slightly larger dots, so the
+          // field reads as printed ink rather than a uniform grid.
+          const size = radius * (0.82 + 0.36 * dot.a)
+          target[level].moveTo(x + size, y)
+          target[level].arc(x, y, size, 0, TAU)
+        }
+        const portrait = dark ? portraitDark : portraitLight
+        for (const dot of portrait) {
+          place(
+            portraitPaths,
+            dot,
+            portraitX + (dot.u - 0.5) * portraitW,
+            portraitY + (dot.v - 0.5) * portraitH,
+            portraitRadius,
+            'portrait',
+          )
+        }
+        if (showText) {
+          wordmark.forEach((dots, index) => {
+            for (const dot of dots) {
+              place(
+                wordmarkPaths[index],
+                dot,
+                blockX + dot.u * blockW,
+                blockY + dot.v * blockH,
+                lockupRadius,
+                'wordmark',
+                index,
+              )
+            }
+          })
+        }
+
+        context.setTransform(dpr, 0, 0, dpr, 0, 0)
+        context.clearRect(0, 0, width, height)
+        const paintGroup = (paths, boost, color) => {
+          for (let level = 0; level < LEVELS; level += 1) {
+            const alpha = Math.min(1, (0.05 + (level / (LEVELS - 1)) * 0.5) * boost).toFixed(3)
+            context.fillStyle = `rgba(${color}, ${alpha})`
+            context.fill(paths[level])
+          }
+        }
+        // The portrait's opacity nudge flips with the palette: +10% on the light
+        // canvas, and its inverse trim on the dark one, where light dots already
+        // read brighter against the canvas.
+        paintGroup(portraitPaths, dark ? 1.15 : 1.5, ink)
+        if (showText) {
+          paintGroup(wordmarkPaths[0], 1, ink)
+          paintGroup(wordmarkPaths[1], 1, '122, 170, 255')
+        }
+        if (DEBUG) {
+          context.fillStyle = '#ff5555'
+          context.font = '12px monospace'
+          const readout = [
+            'pitch=' + pitch.toFixed(2) + ' limit=' + limit.toFixed(0) + ' composerTop=' + composerTop.toFixed(0),
+            'canvas=' + width.toFixed(0) + 'x' + height.toFixed(0) + ' dpr=' + dpr + ' showText=' + showText,
+            'portrait=' + portraitW.toFixed(0) + 'x' + portraitH.toFixed(0)
+              + ' @ ' + portraitX.toFixed(0) + ',' + portraitY.toFixed(0),
+            'block=' + blockW.toFixed(0) + 'x' + blockH.toFixed(0)
+              + ' @ ' + blockX.toFixed(0) + ',' + blockY.toFixed(0),
+          ]
+          readout.forEach((line, index) => context.fillText(line, 12, 20 + index * 16))
+          context.strokeStyle = '#ff5555'
+          context.strokeRect(portraitX - portraitW / 2, portraitY - portraitH / 2, portraitW, portraitH)
+          context.strokeStyle = '#5599ff'
+          context.strokeRect(blockX, blockY, blockW, blockH)
+        }
+        if (!reduced) frame = requestAnimationFrame(paint)
+      }
+
+      const observer = new ResizeObserver(() => {
+        measure()
+        if (reduced) paint(performance.now())
+      })
+      observer.observe(canvas)
+      window.addEventListener('pointermove', onPointerMove, { passive: true })
+      window.addEventListener('pointerleave', onPointerLeave, { passive: true })
+      window.addEventListener('pointerdown', onPointerDown, { passive: true })
+      measure()
+      frame = requestAnimationFrame(paint)
+
+      return () => {
+        disposed = true
+        cancelAnimationFrame(frame)
+        observer.disconnect()
+        composerObserver.disconnect()
+        window.removeEventListener('pointermove', onPointerMove)
+        window.removeEventListener('pointerleave', onPointerLeave)
+        window.removeEventListener('pointerdown', onPointerDown)
+      }
+    }
+
+    /**
+     * Frame layer for the blank home: paint the dot mascot below the content and
+     * pass the wrapped scroll body through untouched.
+     * @param props - the home flag and the wrapped Conversation body.
+     * @returns the layout-neutral frame.
+     */
+    function HeroFrame({ hero, children }) {
+      const canvasRef = React.useRef(null)
+      React.useEffect(() => {
+        const canvas = canvasRef.current
+        if (hero !== true || canvas === null) return undefined
+        return attachMascot(canvas)
+      }, [hero])
+      return h('div', { className: 'dwe-frame' },
+        hero === true ? h('div', { key: 'sign', className: 'dwe-sign' }, 'deepclear-ui') : null,
+        hero === true ? h('canvas', { key: 'mascot', ref: canvasRef, className: 'dwe-whale', 'aria-hidden': 'true' }) : null,
+        children)
+    }
+
+
+    /* ---------------------------------------------------------------- styles */
+
+const CSS = `
+/* Hero frame layer: layout-neutral wrapper (display: contents keeps the wrapped
+   scroll body a direct flex item) plus one canvas that sits above the
+   Conversation background and below its content. */
+.dwe-frame {
+  display: contents;
+}
+.dwe-whale {
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  width: 100%;
+  height: 100%;
+  display: block;
+  pointer-events: none;
+}
+
+/* One whale on the blank home: the official pixel whale would otherwise sit
+   behind this dot field, so its canvas is hidden. It keeps its slot layer and
+   still renders the wrapped content; only its artwork is suppressed. */
+[data-home-whale] {
+  display: none !important;
+}
+
+/* Blank-home headline: drop the "探索未至之境 · 预览版" line and the brand mark
+   beside it, leaving the dot portrait alone above the composer. The title group
+   is a CSS-module class (matched by its local name inside the hash, scoped by
+   the headline ancestor); the mark is the hero's own brand slot, matched by its
+   public slot key. If upstream renames either hook the rule simply stops
+   applying. */
+[class*="headline"] [class*="titleGroup"],
+[data-slot="conversation.hero.brand.mark"] {
+  display: none !important;
+}
+
+/* Product signature: only while the blank home is on screen, because the
+   element lives inside the hero frame layer. */
+.dwe-sign {
+  position: fixed;
+  right: 14px;
+  bottom: 10px;
+  z-index: 2147483000;
+  font-size: 11px;
+  letter-spacing: 0.08em;
+  color: var(--dsw-alias-label-tertiary);
+  opacity: 0.28;
+  pointer-events: none;
+  user-select: none;
+}
+`
+
+    return {
+      inject: ['slots'],
+      apply(ctx) {
+        ctx.effect(() => {
+          const style = document.createElement('style')
+          style.dataset.dshPlugin = 'deepclear-ui'
+          style.textContent = CSS
+          document.head.append(style)
+          return () => { style.remove() }
+        }, 'whale-emphasis: accent styles')
+
+        ctx.slots.inject('conversation.hero.frame', () => ctx.slots.register({
+          name: 'conversation.hero.frame',
+          id: 'dot-whale',
+          order: 20,
+        }, HeroFrame))
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: deepclear-ui
+      name: deepclear-ui

package/docs/DETAIL.md

@@ -0,0 +1 @@
+![The dot-matrix welcome page: a deepseek / harness wordmark on the left and the mascot portrait on the right](preview.svg)

package/docs/preview.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="640" height="300" viewBox="0 0 640 300">
+  <image x="0" y="0" width="640" height="300" preserveAspectRatio="xMidYMid slice" href="data:image/png;base64,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"/>
+</svg>

package/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36">
+  <rect x="8" y="11" width="20" height="3.5" rx="1.75" fill="#4D6BFE"/>
+  <rect x="8" y="17.25" width="15" height="3.5" rx="1.75" fill="#4D6BFE" opacity="0.5"/>
+  <rect x="8" y="23.5" width="11" height="3.5" rx="1.75" fill="#4D6BFE" opacity="0.3"/>
+</svg>

package/index.js

@@ -0,0 +1,5 @@
+/**
+ * Host half of the whale-emphasis bundle. The rendering is entirely a Client
+ * concern (`client.js`); this entry exists so the bundle owns a Loader row.
+ */
+export function apply() {}

package/locale/en.json

@@ -0,0 +1,7 @@
+{
+  "meta": {
+    "title": "DeepClear UI",
+    "description": "Dot-matrix mascot and dsh wordmark decoration for the new-session welcome page.",
+    "detail": "docs/DETAIL.md"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,7 @@
+{
+  "meta": {
+    "title": "DeepClear UI",
+    "description": "新会话欢迎页的点阵鲸鱼娘和 dsh 字样装饰。",
+    "detail": "docs/DETAIL.md"
+  }
+}

package/package.json

@@ -1,6 +1,46 @@
-{
-  "name": "deepclear-ui",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "deepclear-ui",
+  "version": "1.0.0",
+  "private": false,
+  "type": "module",
+  "description": "DeepClear UI — the dot-matrix welcome surface: a mascot portrait plus a deepseek / harness wordmark.",
+  "license": "MIT",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "docs",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "author": "kunnnn",
+  "engines": {
+    "dsh": ">=0.2.1-rc.5 <0.3.0"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "theme",
+    "appearance",
+    "dot-matrix",
+    "welcome-page"
+  ]
+}