dsh-blackjack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuchen Lin
+
+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

@@ -0,0 +1,189 @@
+# dsh-blackjack 插件
+
+> ⚠️ **社区第三方项目声明**
+>
+> 本插件由个人开发者发布与维护，**与任何模型厂商均无关联**：不是任何厂商的官方
+> 项目、不代表其立场、未获其背书或授权，也不使用其名称与标识作为本项目的品牌
+> 元素。包名与命令中的 `dsh-` / `bj-` 前缀仅遵循社区插件的命名惯例，用于标识
+> 本插件的兼容目标与命名空间，不代表 dsh 官方发布或认可。
+
+安装进你自己的 dsh 后，在对话里直接打开一张 21 点牌桌：赢牌拿游戏币 **CHIP**，CHIP 可以单向兑换为「已兑换额度」，这份额
+度只能在本插件的续命路由里消费——**当且仅当你自己配置的模型额度耗尽时**，插件
+才会用这份额度接住那一次失败的请求，让你不用中断手上的任务去充值或等待。
+
+参与**永远免费**：每天有固定的免费手数，玩输了不扣任何东西，也不影响你自己的
+密钥或余额。全部规则细节见下方「参与规则」。
+
+---
+
+## 这是什么、怎么玩
+
+牌桌由一个牌局服务端（`packages/server`，由运营者自托管）维持权威状态，插件只
+是它的客户端：
+
+- **文字命令**：`/blackjack` 系列命令零成本——它们全部走 dsh 的命令层而不是发
+  一条模型消息，所以打牌本身不消耗你的任何 token 额度。
+- **图形牌桌**（可选）：如果你的 dsh profile 带了 Web GUI（例如
+  `@deepseek-ai/dsh-web-app`），对话流里会出现一张可点击的牌桌卡片，动作按钮
+  与文字命令等价，只是换了个界面。没有 Web GUI 的纯终端 profile 里，文字命令
+  照常可用，插件不会因为缺一个可选服务而报错。
+
+一局牌：`/blackjack deal` 开局（默认用当天的免费手，也可以 `deal <注额>` 用余
+额加注）→ 按提示用 `bj-hit` / `bj-stand` 等动作命令打完 → 结算，赢家拿 CHIP。
+
+### 命令表
+
+| 命令 | 作用 |
+|---|---|
+| `/blackjack` | 查看当前状态：有牌局在打就显示牌局，没有就显示余额/免费手/兑换门槛 |
+| `/blackjack agree` | 首次使用必须先执行：阅读须知并同意后才能上桌 |
+| `/blackjack deal [注额]` | 开一局新牌。不带参数用当天的免费手；带一个正整数注额则从余额里加注 |
+| `/blackjack exchange [数量]` | 把达标余额兑换为可消费额度。**首次**（还没绑过 GitHub）会给出一个配对链接，需要去浏览器完成绑定；**绑定之后**带上数量就在命令里直接兑换，不再需要浏览器 |
+| `/blackjack reset confirm` | 清除**本机保存**的牌桌凭证（服务端记录不受影响，重新 `agree` 会注册一个新账户） |
+| `/bj-hit` | 要一张牌 |
+| `/bj-stand` | 停牌，进入结算 |
+| `/bj-double` | 加倍注额并再要一张牌 |
+| `/bj-split` | 把一对相同点数的牌分成两手 |
+| `/bj-insure` | 庄家明牌为 A 时购买保险 |
+| `/bj-decline` | 不购买保险 |
+
+`bj-*` 六个动作命令只在有进行中的牌局时才有意义；没有牌局时执行会提示先
+`/blackjack deal`。
+
+### 兑换的两条路径
+
+兑换要求绑定 GitHub（一个 GitHub 身份只对应一个钱包，这是奖池出口唯一的反小号
+闸门）。绑定这件事只能在浏览器里完成——它走的是 GitHub 官方的 OAuth 授权码流。
+但**绑定只需要做一次**：
+
+1. **首次**：`/blackjack exchange` 给你一个短期配对码和链接。在浏览器里打开、
+   点「用 GitHub 继续」完成绑定，然后在同一页面的表单里填数量兑换。
+2. **之后**：`/blackjack exchange <数量>`。插件用它自己持有的令牌直接调服务端
+   的兑换接口，**不再生成配对码、不再需要打开浏览器**。不带数量时会先回显你的
+   余额与门槛，并提示补上数量——兑换不可逆，插件不会替你猜一个数字。
+
+余额没到门槛、或者数量超过余额，都会得到一句明确的中文提示（"余额还没到兑换门
+槛。" / "余额不足以完成这个动作。"），账本一分不动。
+
+---
+
+## 安装
+
+```sh
+dsh plugin --profile web add -w dsh-blackjack
+dsh --profile web
+```
+
+把 `web` 换成你实际要装的 profile 名。
+
+> **尚未发布到 npm 时**，上面这条命令还装不到东西。从源码装：
+>
+> ```sh
+> git clone https://github.com/yul761/dsh-blackjack
+> cd dsh-blackjack && pnpm install          # 会自动构建插件的 dist/
+> dsh plugin --profile web add -w "$PWD/packages/plugin"
+> ```
+>
+> 注意**不能**直接 `pnpm add github:yul761/dsh-blackjack`：这是个 monorepo，
+> 从 git 源装会拿到仓库根（一个没有入口的私有 workspace 根），而不是
+> `packages/plugin` 里的插件包。
+
+**为什么一定要带 `-w`：** dsh 的每个 profile 目录本身就是一个 pnpm 工作区（自
+带 `pnpm-workspace.yaml`），而 pnpm 默认拒绝在没有 `-w`/`--workspace-root` 的
+情况下向工作区**根**添加依赖——省掉这个参数，安装命令会直接失败退出，而不是装
+出一个残缺的状态。这不是本插件独有的坑，其它社区 dsh 插件的安装文档也踩过同一
+处并确认了同样的结论。
+
+安装成功后，dsh 会读取插件 `package.json` 里的 `dsh.bundle.patch` 声明并自动把
+`blackjack.cordis.yml` 接进 profile 的 bundle 层——不需要你手工再写一份
+`--patch` 覆盖层。
+
+### 配置
+
+装完开箱即用：`serverUrl` 默认指向本项目运营者自托管的那一份服务，不改配置也能
+直接玩。要在 profile 的 `cordis.patch.yml` 里覆盖也可以：
+
+| 配置项 | 类型 | 默认值 | 说明 |
+|---|---|---|---|
+| `serverUrl` | string | `https://server-production-493c.up.railway.app` | 牌局服务端地址。**想自建奖池就改成你自己的部署地址**——服务端与本插件同仓开源，见仓库根 README 的部署一节 |
+| `enabled` | boolean | `true` | 设为 `false` 可保留安装但完全停用：不注册任何命令，也不挂任何路由或续命钩子 |
+
+```yaml
+# ~/.dsh/profiles/<profile>/cordis.patch.yml
+- id: blackjack
+  config:
+    serverUrl: https://your-blackjack-server.example.com
+```
+
+---
+
+## 续命路由到底怎么触发（务必读完）
+
+插件会在 `llm/stream` 上挂一个观察者，但它**绝不会拦截正常调用**。触发续命只
+有在同时满足以下条件时才会发生：
+
+1. 这次调用用的是**你自己配置的模型 provider**（不是插件自己的奖池路由，避免
+   死循环）；
+2. 这次调用**没有产出任何内容**——哪怕已经吐出一个字，也不算数，插件绝不会在
+   内容已经开始返回后中途换源，那样只会造成重复或截断；
+3. 调用是以**配额耗尽**这一类错误收尾的（不是网络错误、不是参数错误、不是别
+   的任何原因）；
+4. 你在本插件里**已经完成过 `/blackjack agree`**（本机存有牌桌凭证；没有这份
+   凭证，插件根本不会尝试）。
+
+   这里只看凭证，**不预先检查你的已兑换额度够不够**。这是刻意的：查余额要在每
+   次失败调用上多打一次网络请求，拿到的还是一个可能已经过期的快照；而"有凭证、
+   余额为零"这条路本身就是安全的——奖池调用会被服务端直接拒绝，插件于是把**你
+   原本的那个错误**原样交还给你，跟没装插件完全一样。
+
+四条同时成立时，插件才会把这一次失败的调用重发到奖池路由。
+
+**切换提示去哪了（请注意）：** 成功切换时插件会输出一行「已切换至奖池余额继续
+本次请求。」，但在当前 dsh 版本里它**只写进 dsh 自己的日志，不会出现在对话界面
+里**——这个版本没有给插件提供任何"往对话里插一条非模型消息"的通道，唯一现成的
+通道会把内容写进模型可见的历史，那是本项目明确不做的（不污染上下文、不让模型看
+到）。换句话说：一次调用可能是靠奖池额度完成的，而你在界面上看不到提示；要确认
+消耗，请用 `/blackjack` 查看已兑换额度的变化。等 dsh 提供插件可用的会话内通知位，
+这条会改成界面内提示。
+
+**如果奖池也用完了、或者奖池服务本身连不上，插件不会伪造一个成功结果**——你会
+原样收到你自己那次调用本来的失败原因，就像没装这个插件一样。换句话说：装上这
+个插件，一次调用的结果**只可能不变或变好，不会变坏**。
+
+---
+
+## 参与规则
+
+- **参与永远免费。** 每日固定几手免费牌，零成本参与；不存在、也不会出现"付费
+  换手数 / 换概率 / 换赔率"的任何设计。
+- **CHIP 与已兑换额度单向、封闭。**
+  - **不可提现**，不折算任何法定货币，界面不显示金额；
+  - **不可转让**（含玩家之间转让），不可退换；
+  - **不会进入任何模型厂商的账户**；
+  - **唯一用途**是通过牌局服务端的续命路由消费——除此之外没有任何出口。
+- **有赛季有效期。** 已兑换额度有效期至本赛季末（含宽限期）；连续一段时间无
+  游戏且无消费的账户余额会被回收进奖池。这些提醒会在插件里提前给出，兑换前也
+  会再提示一次。
+- **你自己的 API key 永远不会进入这套系统**：插件不读取、不托管、不代管你自
+  己 provider 的任何密钥，续命路由用的是牌局服务端自己签发的凭证。
+
+---
+
+## 卸载与清除本机凭证
+
+只想清掉本地保存的牌桌登录凭证（例如换机器、或者想用一个全新账户重新开始），
+不需要卸载插件：
+
+```
+/blackjack reset confirm
+```
+
+（不带 `confirm` 时会先回显一遍这条操作的说明，避免误触。）这只清除**本机**保
+存的凭证，服务端那边的账户记录不受影响；用 `/blackjack agree` 即可重新注册一
+个新账户。
+
+要完全移除插件本身：
+
+```sh
+dsh plugin --profile web remove dsh-blackjack
+```

