mslxdff 0.1.97 → 0.1.98

package/src/providers/deepseek/chat.js

@@ -0,0 +1,220 @@
+// DeepSeek completion 编排：token→session→pow→completion→(流|聚合)→delete
+// 超限分流：expert > 阈值 → 分块喂养 session（对齐 NIyueeE/ds-free-api 方案 B）；其余超限人话报错
+// 风控语义参考 TQZHR/deepseek2api classifyProtocolResponse（MIT）
+import { androidHeaders, solveChallenge, netRetry, DEEPSEEK_DEFAULT_BASE, DEEPSEEK_API_PREFIX } from "./pow.js";
+import { COOLDOWN_PRESETS } from "./auth.js";
+import { buildPrompt, mapModelToFlags, createDeepseekSseParser, buildUpstreamBody, promptThresholdFor, splitPromptChunks } from "./bridge.js";
+import { createChatSession, deleteChatSession, feedChunkToSession } from "./session.js";
+import { dsDebug, dsDump, dsError } from "./debug.js";
+
+const CAPTCHA_PATTERN = /captcha|shumei|数美|验证码|风控|verification/i;
+// user is muted：账号被禁言/风控（上游对 completion 直接拒），切账号冷却，禁言期间不再打上游
+const MUTED_PATTERN = /user is muted|account is muted|\bmuted\b|禁言/i;
+// 「消息发送过于频繁」= 禁言前兆（TQZHR/deepseek2api 同款识别），命中即冷却换号，避免小病拖成禁言
+const FREQUENCY_PATTERN = /消息发送过于频繁[\s，,、:：]*请稍后重试/;
+
+function classifyProtocolFailure(text, status) {
+  const t = String(text || "");
+  if (FREQUENCY_PATTERN.test(t)) {
+    return upstreamError("DeepSeek 上游提示「消息发送过于频繁」：该账号触发频率风控（禁言前兆），已自动冷却并切换账号", { status, rotateAuth: true, cooldownMs: COOLDOWN_PRESETS.frequency });
+  }
+  if (MUTED_PATTERN.test(t)) {
+    return upstreamError("DeepSeek 账号被禁言/风控（user is muted）：已自动冷却该账号，请等待解除或 -provider deepseek login 追加账号", { status, rotateAuth: true, cooldownMs: COOLDOWN_PRESETS.muted });
+  }
+  return null;
+}
+
+function fmt(n) { return Number(n).toLocaleString("en-US"); }
+
+function upstreamError(message, { status, rotateAuth, cooldownMs } = {}) {
+  const err = new Error(message);
+  err.status = status;
+  if (rotateAuth) err._rotateAuth = true;
+  if (cooldownMs) err._cooldownMs = cooldownMs;
+  return err;
+}
+
+function classifyFailure(status, bodyText) {
+  const text = String(bodyText || "");
+  const muted = classifyProtocolFailure(text, status);
+  if (muted) return muted;
+  if (CAPTCHA_PATTERN.test(text)) {
+    return upstreamError("DeepSeek 触发上游风控/验证码，请稍后再试或换账号（-provider deepseek login 追加）", { status, rotateAuth: true });
+  }
+  if (status === 401 || status === 403) {
+    return upstreamError(`DeepSeek 凭据被拒 (http ${status})，自动切换下一个账号或重新 login`, { status, rotateAuth: true });
+  }
+  if (status === 429) {
+    return upstreamError("DeepSeek 请求过于频繁 (429)，账号已冷却，稍后再试", { status, rotateAuth: true });
+  }
+  return upstreamError(`DeepSeek completion 失败 (http ${status}): ${text.slice(0, 300)}`, { status });
+}
+
+async function readBodyText(res) {
+  try { return await res.text(); } catch { return ""; }
+}
+
+// 公共 completion 请求：netRetry + 非 SSE 检查 + INVALID_POW 一次重试（重解 challenge）
+async function fetchCompletionWithPow({ token, base, body, pow, fetchImpl, dispatcher, connectTimeoutMs }) {
+  const url = `${base}${DEEPSEEK_API_PREFIX}/chat/completion`;
+  for (let powAttempt = 0; ; powAttempt++) {
+    let res;
+    try {
+      res = await netRetry(() => fetchImpl(url, {
+        method: "POST",
+        headers: androidHeaders(token, { "x-ds-pow-response": pow.header }),
+        body: JSON.stringify(body),
+        ...(dispatcher ? { dispatcher } : {}),
+      }), { attempts: 2, delayMs: 400 });
+    } catch (err) {
+      dsError("completion", err);
+      throw upstreamError(`DeepSeek completion 网络失败: ${String(err?.message || err)}`, { rotateAuth: false });
+    }
+    dsDebug("completion", { event: "response", status: res.status, contentType: res.headers.get("content-type"), powAttempt, promptLen: body.prompt.length });
+
+    if (res.ok) {
+      const contentType = res.headers.get("content-type") || "";
+      if (!contentType.includes("text/event-stream")) {
+        const text = await readBodyText(res);
+        const muted = classifyProtocolFailure(text, res.status);
+        if (muted) { dsDump("completion", "muted", text, 400); throw muted; }
+        let payload = null;
+        try { payload = JSON.parse(text); } catch {}
+        const bizMsg = payload?.data?.biz_msg || payload?.msg || text.slice(0, 200);
+        dsDump("completion", "non-sse body", text, 1200);
+        throw upstreamError(`DeepSeek completion 返回非 SSE: ${bizMsg}`, { status: res.status });
+      }
+      return res;
+    }
+
+    const text = await readBodyText(res);
+    dsDump("completion", `error body http=${res.status}`, text, 1200);
+    if (/INVALID_POW_RESPONSE/i.test(text) && powAttempt < 1) {
+      const retryPow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
+      pow.header = retryPow.header;
+      continue;
+    }
+    throw classifyFailure(res.status, text);
+  }
+}
+
+// 单发路径（不超阈值）
+async function runOnce({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs }) {
+  const base = String(baseUrl || DEEPSEEK_DEFAULT_BASE).replace(/\/+$/, "");
+  const sessionId = await createChatSession({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
+  const pow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
+  const completionBody = buildUpstreamBody({ sessionId, prompt, thinking: flags.thinking, search: flags.search, expert: flags.expert });
+  dsDebug("completion", { event: "request", sessionId, thinking: flags.thinking, search: flags.search, expert: flags.expert, promptLen: prompt.length, promptHead: prompt.slice(0, 120), body: JSON.stringify(completionBody) });
+  const res = await fetchCompletionWithPow({ token, base, body: completionBody, pow, fetchImpl, dispatcher, connectTimeoutMs });
+  return { kind: isStream ? "stream" : "aggregate", res, sessionId, token };
+}
+
+// 分块喂养路径（expert 超阈值）：共享 session，非末块只喂历史（ready→stop_stream→drain），末块正常生成
+async function runChunked({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs, threshold }) {
+  const base = String(baseUrl || DEEPSEEK_DEFAULT_BASE).replace(/\/+$/, "");
+  const chunks = splitPromptChunks(prompt, threshold);
+  const sessionId = await createChatSession({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
+  dsDebug("chunked", { event: "start", sessionId, totalChunks: chunks.length, promptLen: prompt.length, threshold });
+  let parentId = null;
+  try {
+    for (const chunk of chunks.slice(0, -1)) {
+      const pow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
+      const feedBody = buildUpstreamBody({ sessionId, prompt: chunk, thinking: false, search: false, expert: flags.expert, parentMessageId: parentId });
+      dsDebug("chunked", { event: "feed", chunkLen: chunk.length, parentMessageId: parentId });
+      const res = await fetchCompletionWithPow({ token, base, body: feedBody, pow, fetchImpl, dispatcher, connectTimeoutMs });
+      parentId = await feedChunkToSession({ res, token, sessionId, fetchImpl, dispatcher, baseUrl, connectTimeoutMs });
+      dsDebug("chunked", { event: "fed", parentMessageId: parentId });
+    }
+    const lastChunk = chunks[chunks.length - 1];
+    const pow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
+    const body = buildUpstreamBody({ sessionId, prompt: lastChunk, thinking: flags.thinking, search: flags.search, expert: flags.expert, parentMessageId: parentId });
+    dsDebug("chunked", { event: "final", chunkLen: lastChunk.length, parentMessageId: parentId, thinking: flags.thinking, search: flags.search });
+    const res = await fetchCompletionWithPow({ token, base, body, pow, fetchImpl, dispatcher, connectTimeoutMs });
+    return { kind: isStream ? "stream" : "aggregate", res, sessionId, token };
+  } catch (err) {
+    dsError("chunked", err);
+    await deleteChatSession({ token, sessionId, fetchImpl, dispatcher, baseUrl });
+    throw err;
+  }
+}
+
+export function aggregateFromText(sseText, model, { thinking = false } = {}) {
+  const parse = createDeepseekSseParser({ startKind: thinking ? "reasoning" : "content" });
+  let content = "";
+  let reasoning = "";
+  let finish = "stop";
+  for (const ev of parse(String(sseText ?? ""))) {
+    // 上游拒绝（hint error）：人话抛出，绝不返回空 200；频率风控/禁言命中时冷却换号
+    if (ev.error) {
+      const rotate = FREQUENCY_PATTERN.test(String(ev.error)) || MUTED_PATTERN.test(String(ev.error));
+      throw upstreamError(`DeepSeek 上游拒绝: ${ev.error}${ev.finishReason ? ` (${ev.finishReason})` : ""}`, { status: 502, rotateAuth: rotate });
+    }
+    if (ev.content) content += ev.content;
+    if (ev.reasoning) reasoning += ev.reasoning;
+    if (ev.finish) finish = ev.finish;
+  }
+  const message = { role: "assistant", content };
+  if (reasoning) message.reasoning_content = reasoning;
+  return {
+    id: `chatcmpl-deepseek-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{ index: 0, message, finish_reason: finish }],
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+}
+
+export async function runDeepseekChat({ body, authPool, fetchImpl, dispatcher, baseUrl, connectTimeoutMs = 30_000, maxAuthRetries } = {}) {
+  const model = body?.model || "deepseek/chat";
+  const rawId = String(model).includes("/") ? String(model).split("/").pop() : String(model);
+  const flags = mapModelToFlags(rawId);
+  const prompt = buildPrompt(body?.messages || []);
+  const isStream = body?.stream === true;
+  const threshold = promptThresholdFor(flags);
+
+  // 超限分流（ds-free-api 实测标定：default/vision 2,621,440 / expert 163,840，阈值取 75%）
+  if (prompt.length > threshold) {
+    if (!flags.expert) {
+      throw upstreamError(`DeepSeek ${model} 输入超长：${fmt(prompt.length)} 字符，超过 ${fmt(threshold)} 上限（网页通道 default 模型上限 2,621,440 字符）。请压缩对话历史（opencode /compact）或改用 deepseek-*-expert-free（自动分块）`, { status: 413 });
+    }
+    dsDebug("oversize", { event: "chunked-mode", model, promptLen: prompt.length, threshold });
+  }
+
+  const maxAttempts = maxAuthRetries ?? Math.max(1, authPool.size);
+  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+    const token = authPool.requireToken();
+    try {
+      const out = prompt.length > threshold
+        ? await runChunked({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs, threshold })
+        : await runOnce({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs });
+      if (out.kind === "stream") {
+        return {
+          kind: "stream",
+          res: out.res,
+          token,
+          cleanup: () => deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl }),
+        };
+      }
+      const sseText = await readBodyText(out.res);
+      let data;
+      try {
+        data = aggregateFromText(sseText, model, { thinking: flags.thinking });
+      } catch (err) {
+        await deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl });
+        throw err;
+      }
+      dsDump("aggregate", `sseText model=${model}`, sseText, 4000);
+      if (!data.choices[0].message.content && !data.choices[0].message.reasoning_content) {
+        dsDump("aggregate", "EMPTY aggregate content! full sseText", sseText, 8000);
+      }
+      await deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl });
+      return { kind: "json", data };
+    } catch (err) {
+      dsError(`chat attempt=${attempt}`, err);
+      if (err?._rotateAuth) authPool.onError(token, { cooldownMs: err._cooldownMs });
+      if (!err?._rotateAuth || attempt >= maxAttempts - 1) throw err;
+    }
+  }
+  throw upstreamError("DeepSeek: 所有账号均不可用", {});
+}

package/src/providers/deepseek/debug.js

@@ -0,0 +1,44 @@
+// DeepSeek 排障日志：落 ~/.config/mslxdff/deepseek-debug.log（5MB 轮转），定位空流/风控/协议异常
+// 解决后统一摘除调用点（用户授权全量日志）
+import { appendFileSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const DEBUG_FILE = process.env.MSLXDFF_DEEPSEEK_DEBUG_FILE
+  || join(homedir(), ".config", "mslxdff", "deepseek-debug.log");
+const MAX_BYTES = 5 * 1024 * 1024;
+
+function rotateIfNeeded() {
+  try {
+    if (statSync(DEBUG_FILE).size > MAX_BYTES) unlinkSync(DEBUG_FILE);
+  } catch {}
+}
+
+function write(line) {
+  try {
+    rotateIfNeeded();
+    appendFileSync(DEBUG_FILE, line + "\n");
+  } catch {}
+}
+
+function ts() {
+  return new Date().toISOString().slice(11, 23);
+}
+
+// 结构化一行：dsDebug("completion", { model, status, ... })
+export function dsDebug(scope, fields = {}) {
+  const pairs = Object.entries(fields).map(([k, v]) => `${k}=${typeof v === "string" ? JSON.stringify(v) : String(v)}`);
+  write(`[${ts()}] [${scope}] ${pairs.join(" ")}`);
+}
+
+// 原始文本截断记录（SSE chunk / 聚合全文）
+export function dsDump(scope, label, text, limit = 2000) {
+  const s = String(text ?? "");
+  write(`[${ts()}] [${scope}] ${label} (${s.length}B) >>> ${s.slice(0, limit).replace(/\n/g, "\\n")}<<<`);
+}
+
+export function dsError(scope, err) {
+  write(`[${ts()}] [${scope}] ERROR ${String(err?.stack || err?.message || err).slice(0, 800)}`);
+}
+
+export { DEBUG_FILE };

package/src/providers/deepseek/hash-reference.js

@@ -0,0 +1,117 @@
+// 可读 FIPS 202 参考实现（BigInt）：24 轮 = 标准 SHA3-256，仅测试对拍用。
+// 源自 diegosouzapw/OmniRoute（MIT）clean-room NIST FIPS 202 port。
+// 运行时求解用 hash.js 的 Uint32 优化版（keccakP1600Uint32）。
+
+const LANE_MASK = (1n << 64n) - 1n;
+const SHA3_256_RATE_BYTES = 136;
+const SHA3_DOMAIN_SUFFIX = 0x06;
+const SHA3_256_OUTPUT_BYTES = 32;
+
+const ROTATION_OFFSETS = [
+  0, 1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14,
+];
+
+const ROUND_CONSTANTS = [
+  0x0000000000000001n,
+  0x0000000000008082n,
+  0x800000000000808an,
+  0x8000000080008000n,
+  0x000000000000808bn,
+  0x0000000080000001n,
+  0x8000000080008081n,
+  0x8000000000008009n,
+  0x000000000000008an,
+  0x0000000000000088n,
+  0x0000000080008009n,
+  0x000000008000000an,
+  0x000000008000808bn,
+  0x800000000000008bn,
+  0x8000000000008089n,
+  0x8000000000008003n,
+  0x8000000000008002n,
+  0x8000000000000080n,
+  0x000000000000800an,
+  0x800000008000000an,
+  0x8000000080008081n,
+  0x8000000000008080n,
+  0x0000000080000001n,
+  0x8000000080008008n,
+];
+
+function rotateLeft64(value, amount) {
+  if (amount === 0) return value;
+  const shift = BigInt(amount);
+  return ((value << shift) | (value >> (64n - shift))) & LANE_MASK;
+}
+
+function keccakP1600Reference(state, roundCount) {
+  const columnParity = new Array(5).fill(0n);
+  const thetaMix = new Array(5).fill(0n);
+  const rhoPiState = new Array(25).fill(0n);
+  const firstRound = ROUND_CONSTANTS.length - roundCount;
+
+  for (let round = firstRound; round < ROUND_CONSTANTS.length; round++) {
+    for (let x = 0; x < 5; x++) {
+      columnParity[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
+    }
+    for (let x = 0; x < 5; x++) {
+      thetaMix[x] = columnParity[(x + 4) % 5] ^ rotateLeft64(columnParity[(x + 1) % 5], 1);
+    }
+    for (let y = 0; y < 5; y++) {
+      for (let x = 0; x < 5; x++) state[x + 5 * y] ^= thetaMix[x];
+    }
+    for (let y = 0; y < 5; y++) {
+      for (let x = 0; x < 5; x++) {
+        const destinationX = y;
+        const destinationY = (2 * x + 3 * y) % 5;
+        const lane = x + 5 * y;
+        rhoPiState[destinationX + 5 * destinationY] = rotateLeft64(state[lane], ROTATION_OFFSETS[lane]);
+      }
+    }
+    for (let y = 0; y < 5; y++) {
+      const row = 5 * y;
+      for (let x = 0; x < 5; x++) {
+        state[x + row] = rhoPiState[x + row] ^ (~rhoPiState[((x + 1) % 5) + row] & LANE_MASK & rhoPiState[((x + 2) % 5) + row]);
+      }
+    }
+    state[0] ^= ROUND_CONSTANTS[round];
+  }
+}
+
+function absorbReferenceBlock(state, block, roundCount) {
+  for (let index = 0; index < SHA3_256_RATE_BYTES; index++) {
+    const lane = Math.floor(index / 8);
+    const shift = BigInt((index % 8) * 8);
+    state[lane] ^= BigInt(block[index]) << shift;
+  }
+  keccakP1600Reference(state, roundCount);
+}
+
+function sha3_256ReferenceWithRoundCount(input, roundCount) {
+  const bytes = new TextEncoder().encode(input);
+  const state = new Array(25).fill(0n);
+  let offset = 0;
+
+  while (offset + SHA3_256_RATE_BYTES <= bytes.length) {
+    absorbReferenceBlock(state, bytes.subarray(offset, offset + SHA3_256_RATE_BYTES), roundCount);
+    offset += SHA3_256_RATE_BYTES;
+  }
+
+  const finalBlock = new Uint8Array(SHA3_256_RATE_BYTES);
+  finalBlock.set(bytes.subarray(offset));
+  finalBlock[bytes.length - offset] ^= SHA3_DOMAIN_SUFFIX;
+  finalBlock[SHA3_256_RATE_BYTES - 1] ^= 0x80;
+  absorbReferenceBlock(state, finalBlock, roundCount);
+
+  const output = new Uint8Array(SHA3_256_OUTPUT_BYTES);
+  for (let index = 0; index < output.length; index++) {
+    const lane = Math.floor(index / 8);
+    const shift = BigInt((index % 8) * 8);
+    output[index] = Number((state[lane] >> shift) & 0xffn);
+  }
+  return Array.from(output, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export function sha3_256Fips202Reference(input) {
+  return sha3_256ReferenceWithRoundCount(input, 24);
+}

package/src/providers/deepseek/hash.js

@@ -0,0 +1,245 @@
+// DeepSeekHashV1 + KECCAK-p[1600] sponge primitives (Uint32 optimized).
+// Clean-room port of diegosouzapw/OmniRoute (MIT) open-sse/lib/deepseek-pow-hash.js,
+// itself derived from NIST FIPS 202: DeepSeekHashV1 is SHA3-256 with the final
+// Keccak round dropped (KECCAK-p[1600, 23]), verified by differential testing
+// against the official sha3_wasm_bg.wasm black box.
+// 可读 BigInt 参考实现拆在 hash-reference.js（仅测试对拍用）。
+
+const LANE_MASK = (1n << 64n) - 1n;
+const SHA3_256_RATE_BYTES = 136;
+const SHA3_DOMAIN_SUFFIX = 0x06;
+const SHA3_256_OUTPUT_BYTES = 32;
+
+const ROTATION_OFFSETS = [
+  0, 1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14,
+];
+
+const ROUND_CONSTANTS = [
+  0x0000000000000001n,
+  0x0000000000008082n,
+  0x800000000000808an,
+  0x8000000080008000n,
+  0x000000000000808bn,
+  0x0000000080000001n,
+  0x8000000080008081n,
+  0x8000000000008009n,
+  0x000000000000008an,
+  0x0000000000000088n,
+  0x0000000080008009n,
+  0x000000008000000an,
+  0x000000008000808bn,
+  0x800000000000008bn,
+  0x8000000000008089n,
+  0x8000000000008003n,
+  0x8000000000008002n,
+  0x8000000000000080n,
+  0x000000000000800an,
+  0x800000008000000an,
+  0x8000000080008081n,
+  0x8000000000008080n,
+  0x0000000080000001n,
+  0x8000000080008008n,
+];
+
+export { sha3_256Fips202Reference } from "./hash-reference.js";
+
+const DEEPSEEK_HASH_ROUNDS = 23;
+const DIGEST_HEX_PATTERN = /^[a-f0-9]{64}$/i;
+const ROUND_CONSTANTS_LOW = Uint32Array.from(ROUND_CONSTANTS, (value) => Number(value & 0xffffffffn));
+const ROUND_CONSTANTS_HIGH = Uint32Array.from(ROUND_CONSTANTS, (value) => Number((value >> 32n) & 0xffffffffn));
+const RHO_PI_DESTINATION_WORDS = Uint8Array.from({ length: 25 }, (_, lane) => {
+  const x = lane % 5;
+  const y = Math.floor(lane / 5);
+  return 2 * (y + 5 * ((2 * x + 3 * y) % 5));
+});
+const CHI_NEXT_WORDS = Uint8Array.from({ length: 25 }, (_, lane) => {
+  const x = lane % 5;
+  const row = lane - x;
+  return 2 * (row + ((x + 1) % 5));
+});
+const CHI_NEXT_NEXT_WORDS = Uint8Array.from({ length: 25 }, (_, lane) => {
+  const x = lane % 5;
+  const row = lane - x;
+  return 2 * (row + ((x + 2) % 5));
+});
+const HEX_DIGITS = "0123456789abcdef";
+
+export const MAX_POW_DIFFICULTY = 250_000;
+
+function keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, roundCount) {
+  const firstRound = ROUND_CONSTANTS.length - roundCount;
+
+  for (let round = firstRound; round < ROUND_CONSTANTS.length; round++) {
+    for (let x = 0; x < 5; x++) {
+      const word = 2 * x;
+      columnParity[word] = state[word] ^ state[word + 10] ^ state[word + 20] ^ state[word + 30] ^ state[word + 40];
+      columnParity[word + 1] = state[word + 1] ^ state[word + 11] ^ state[word + 21] ^ state[word + 31] ^ state[word + 41];
+    }
+
+    for (let x = 0; x < 5; x++) {
+      const previous = 2 * ((x + 4) % 5);
+      const next = 2 * ((x + 1) % 5);
+      const rotatedLow = (columnParity[next] << 1) | (columnParity[next + 1] >>> 31);
+      const rotatedHigh = (columnParity[next + 1] << 1) | (columnParity[next] >>> 31);
+      thetaMix[2 * x] = columnParity[previous] ^ rotatedLow;
+      thetaMix[2 * x + 1] = columnParity[previous + 1] ^ rotatedHigh;
+    }
+
+    for (let x = 0; x < 5; x++) {
+      const word = 2 * x;
+      const low = thetaMix[word];
+      const high = thetaMix[word + 1];
+      state[word] ^= low;
+      state[word + 1] ^= high;
+      state[word + 10] ^= low;
+      state[word + 11] ^= high;
+      state[word + 20] ^= low;
+      state[word + 21] ^= high;
+      state[word + 30] ^= low;
+      state[word + 31] ^= high;
+      state[word + 40] ^= low;
+      state[word + 41] ^= high;
+    }
+
+    rhoPiState[0] = state[0];
+    rhoPiState[1] = state[1];
+    for (let lane = 1; lane < 25; lane++) {
+      const source = 2 * lane;
+      const destination = RHO_PI_DESTINATION_WORDS[lane];
+      const amount = ROTATION_OFFSETS[lane];
+      const low = state[source];
+      const high = state[source + 1];
+
+      if (amount < 32) {
+        rhoPiState[destination] = (low << amount) | (high >>> (32 - amount));
+        rhoPiState[destination + 1] = (high << amount) | (low >>> (32 - amount));
+      } else {
+        const reduced = amount - 32;
+        rhoPiState[destination] = (high << reduced) | (low >>> (32 - reduced));
+        rhoPiState[destination + 1] = (low << reduced) | (high >>> (32 - reduced));
+      }
+    }
+
+    for (let lane = 0; lane < 25; lane++) {
+      const word = 2 * lane;
+      const nextWord = CHI_NEXT_WORDS[lane];
+      const nextNextWord = CHI_NEXT_NEXT_WORDS[lane];
+      state[word] = rhoPiState[word] ^ (~rhoPiState[nextWord] & rhoPiState[nextNextWord]);
+      state[word + 1] = rhoPiState[word + 1] ^ (~rhoPiState[nextWord + 1] & rhoPiState[nextNextWord + 1]);
+    }
+
+    state[0] ^= ROUND_CONSTANTS_LOW[round];
+    state[1] ^= ROUND_CONSTANTS_HIGH[round];
+  }
+}
+
+function absorbFullUint32Block(state, bytes, offset, rhoPiState, columnParity, thetaMix, roundCount) {
+  for (let index = 0; index < SHA3_256_RATE_BYTES; index++) {
+    const word = index >>> 2;
+    state[word] ^= bytes[offset + index] << ((index & 3) * 8);
+  }
+  keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, roundCount);
+}
+
+function digestStateToHex(state) {
+  let digest = "";
+  for (let index = 0; index < SHA3_256_OUTPUT_BYTES; index++) {
+    const byte = (state[index >>> 2] >>> ((index & 3) * 8)) & 0xff;
+    digest += HEX_DIGITS[byte >>> 4] + HEX_DIGITS[byte & 0x0f];
+  }
+  return digest;
+}
+
+function sha3_256Uint32WithRoundCount(input, roundCount) {
+  const bytes = new TextEncoder().encode(input);
+  const state = new Uint32Array(50);
+  const rhoPiState = new Uint32Array(50);
+  const columnParity = new Uint32Array(10);
+  const thetaMix = new Uint32Array(10);
+  let offset = 0;
+
+  while (offset + SHA3_256_RATE_BYTES <= bytes.length) {
+    absorbFullUint32Block(state, bytes, offset, rhoPiState, columnParity, thetaMix, roundCount);
+    offset += SHA3_256_RATE_BYTES;
+  }
+
+  const remaining = bytes.length - offset;
+  for (let index = 0; index < remaining; index++) {
+    state[index >>> 2] ^= bytes[offset + index] << ((index & 3) * 8);
+  }
+  state[remaining >>> 2] ^= SHA3_DOMAIN_SUFFIX << ((remaining & 3) * 8);
+  state[(SHA3_256_RATE_BYTES - 1) >>> 2] ^= 0x80 << 24;
+  keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, roundCount);
+  return digestStateToHex(state);
+}
+
+export function deepSeekHashV1(input) {
+  return sha3_256Uint32WithRoundCount(input, DEEPSEEK_HASH_ROUNDS);
+}
+
+function parseDigestWords(digestHex) {
+  const words = new Uint32Array(SHA3_256_OUTPUT_BYTES / 4);
+  for (let index = 0; index < SHA3_256_OUTPUT_BYTES; index++) {
+    const byte = Number.parseInt(digestHex.slice(index * 2, index * 2 + 2), 16);
+    words[index >>> 2] |= byte << ((index & 3) * 8);
+  }
+  return words;
+}
+
+export function findPowNonce(prefix, challenge, difficulty) {
+  if (typeof prefix !== "string") throw new TypeError("DeepSeek PoW prefix must be a string");
+  if (!DIGEST_HEX_PATTERN.test(challenge)) {
+    throw new TypeError("DeepSeek PoW challenge must be a 64-character hex digest");
+  }
+  if (!Number.isSafeInteger(difficulty) || difficulty < 1 || difficulty > MAX_POW_DIFFICULTY) {
+    throw new RangeError(`DeepSeek PoW difficulty must be an integer from 1 to ${MAX_POW_DIFFICULTY}`);
+  }
+
+  const prefixBytes = new TextEncoder().encode(prefix);
+  const baseState = new Uint32Array(50);
+  const rhoPiState = new Uint32Array(50);
+  const columnParity = new Uint32Array(10);
+  const thetaMix = new Uint32Array(10);
+  let prefixOffset = 0;
+
+  while (prefixOffset + SHA3_256_RATE_BYTES <= prefixBytes.length) {
+    absorbFullUint32Block(baseState, prefixBytes, prefixOffset, rhoPiState, columnParity, thetaMix, DEEPSEEK_HASH_ROUNDS);
+    prefixOffset += SHA3_256_RATE_BYTES;
+  }
+
+  const tailLength = prefixBytes.length - prefixOffset;
+  const tailWords = new Uint32Array(Math.ceil(tailLength / 4));
+  for (let index = 0; index < tailLength; index++) {
+    tailWords[index >>> 2] ^= prefixBytes[prefixOffset + index] << ((index & 3) * 8);
+  }
+
+  const targetWords = parseDigestWords(challenge.toLowerCase());
+  const state = new Uint32Array(50);
+
+  nonceLoop: for (let nonce = 0; nonce < difficulty; nonce++) {
+    state.set(baseState);
+    for (let word = 0; word < tailWords.length; word++) state[word] ^= tailWords[word];
+
+    let position = tailLength;
+    const nonceText = String(nonce);
+    for (let index = 0; index < nonceText.length; index++) {
+      state[position >>> 2] ^= nonceText.charCodeAt(index) << ((position & 3) * 8);
+      position += 1;
+      if (position === SHA3_256_RATE_BYTES) {
+        keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, DEEPSEEK_HASH_ROUNDS);
+        position = 0;
+      }
+    }
+
+    state[position >>> 2] ^= SHA3_DOMAIN_SUFFIX << ((position & 3) * 8);
+    state[(SHA3_256_RATE_BYTES - 1) >>> 2] ^= 0x80 << 24;
+    keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, DEEPSEEK_HASH_ROUNDS);
+
+    for (let word = 0; word < targetWords.length; word++) {
+      if (state[word] !== targetWords[word]) continue nonceLoop;
+    }
+    return nonce;
+  }
+
+  return -1;
+}