dsh-mobile 0.6.3 → 0.6.4

package/lib/client.js

@@ -2478,19 +2478,396 @@ window.__ModuleLoader__.load({
 		function createFrpAttachTemplate(settings, options = {}) {
 			return createFrpAttachTemplateParts(settings, options).text;
 		}
-		/** Wire bounds mirrored by the Android notification policy. */
-		const TASK_NOTIFY_LIMITS = Object.freeze({
+		//#endregion
+		//#region node_modules/@noble/hashes/esm/utils.js
+		/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+		/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+		function isBytes(a) {
+			return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+		}
+		/** Asserts something is Uint8Array. */
+		function abytes(b, ...lengths) {
+			if (!isBytes(b)) throw new Error("Uint8Array expected");
+			if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+		}
+		/** Asserts a hash instance has not been destroyed / finished */
+		function aexists(instance, checkFinished = true) {
+			if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+			if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+		}
+		/** Asserts output is properly-sized byte array */
+		function aoutput(out, instance) {
+			abytes(out);
+			const min = instance.outputLen;
+			if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+		}
+		/** Zeroize a byte array. Warning: JS provides no guarantees. */
+		function clean(...arrays) {
+			for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+		}
+		/** Create DataView of an array for easy byte-level manipulation. */
+		function createView(arr) {
+			return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+		}
+		/** The rotate right (circular right shift) operation for uint32 */
+		function rotr(word, shift) {
+			return word << 32 - shift | word >>> shift;
+		}
+		const hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+		const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+		/**
+		* Convert byte array to hex string. Uses built-in function, when available.
+		* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+		*/
+		function bytesToHex(bytes) {
+			abytes(bytes);
+			if (hasHexBuiltin) return bytes.toHex();
+			let hex = "";
+			for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+			return hex;
+		}
+		/**
+		* Converts string to bytes using UTF8 encoding.
+		* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+		*/
+		function utf8ToBytes(str) {
+			if (typeof str !== "string") throw new Error("string expected");
+			return new Uint8Array(new TextEncoder().encode(str));
+		}
+		/**
+		* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+		* Warning: when Uint8Array is passed, it would NOT get copied.
+		* Keep in mind for future mutable operations.
+		*/
+		function toBytes(data) {
+			if (typeof data === "string") data = utf8ToBytes(data);
+			abytes(data);
+			return data;
+		}
+		/** For runtime check if class implements interface */
+		var Hash = class {};
+		/** Wraps hash function, creating an interface on top of it */
+		function createHasher(hashCons) {
+			const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+			const tmp = hashCons();
+			hashC.outputLen = tmp.outputLen;
+			hashC.blockLen = tmp.blockLen;
+			hashC.create = () => hashCons();
+			return hashC;
+		}
+		//#endregion
+		//#region node_modules/@noble/hashes/esm/_md.js
+		/**
+		* Internal Merkle-Damgard hash utils.
+		* @module
+		*/
+		/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+		function setBigUint64(view, byteOffset, value, isLE) {
+			if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
+			const _32n = BigInt(32);
+			const _u32_max = BigInt(4294967295);
+			const wh = Number(value >> _32n & _u32_max);
+			const wl = Number(value & _u32_max);
+			const h = isLE ? 4 : 0;
+			const l = isLE ? 0 : 4;
+			view.setUint32(byteOffset + h, wh, isLE);
+			view.setUint32(byteOffset + l, wl, isLE);
+		}
+		/** Choice: a ? b : c */
+		function Chi(a, b, c) {
+			return a & b ^ ~a & c;
+		}
+		/** Majority function, true if any two inputs is true. */
+		function Maj(a, b, c) {
+			return a & b ^ a & c ^ b & c;
+		}
+		/**
+		* Merkle-Damgard hash construction base class.
+		* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+		*/
+		var HashMD = class extends Hash {
+			constructor(blockLen, outputLen, padOffset, isLE) {
+				super();
+				this.finished = false;
+				this.length = 0;
+				this.pos = 0;
+				this.destroyed = false;
+				this.blockLen = blockLen;
+				this.outputLen = outputLen;
+				this.padOffset = padOffset;
+				this.isLE = isLE;
+				this.buffer = new Uint8Array(blockLen);
+				this.view = createView(this.buffer);
+			}
+			update(data) {
+				aexists(this);
+				data = toBytes(data);
+				abytes(data);
+				const { view, buffer, blockLen } = this;
+				const len = data.length;
+				for (let pos = 0; pos < len;) {
+					const take = Math.min(blockLen - this.pos, len - pos);
+					if (take === blockLen) {
+						const dataView = createView(data);
+						for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+						continue;
+					}
+					buffer.set(data.subarray(pos, pos + take), this.pos);
+					this.pos += take;
+					pos += take;
+					if (this.pos === blockLen) {
+						this.process(view, 0);
+						this.pos = 0;
+					}
+				}
+				this.length += data.length;
+				this.roundClean();
+				return this;
+			}
+			digestInto(out) {
+				aexists(this);
+				aoutput(out, this);
+				this.finished = true;
+				const { buffer, view, blockLen, isLE } = this;
+				let { pos } = this;
+				buffer[pos++] = 128;
+				clean(this.buffer.subarray(pos));
+				if (this.padOffset > blockLen - pos) {
+					this.process(view, 0);
+					pos = 0;
+				}
+				for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+				setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+				this.process(view, 0);
+				const oview = createView(out);
+				const len = this.outputLen;
+				if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
+				const outLen = len / 4;
+				const state = this.get();
+				if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+				for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+			}
+			digest() {
+				const { buffer, outputLen } = this;
+				this.digestInto(buffer);
+				const res = buffer.slice(0, outputLen);
+				this.destroy();
+				return res;
+			}
+			_cloneInto(to) {
+				to || (to = new this.constructor());
+				to.set(...this.get());
+				const { blockLen, buffer, length, finished, destroyed, pos } = this;
+				to.destroyed = destroyed;
+				to.finished = finished;
+				to.length = length;
+				to.pos = pos;
+				if (length % blockLen) to.buffer.set(buffer);
+				return to;
+			}
+			clone() {
+				return this._cloneInto();
+			}
+		};
+		/**
+		* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+		* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+		*/
+		/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+		const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+			1779033703,
+			3144134277,
+			1013904242,
+			2773480762,
+			1359893119,
+			2600822924,
+			528734635,
+			1541459225
+		]);
+		//#endregion
+		//#region node_modules/@noble/hashes/esm/sha2.js
+		/**
+		* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+		* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+		* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+		* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+		* @module
+		*/
+		/**
+		* Round constants:
+		* First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+		*/
+		const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+			1116352408,
+			1899447441,
+			3049323471,
+			3921009573,
+			961987163,
+			1508970993,
+			2453635748,
+			2870763221,
+			3624381080,
+			310598401,
+			607225278,
+			1426881987,
+			1925078388,
+			2162078206,
+			2614888103,
+			3248222580,
+			3835390401,
+			4022224774,
+			264347078,
+			604807628,
+			770255983,
+			1249150122,
+			1555081692,
+			1996064986,
+			2554220882,
+			2821834349,
+			2952996808,
+			3210313671,
+			3336571891,
+			3584528711,
+			113926993,
+			338241895,
+			666307205,
+			773529912,
+			1294757372,
+			1396182291,
+			1695183700,
+			1986661051,
+			2177026350,
+			2456956037,
+			2730485921,
+			2820302411,
+			3259730800,
+			3345764771,
+			3516065817,
+			3600352804,
+			4094571909,
+			275423344,
+			430227734,
+			506948616,
+			659060556,
+			883997877,
+			958139571,
+			1322822218,
+			1537002063,
+			1747873779,
+			1955562222,
+			2024104815,
+			2227730452,
+			2361852424,
+			2428436474,
+			2756734187,
+			3204031479,
+			3329325298
+		]);
+		/** Reusable temporary buffer. "W" comes straight from spec. */
+		const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+		var SHA256 = class extends HashMD {
+			constructor(outputLen = 32) {
+				super(64, outputLen, 8, false);
+				this.A = SHA256_IV[0] | 0;
+				this.B = SHA256_IV[1] | 0;
+				this.C = SHA256_IV[2] | 0;
+				this.D = SHA256_IV[3] | 0;
+				this.E = SHA256_IV[4] | 0;
+				this.F = SHA256_IV[5] | 0;
+				this.G = SHA256_IV[6] | 0;
+				this.H = SHA256_IV[7] | 0;
+			}
+			get() {
+				const { A, B, C, D, E, F, G, H } = this;
+				return [
+					A,
+					B,
+					C,
+					D,
+					E,
+					F,
+					G,
+					H
+				];
+			}
+			set(A, B, C, D, E, F, G, H) {
+				this.A = A | 0;
+				this.B = B | 0;
+				this.C = C | 0;
+				this.D = D | 0;
+				this.E = E | 0;
+				this.F = F | 0;
+				this.G = G | 0;
+				this.H = H | 0;
+			}
+			process(view, offset) {
+				for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+				for (let i = 16; i < 64; i++) {
+					const W15 = SHA256_W[i - 15];
+					const W2 = SHA256_W[i - 2];
+					const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+					const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+					SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+				}
+				let { A, B, C, D, E, F, G, H } = this;
+				for (let i = 0; i < 64; i++) {
+					const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+					const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+					const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
+					H = G;
+					G = F;
+					F = E;
+					E = D + T1 | 0;
+					D = C;
+					C = B;
+					B = A;
+					A = T1 + T2 | 0;
+				}
+				A = A + this.A | 0;
+				B = B + this.B | 0;
+				C = C + this.C | 0;
+				D = D + this.D | 0;
+				E = E + this.E | 0;
+				F = F + this.F | 0;
+				G = G + this.G | 0;
+				H = H + this.H | 0;
+				this.set(A, B, C, D, E, F, G, H);
+			}
+			roundClean() {
+				clean(SHA256_W);
+			}
+			destroy() {
+				this.set(0, 0, 0, 0, 0, 0, 0, 0);
+				clean(this.buffer);
+			}
+		};
+		//#endregion
+		//#region node_modules/@noble/hashes/esm/sha256.js
+		/**
+		* SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+		*
+		* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+		* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+		*
+		* Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+		* @module
+		* @deprecated
+		*/
+		/** @deprecated Use import from `noble/hashes/sha2` module */
+		const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+		Object.freeze({
 			title: 80,
 			body: 200,
 			tag: 64
 		});
 		const MAX_SEEN_QUESTION_KEYS = 20;