package/blackjack.cordis.yml

@@ -0,0 +1,13 @@
+# dsh bundle patch for dsh-blackjack. Declared by package.json's
+# `dsh.bundle.patch`, so `dsh plugin --profile <name> add -w dsh-blackjack`
+# activates the plugin without a manual --patch overlay.
+- insert:
+    - id: blackjack
+      name: dsh-blackjack
+      config:
+        # 牌局服务端地址。默认已指向本项目运营者自托管的那一份，不填也能玩。
+        # 想自建奖池就改成你自己的部署地址（服务端同仓开源）。
+        # serverUrl: https://your-own-deployment.example.com
+
+        # 设为 false 可保留安装但完全停用（不注册命令、不挂路由）。
+        # enabled: true

package/dist/adapter.d.ts

@@ -0,0 +1,33 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type LlmAdapter } from '@deepseek-ai/dsh-llm';
+import { type DeepSeekConnectionOptions } from '@deepseek-ai/dsh-llm-deepseek';
+/**
+ * The pool route's connection facts. A standalone, side-effect-free function
+ * (rather than only a closure inside `createPoolAdapter`) so `baseURL` and
+ * `apiKeyEnv` — the two facts this whole feature depends on — are directly
+ * assertable in a test without driving a live `DeepSeekAdapter.stream()`.
+ */
+export declare function poolConnectionOptions(serverUrl: string): DeepSeekConnectionOptions;
+/**
+ * Build the per-request credential resolver, also exported standalone so its
+ * `MISSING_CREDENTIAL` throw and `assertUsableApiKey` validation are directly
+ * testable against a fake `ctx.credentials`.
+ */
+export declare function createPoolResolveApiKey(ctx: Context): (connection: DeepSeekConnectionOptions) => Promise<string>;
+/**
+ * Build the pool-route adapter by pointing `DeepSeekAdapter` — the same
+ * tested wire-format translator `@deepseek-ai/dsh-llm-deepseek` uses for its
+ * own `deepseek-official` route — at our metering proxy's chat-completions-
+ * compatible endpoint. No hand-written SSE/tool-call translation here.
+ *
+ * Mirrors `dsh-llm-deepseek`'s own `apply()` wiring line-by-line (verified
+ * against the installed `@deepseek-ai/dsh-llm-deepseek@0.1.0-rc.6` source):
+ * `options` is re-read per operation, `resolveApiKey` resolves through
+ * `ctx.credentials`, validates the value with the same `assertUsableApiKey`
+ * the vendor's own `apply()` applies (trims whitespace, refuses a blank or
+ * header-unsafe value with `LlmError` `INVALID_CREDENTIAL` instead of
+ * letting `fetch` fail on it opaquely), and throws `LlmError`
+ * `MISSING_CREDENTIAL` when no token is stored at all; `resolveUserId`
+ * reuses the harness-home anonymous id.
+ */
+export declare function createPoolAdapter(ctx: Context, serverUrl: string): LlmAdapter;

package/dist/adapter.js

@@ -0,0 +1,58 @@
+import { LlmError, assertUsableApiKey, resolveRetryPolicy } from '@deepseek-ai/dsh-llm';
+import { DeepSeekAdapter, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, } from '@deepseek-ai/dsh-llm-deepseek';
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { getOrCreateAnonymousUserId } from '@deepseek-ai/dsh-anonymous-user-id';
+import { TOKEN_REF } from './config.js';
+/**
+ * The pool route's connection facts. A standalone, side-effect-free function
+ * (rather than only a closure inside `createPoolAdapter`) so `baseURL` and
+ * `apiKeyEnv` — the two facts this whole feature depends on — are directly
+ * assertable in a test without driving a live `DeepSeekAdapter.stream()`.
+ */
+export function poolConnectionOptions(serverUrl) {
+    return {
+        baseURL: `${serverUrl}/v1`,
+        apiKeyEnv: credentialRef(TOKEN_REF),
+        defaults: {},
+        maxTokens: DEFAULT_MAX_TOKENS,
+        defaultContextWindow: DEFAULT_CONTEXT_WINDOW,
+        models: [],
+        streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+        retryPolicy: resolveRetryPolicy(undefined, 'dsh-blackjack: pool retryPolicy'),
+    };
+}
+/**
+ * Build the per-request credential resolver, also exported standalone so its
+ * `MISSING_CREDENTIAL` throw and `assertUsableApiKey` validation are directly
+ * testable against a fake `ctx.credentials`.
+ */
+export function createPoolResolveApiKey(ctx) {
+    return async (connection) => {
+        const hit = await ctx.credentials.resolve(connection.apiKeyEnv);
+        if (hit !== undefined)
+            return assertUsableApiKey(hit.value, 'dsh-blackjack', connection.apiKeyEnv);
+        throw new LlmError(`dsh-blackjack: no player token for the pool provider route; accept the plugin's one-time notice first`, 'MISSING_CREDENTIAL');
+    };
+}
+/**
+ * Build the pool-route adapter by pointing `DeepSeekAdapter` — the same
+ * tested wire-format translator `@deepseek-ai/dsh-llm-deepseek` uses for its
+ * own `deepseek-official` route — at our metering proxy's chat-completions-
+ * compatible endpoint. No hand-written SSE/tool-call translation here.
+ *
+ * Mirrors `dsh-llm-deepseek`'s own `apply()` wiring line-by-line (verified
+ * against the installed `@deepseek-ai/dsh-llm-deepseek@0.1.0-rc.6` source):
+ * `options` is re-read per operation, `resolveApiKey` resolves through
+ * `ctx.credentials`, validates the value with the same `assertUsableApiKey`
+ * the vendor's own `apply()` applies (trims whitespace, refuses a blank or
+ * header-unsafe value with `LlmError` `INVALID_CREDENTIAL` instead of
+ * letting `fetch` fail on it opaquely), and throws `LlmError`
+ * `MISSING_CREDENTIAL` when no token is stored at all; `resolveUserId`
+ * reuses the harness-home anonymous id.
+ */
+export function createPoolAdapter(ctx, serverUrl) {
+    const resolveApiKey = createPoolResolveApiKey(ctx);
+    let userId;
+    const resolveUserId = () => (userId ??= getOrCreateAnonymousUserId());
+    return new DeepSeekAdapter({ options: () => poolConnectionOptions(serverUrl), resolveApiKey, resolveUserId });
+}