-		function sanitizeTagFragment(value) {
-			return value.toLowerCase().replaceAll(/[^a-z0-9-]+/gu, "-").replaceAll(/^-+|-+$/gu, "").slice(0, TASK_NOTIFY_LIMITS.tag);
+		/** A bounded native identifier derived from the complete, case-sensitive wire ID. */
+		function notificationIdentity(value) {
+			return bytesToHex(sha256(JSON.stringify(value)).subarray(0, 16));
 		}
 		/** Stable per-turn tag so concurrent sessions keep separate notifications. */
 		function taskCompletionTag(sessionId, turn) {
-			return `dsh-task-done-${sanitizeTagFragment(`${sessionId}-${String(turn)}`) || "task"}`.slice(0, TASK_NOTIFY_LIMITS.tag);
+			return `dsh-task-done-${notificationIdentity(sessionId)}-${String(turn)}`;
 		}
 		/** Decide whether the current snapshot deserves a system notification. */
 		var TaskNotifyTracker = class {
@@ -2581,7 +2958,7 @@ window.__ModuleLoader__.load({
 			}
 			event(kind, sessionLabel, questionKey) {
 				const text = this.format(kind, sessionLabel);
-				const tag = kind === "question" && questionKey !== void 0 ? `dsh-task-question-${sanitizeTagFragment(questionKey) || "pending"}` : "dsh-task-done";
+				const tag = kind === "question" && questionKey !== void 0 ? `dsh-task-question-${notificationIdentity(questionKey)}` : "dsh-task-done";
 				return Object.freeze({
 					kind,
 					title: text.title,
@@ -2666,7 +3043,7 @@ window.__ModuleLoader__.load({
 			if (typeof record.sessionId !== "string" || record.sessionId.trim() === "") return void 0;
 			const turn = typeof record.turn === "number" && Number.isSafeInteger(record.turn) && record.turn >= 0 ? record.turn : 0;
 			return Object.freeze({
-				sessionId: record.sessionId.slice(0, 128),
+				sessionId: record.sessionId,
 				turn
 			});
 		}
@@ -2796,6 +3173,10 @@ window.__ModuleLoader__.load({
 [data-dsh-mobile-composer-controls] button:not(:where(dialog *,[popover] *,[role="dialog"] *,[role="menu"] *,[role="listbox"] *,[data-trigger-menu] *)) { white-space:normal !important; overflow-wrap:anywhere !important; }
 @media (max-width:720px) {
   [data-dsh-mobile-composer-row] button:not([role="switch"]):not(:where(dialog *,[popover] *,[role="dialog"] *,[role="menu"] *,[role="listbox"] *,[data-trigger-menu] *)) { min-width:44px !important; min-height:44px !important; touch-action:manipulation; }
+  /* Public slot icon wrappers must reserve the same space as their enlarged
+     child targets. Keep wrapper and tooltip ownership intact; pure switches,
+     dialogs and wrappers without direct non-switch buttons are not selected. */
+  :is([data-dsh-mobile-composer-tools],[data-dsh-mobile-composer-controls]) > :is([data-slot="conversation.input.left"],[data-slot="conversation.input.right"]) > :where(span,div):not(:where(dialog,[popover],[role="dialog"],[role="menu"],[role="listbox"],[data-trigger-menu])):has(> button:not([role="switch"])) { min-width:44px !important; min-height:44px !important; flex-shrink:0 !important; }
   [data-dsh-mobile-composer-trailing] > button[class*="_primary"] { min-width:44px !important; flex-shrink:0 !important; }
   [data-dsh-mobile-composer-row] { display:flex !important; flex-wrap:wrap !important; align-items:center !important; gap:4px 8px !important; min-width:0 !important; max-width:100% !important; }
   [data-dsh-mobile-composer-tools]:not([hidden]) { display:flex !important; flex:0 1 auto !important; flex-wrap:wrap !important; width:auto !important; min-width:0 !important; max-width:100% !important; gap:6px !important; }
@@ -10136,6 +10517,7 @@ window.__ModuleLoader__.load({
 			const activations = new PerIdActivationLifecycle();
 			const styleNodes = /* @__PURE__ */ new Map();
 			const styleEtags = /* @__PURE__ */ new Map();
+			const scriptEtags = /* @__PURE__ */ new Map();
 			const scriptDigests = /* @__PURE__ */ new Map();
 			const activeHostGenerations = /* @__PURE__ */ new Map();
 			const activationKeys = /* @__PURE__ */ new Map();
@@ -10516,6 +10898,7 @@ window.__ModuleLoader__.load({
 				styleNodes.get(id)?.remove();
 				styleNodes.delete(id);
 				styleEtags.delete(id);
+				scriptEtags.delete(id);
 				scriptDigests.delete(id);
 				activeHostGenerations.delete(id);
 				activationKeys.delete(id);
@@ -10524,6 +10907,7 @@ window.__ModuleLoader__.load({
 			const managedManifestIdSources = () => [
 				styleNodes.keys(),
 				styleEtags.keys(),
+				scriptEtags.keys(),
 				scriptDigests.keys(),
 				managedDefinitionIds
 			];
@@ -10617,12 +11001,13 @@ window.__ModuleLoader__.load({
 								commitStyle(entry.id, styleChange, pendingCss, pendingStyleEtag);
 								activations.remove(entry.id);
 								activeHostGenerations.delete(entry.id);
+								scriptEtags.delete(entry.id);
 								scriptDigests.delete(entry.id);
 								if (managedDefinitionIds.delete(entry.id)) definitions.delete(entry.id);
 							} else {
 								const scriptHeaders = {};
-								const storedDigest = scriptDigests.get(entry.id);
-								if (storedDigest !== void 0) scriptHeaders["if-none-match"] = storedDigest;
+								const storedEtag = scriptEtags.get(entry.id);
+								if (storedEtag !== void 0) scriptHeaders["if-none-match"] = storedEtag;
 								const scriptResponse = await fetch(scriptUrl, {
 									credentials: "same-origin",
 									cache: "no-store",
@@ -10630,8 +11015,10 @@ window.__ModuleLoader__.load({
 									signal
 								});
 								let nextDigest;
+								let nextEtag;
 								if (scriptResponse.status !== 304) {
 									if (!scriptResponse.ok) throw new Error("mobile extension script failed to load");
+									nextEtag = scriptResponse.headers.get("etag") ?? void 0;
 									const source = await scriptResponse.text();
 									if (refreshAborted(signal)) return false;
 									const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(source));
@@ -10673,6 +11060,10 @@ window.__ModuleLoader__.load({
 								}
 								managedDefinitionIds.add(entry.id);
 								if (nextDigest !== void 0) scriptDigests.set(entry.id, nextDigest);
+								if (scriptResponse.status !== 304) {
+									if (nextEtag === void 0 || nextEtag === "") scriptEtags.delete(entry.id);
+									else scriptEtags.set(entry.id, nextEtag);
+								}
 							}
 						} catch {
 							if (evaluatedDefinition) {