package/dist/api.d.ts

@@ -0,0 +1,85 @@
+export interface Card {
+    rank: string;
+    suit: 'S' | 'H' | 'D' | 'C';
+}
+export type HiddenCard = {
+    hidden: true;
+};
+export interface HandView {
+    cards: Card[];
+    total: number;
+    soft: boolean;
+    doubled: boolean;
+    done: boolean;
+    outcome: string | null;
+}
+export interface RoundView {
+    id: string;
+    mode: 'free' | 'raise';
+    phase: 'insurance' | 'player' | 'settled';
+    betChips: number;
+    hands: HandView[];
+    dealer: {
+        cards: (Card | HiddenCard)[];
+        total?: number;
+    };
+    actions: string[];
+    payoutChips?: number;
+    pointsGranted?: number;
+    poolShortfall?: boolean;
+}
+export interface MeView {
+    playerId: string;
+    chips: number;
+    exchangedChips: number;
+    points: number;
+    freeHandsRemaining: number;
+    seasonId: string;
+    sponsorText: string;
+    poolEmpty: boolean;
+    exchangeThresholdChips: number;
+    baseBetChips: number;
+    githubLogin: string | null;
+}
+/** Every failure this client surfaces: HTTP status plus the server's error code. */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, code?: string | undefined, message?: string);
+}
+export interface Api {
+    register(): Promise<{
+        playerId: string;
+        token: string;
+    }>;
+    me(token: string): Promise<MeView>;
+    activeRound(token: string): Promise<RoundView | undefined>;
+    startRound(token: string, body: {
+        mode: 'free' | 'raise';
+        betChips?: number;
+    }): Promise<RoundView>;
+    act(token: string, roundId: string, action: string): Promise<RoundView>;
+    /**
+     * Exchange `chips` of game balance for spendable quota directly, with no
+     * browser round-trip. The server requires an already-bound GitHub identity
+     * (403 `github binding required`), so this is the SECOND exchange path — the
+     * one an already-bound player takes on every repeat exchange. First-time
+     * binding still has to go through `startPairing` and the browser, because
+     * only a browser can complete GitHub's authorization-code flow.
+     */
+    exchange(token: string, chips: number): Promise<{
+        chips: number;
+        exchangedChips: number;
+        note: string;
+    }>;
+    startPairing(token: string): Promise<{
+        code: string;
+        url: string;
+        expiresInSeconds: number;
+    }>;
+    chatCompletionsUrl(): string;
+}
+export declare function createApi(opts: {
+    serverUrl: string;
+    fetchImpl?: typeof fetch;
+}): Api;

package/dist/api.js

@@ -0,0 +1,55 @@
+/** Every failure this client surfaces: HTTP status plus the server's error code. */
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message ?? `api error ${status}${code ? `: ${code}` : ''}`);
+        this.status = status;
+        this.code = code;
+        this.name = 'ApiError';
+    }
+}
+export function createApi(opts) {
+    const base = opts.serverUrl.replace(/\/+$/, '');
+    const f = opts.fetchImpl ?? fetch;
+    async function call(path, init = {}) {
+        const { token, ...rest } = init;
+        const headers = new Headers(rest.headers);
+        if (token)
+            headers.set('authorization', `Bearer ${token}`);
+        if (rest.body)
+            headers.set('content-type', 'application/json');
+        let res;
+        try {
+            res = await f(`${base}${path}`, { ...rest, headers });
+        }
+        catch (cause) {
+            throw new ApiError(0, undefined, `cannot reach ${base}: ${cause.message}`);
+        }
+        if (res.status === 204)
+            return undefined;
+        const text = await res.text();
+        const body = text ? safeParse(text) : {};
+        if (!res.ok)
+            throw new ApiError(res.status, typeof body?.error === 'string' ? body.error : undefined);
+        return body;
+    }
+    function safeParse(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {
+        register: () => call('/api/register', { method: 'POST' }),
+        me: (token) => call('/api/me', { token }),
+        activeRound: (token) => call('/api/round/active', { token }),
+        startRound: (token, body) => call('/api/round/start', { method: 'POST', token, body: JSON.stringify(body) }),
+        act: (token, roundId, action) => call(`/api/round/${encodeURIComponent(roundId)}/action`, { method: 'POST', token, body: JSON.stringify({ action }) }),
+        exchange: (token, chips) => call('/api/exchange', { method: 'POST', token, body: JSON.stringify({ chips }) }),
+        startPairing: (token) => call('/api/pairing/start', { method: 'POST', token }),
+        chatCompletionsUrl: () => `${base}/v1/chat/completions`,
+    };
+}

package/dist/client/Table.d.ts

@@ -0,0 +1,30 @@
+import type { MeView, RoundView } from '../api.js';
+/**
+ * Pure presentational graphical blackjack table, rendered inside the
+ * `conversation.chat.commandview` slot for the `/blackjack` command row.
+ *
+ * Consent lives entirely on the command plane: before `state.consented` is
+ * true this component renders ONLY the pointer to `/blackjack agree` — no
+ * play controls, and (deliberately) no button that could grant consent from
+ * the browser, matching the host route's 403-before-consent behaviour
+ * (`routes.ts`).
+ *
+ * All player-facing copy here must stay within the same red lines as the
+ * command-plane text renderer (`render.ts`): no gambling vocabulary, no
+ * model-vendor branding tied to the game, CHIP (never RMB) as the only unit.
+ * @module dsh-blackjack/client/Table
+ */
+/** Shape of the `GET /blackjack/api/state` response (see `routes.ts`). */
+export interface BlackjackApiState {
+    consented: boolean;
+    me?: MeView;
+    round?: RoundView;
+}
+export interface BlackjackTableProps {
+    state: BlackjackApiState;
+    onAction: (action: string) => void;
+    onDeal: (betChips?: number) => void;
+    /** Brief inline notice for a failed action/deal call (container-owned; cleared on the next successful one). */
+    error?: string;
+}
+export declare function BlackjackTable({ state, onAction, onDeal, error }: BlackjackTableProps): JSX.Element;

package/dist/client/Table.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const SUITS = { S: '♠', H: '♥', D: '♦', C: '♣' };
+const RED_SUITS = new Set(['H', 'D']);
+const n = (v) => v.toLocaleString('en-US');
+const ACTION_LABELS = {
+    hit: '要牌', stand: '停牌', double: '双倍', split: '分牌', insure: '买保险', decline: '不买保险',
+};
+const CSS = `
+.bj-table { --bj-felt: #0f3d2e; --bj-line: rgba(255,255,255,.18); font-size: 14px; }
+.bj-hand { display: flex; gap: 6px; flex-wrap: wrap; align-items: center; margin: 4px 0; }
+.bj-card {
+  width: 38px; height: 54px; border-radius: 6px; display: flex; align-items: center;
+  justify-content: center; font-weight: 700; font-size: 15px; box-shadow: 0 1px 2px rgba(0,0,0,.35);
+  background: #fdfdf8; border: 1px solid rgba(0,0,0,.15);
+}
+.bj-card-red { color: #c0392b; }
+.bj-card-black { color: #1a1a1a; }
+.bj-card-back {
+  background-image: repeating-linear-gradient(45deg, #2a5aa0, #2a5aa0 4px, #1d4278 4px, #1d4278 8px);
+  border: 1px solid rgba(255,255,255,.4);
+}
+.bj-actions { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 8px; }
+.bj-actions button {
+  font: inherit; padding: 6px 14px; border-radius: 6px; border: 1px solid var(--bj-line);
+  background: rgba(255,255,255,.08); color: inherit; cursor: pointer;
+}
+.bj-actions button:hover { background: rgba(255,255,255,.16); }
+.bj-meta { opacity: .85; margin-bottom: 8px; }
+.bj-error {
+  color: #c0392b; border: 1px solid rgba(192,57,43,.4); border-radius: 6px;
+  padding: 4px 8px; margin-bottom: 8px;
+}
+`;
+function CardFace({ card }) {
+    if ('hidden' in card) {
+        return _jsx("div", { className: "bj-card bj-card-back", "aria-label": "\u6697\u724C" });
+    }
+    const suit = SUITS[card.suit] ?? card.suit;
+    const cls = RED_SUITS.has(card.suit) ? 'bj-card-red' : 'bj-card-black';
+    return _jsx("div", { className: `bj-card ${cls}`, children: `${card.rank}${suit}` });
+}
+function HandRow({ hand, label }) {
+    const soft = hand.soft ? '软' : '';
+    return (_jsxs("div", { children: [_jsxs("div", { className: "bj-meta", children: [label, "\uFF08", soft, hand.total, "\uFF09", hand.doubled ? ' [双倍]' : ''] }), _jsx("div", { className: "bj-hand", children: hand.cards.map((card, i) => (_jsx(CardFace, { card: card }, i))) })] }));
+}
+function DealerRow({ dealer }) {
+    return (_jsxs("div", { children: [_jsxs("div", { className: "bj-meta", children: ["\u5E84\u5BB6", dealer.total !== undefined ? `（${dealer.total}）` : ''] }), _jsx("div", { className: "bj-hand", children: dealer.cards.map((card, i) => (_jsx(CardFace, { card: card }, i))) })] }));
+}
+function ConsentPrompt() {
+    return (_jsx("div", { className: "bj-table", children: _jsxs("p", { children: ["\u8BF7\u5148\u5728\u547D\u4EE4\u884C\u8F93\u5165 ", _jsx("code", { children: "/blackjack agree" }), "\uFF0C\u9605\u8BFB\u5E76\u540C\u610F\u89C4\u5219\u540E\u624D\u80FD\u5F00\u59CB\u3002"] }) }));
+}
+function MeHeader({ me }) {
+    return (_jsxs("div", { className: "bj-meta", children: ["\u4F59\u989D\uFF1A", n(me.chips), " CHIP\u3000\u4ECA\u65E5\u5269\u4F59\u514D\u8D39\u624B\uFF1A", me.freeHandsRemaining, me.points > 0 ? `　积分：${n(me.points)}` : '', me.poolEmpty ? '（本期奖池已发完，现在赢牌将发放积分）' : '', me.sponsorText ? _jsx("div", { children: me.sponsorText }) : null] }));
+}
+function RoundFooter({ round }) {
+    if (round.phase !== 'settled')
+        return null;
+    const payout = round.payoutChips ?? 0;
+    return (_jsxs("div", { className: "bj-meta", children: [payout > 0 ? `本手赢得 ${n(payout)} CHIP。` : '本手没有收获，明天再来。', round.pointsGranted ? _jsxs("div", { children: ["\u672C\u671F\u5956\u6C60\u5DF2\u53D1\u5B8C\uFF0C\u6539\u4E3A\u53D1\u653E ", n(round.pointsGranted), " \u79EF\u5206\u3002"] }) : null] }));
+}
+function ActionBar({ round, onAction }) {
+    if (round.actions.length === 0)
+        return null;
+    return (_jsx("div", { className: "bj-actions", children: round.actions.map((action) => (_jsx("button", { type: "button", onClick: () => onAction(action), children: ACTION_LABELS[action] ?? action }, action))) }));
+}
+function NoRound({ me, onDeal }) {
+    return (_jsxs("div", { children: [_jsx("div", { className: "bj-meta", children: "\u5F53\u524D\u6CA1\u6709\u8FDB\u884C\u4E2D\u7684\u724C\u5C40\u3002" }), _jsxs("div", { className: "bj-actions", children: [_jsx("button", { type: "button", onClick: () => onDeal(), children: "\u5F00\u59CB\u4E00\u5C40\uFF08\u9650\u514D\uFF09" }), me ? (_jsxs("button", { type: "button", onClick: () => onDeal(me.baseBetChips), children: ["\u5F00\u59CB\u4E00\u5C40\uFF08", n(me.baseBetChips), " CHIP\uFF09"] })) : null] })] }));
+}
+export function BlackjackTable({ state, onAction, onDeal, error }) {
+    if (!state.consented)
+        return _jsx(ConsentPrompt, {});
+    const { me, round } = state;
+    return (_jsxs("div", { className: "bj-table", children: [_jsx("style", { children: CSS }), error ? _jsx("div", { className: "bj-error", children: error }) : null, me ? _jsx(MeHeader, { me: me }) : null, round ? (_jsxs("div", { children: [round.hands.map((hand, i) => (_jsx(HandRow, { hand: hand, label: round.hands.length > 1 ? `你的第 ${i + 1} 手` : '你的牌' }, i))), _jsx(DealerRow, { dealer: round.dealer }), _jsx(RoundFooter, { round: round }), _jsx(ActionBar, { round: round, onAction: onAction })] })) : (_jsx(NoRound, { me: me, onDeal: onDeal }))] }));
+}

package/dist/client/index.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Client module entry: registers the graphical table into the KEYED
+ * `conversation.chat.commandview` slot under `key: 'blackjack'`, so every
+ * `/blackjack` command row in the conversation renders `BlackjackTable`
+ * instead of (or alongside) the plain-text reply. Registration shape
+ * mirrors `dsh-statecore`'s client module (`dist/client.js`), the only
+ * difference being the keyed slot needs a `key` instead of an `id`/`order`.
+ * @module dsh-blackjack/client
+ */
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;

package/dist/client/index.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { BlackjackTable } from './Table.js';
+/**
+ * Client module entry: registers the graphical table into the KEYED
+ * `conversation.chat.commandview` slot under `key: 'blackjack'`, so every
+ * `/blackjack` command row in the conversation renders `BlackjackTable`
+ * instead of (or alongside) the plain-text reply. Registration shape
+ * mirrors `dsh-statecore`'s client module (`dist/client.js`), the only
+ * difference being the keyed slot needs a `key` instead of an `id`/`order`.
+ * @module dsh-blackjack/client
+ */
+export const inject = ['slots'];
+async function getJson(path, init) {
+    const res = await fetch(path, init);
+    const text = await res.text();
+    const body = text.length > 0 ? JSON.parse(text) : {};
+    if (!res.ok) {
+        const error = typeof body?.error === 'string' ? body.error : `${res.status}`;
+        throw new Error(error);
+    }
+    return body;
+}
+/** Brief, vocabulary-safe notice shown when an action/deal call fails; never echoes the raw server error text. */
+const ACTION_FAILED_NOTICE = '上一次操作没有成功，已为你刷新到最新状态。';
+/** Container: owns data fetching. Refetches state after every action — no polling timer. */
+function BlackjackTableContainer() {
+    const [state, setState] = useState(null);
+    const [actionError, setActionError] = useState(null);
+    const refresh = useCallback(() => {
+        getJson('/blackjack/api/state')
+            .then(setState)
+            .catch(() => setState({ consented: false }));
+    }, []);
+    useEffect(() => {
+        refresh();
+    }, [refresh]);
+    const runAction = useCallback((path, body) => {
+        getJson(path, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        })
+            .then(() => {
+            setActionError(null);
+            refresh();
+        })
+            .catch(() => {
+            // A failed action (including the 404 "no active round" case) still
+            // resyncs state so the UI never shows a stale action bar, but the
+            // notice stays up until the next successful action clears it.
+            setActionError(ACTION_FAILED_NOTICE);
+            refresh();
+        });
+    }, [refresh]);
+    const onDeal = useCallback((betChips) => runAction('/blackjack/api/deal', betChips === undefined ? {} : { betChips }), [runAction]);
+    const onAction = useCallback((action) => runAction('/blackjack/api/action', { action }), [runAction]);
+    if (state === null)
+        return null;
+    return _jsx(BlackjackTable, { state: state, onAction: onAction, onDeal: onDeal, error: actionError ?? undefined });
+}
+export function apply(ctx) {
+    ctx.slots.inject('conversation.chat.commandview', () => ctx.slots.register({
+        name: 'conversation.chat.commandview',
+        key: 'blackjack',
+        inject: () => ({}),
+    }, BlackjackTableContainer));
+}