@xiaobuyu/nodesign 0.0.7 → 0.0.8

package/server/lib/model-ingress.js

@@ -39,6 +39,7 @@ import { resolveWireModel, UPSTREAMS } from '../engine/agent/model-context.js';
 import { resolveSessionWire, fallbackLogged } from './ingress/session-routes.js';
 import { forwardOpenAIChat } from './ingress/forward-openai-chat.js';
 import { failStreaks, exhaustedErrorBody } from './ingress/upstream-fail-streak.js';
+import { armIdleWatchdog } from './ingress/stream-watchdog.js';
 import { noteUpstreamBilling } from './ingress/upstream-billing.js';
 import { noteUpstreamTruncation } from './ingress/upstream-truncation.js';
 import { noticeSession } from './ingress/session-notice.js';
@@ -295,6 +296,15 @@ async function handleRequest(req, res, bodyBuf) {
       noteOutcome(true);
     }
     res.writeHead(proxyRes.statusCode, proxyRes.headers);
+    // 断流看门狗（2026-08-29，proj_mtexu1kp 现场）：上游 SSE 半路断粮不报错不 EOF，
+    // run 会无限挂起。只对流式响应上岗；掐掉后 CLI 收到流错误自己重试。
+    if (proxyRes.statusCode < 400 && String(proxyRes.headers['content-type'] || '').includes('event-stream')) {
+      armIdleWatchdog(proxyRes, { onIdle: (silentMs) => {
+        console.warn(`[model-ingress] sid=${sidShort} upstream=${wire.upstreamId} 流静默 ${Math.round(silentMs / 1000)}s —— 看门狗掐断死流`);
+        noteOutcome(false, 'stream idle');
+        try { proxyRes.destroy(new Error('ingress stream idle watchdog')); } catch { /* 已经死了就算了 */ }
+      } });
+    }
     proxyRes.pipe(res);
   });
 
@@ -327,7 +337,12 @@ export async function transformForUpstream(parsed, wire) {
 
   // thinking：'strip' = 删字段让上游自决（Gemini thinking 关不掉、参数过桥行为
   // 未知）；'enabled8k' = adaptive 改写成 enabled+budget（Kimi 实测 adaptive =
-  // 0 thinking blocks）
+  // 0 thinking blocks）；'adaptive' = 反过来，enabled+budget 改写成 adaptive。
+  //
+  // ⚠️ 本站给**每一条 API 行**发的都是 enabled+8192（model-context.pickThinkingConfig），
+  // 对"自己会判断该不该想"的模型等于逐轮强制想满预算。MiniMax M3 是这一类（08-25 实测
+  // GMI 部署 adaptive/disabled/enabled 三种都收）：agent 一轮里大半是读文件调工具，
+  // 该不该想交给它自己。
   if (wire.thinking === 'strip') {
     if ('thinking' in parsed) { delete parsed.thinking; mutated = true; }
   } else if (wire.thinking === 'enabled8k') {
@@ -335,6 +350,12 @@ export async function transformForUpstream(parsed, wire) {
       parsed.thinking = { type: 'enabled', budget_tokens: 8192 };
       mutated = true;
     }
+  } else if (wire.thinking === 'adaptive') {
+    // 'disabled' 不动：那是调用方明确要求别想，行的默认档不该压过它
+    if (parsed.thinking && parsed.thinking.type !== 'adaptive' && parsed.thinking.type !== 'disabled') {
+      parsed.thinking = { type: 'adaptive' };
+      mutated = true;
+    }
   }
 
   // tool_result 里的图提升到 user message 顶层（丢图桥的必修 shim）
@@ -349,6 +370,10 @@ export async function transformForUpstream(parsed, wire) {
     if (await normalizeImages(parsed.messages, VISION_MAX_DIM, allowed)) mutated = true;
   }
 
+  // 上游要的额外顶层字段（merge 的 vendor 点名）。放在这里是 **Anthropic 透传腿的读者** ——
+  // 那条腿直接 JSON.stringify(parsed)。openai-chat 腿另有一个读者，见 toOpenAIChatRequest
+  if (wire.bodyExtra) { Object.assign(parsed, wire.bodyExtra); mutated = true; }
+
   return mutated;
 }
 

package/server/lib/moderation.js

@@ -20,7 +20,9 @@
  * 强度三档，**per-user、per-通路可调**（站主在控制台按人设）。08-20 起按模型通路分成
  * 两个独立旋钮：users.moderation_level 管订阅模型（Sonnet/Opus，跑在站主账号上），
  * users.moderation_level_api 管本地 qwen / 中转站那些走 ingress 的 API 行。哪条通路
- * 由 model-context 的 resolveModelRoute 说了算，这里不判模型名。两边默认档推导相同。
+ * 由 model-context 的 resolveModelRoute 说了算，这里不判模型名。
+ * ⭐ **08-30 起两边的默认档也各算各的**（tier.js 的 moderationDefault / moderationDefaultApi）：
+ * 订阅 strict、非订阅 off。在此之前两边推导同一个值，"订阅严、其他放开"只能靠逐人钉。
  * 同一档位值同时管 GPT 外审和 prelude 的成人句（见 agent/system-prompts.js）。
  *   off     不审
  *   loose   只拦"换个说法也还是违法"的硬线：未成年人色情 / 恐怖主义 / 武器毒品
@@ -29,8 +31,10 @@
  *           小说 / RP 形态天然要碰这些，误伤创作比漏审更伤产品。
  *   strict  loose 全部 + 露骨色情 / 美化煽动真实暴力 / 群体仇恨歧视。
  *
- * 默认档（users.moderation_level 为 NULL 时）：试用号 strict / 正式号 loose /
- * admin off。改默认档不影响已显式设过的号。`NODESIGN_MODERATION=off` 是全站总闸。
+ * 默认档（该旋钮为 NULL 时）走 tier.js 的能力表：订阅通路 admin off / pro·basic strict，
+ * API 通路一律 off。改默认档不影响已显式钉过档的号 —— 所以改默认时要顺手看一眼库里还有多少
+ * 显式值压着（08-30 那次把 41 个显式的 API 档清回 NULL，就是为了让这张表真的说了算）。
+ * `NODESIGN_MODERATION=off` 是全站总闸。
  */
 
 import db from '../engine/runs/store.js';
@@ -94,9 +98,10 @@ export function levelForKnob(user, knob) {
   if (!user) return 'off';
   const explicit = knob === 'api' ? user.moderationLevelApi : user.moderationLevel;
   if (LEVELS.includes(explicit)) return explicit;
-  // 默认档按账号档位（auth/tier.js 能力表）：admin off / pro loose / basic strict。
+  // 默认档按账号档位**和通路**（auth/tier.js 能力表）：订阅 admin off / pro·basic strict，API 一律 off。
   // 08-21 前这里猜的是 lifetimeCostLimitUsd（试用码 ⇒ strict），开放注册号该字段为 null 被当成正式号拿 loose。
-  return defaultModerationLevel(user);
+  // ⚠️ knob 必须往下传：08-30 之前这里不传，于是 tier 表里就算分了两栏也读不到第二栏。
+  return defaultModerationLevel(user, knob);
 }
 
 export function shouldModerate(user, appModel = null) {

package/server/lib/quota.js

@@ -222,12 +222,22 @@ export function usedTodayByFamily(userId, now = Date.now()) {
 //
 // 08-21 经营态转向后分两档：
 // - 订阅行（花站主的订阅）：全局固定数 NODESIGN_MAX_CONCURRENT_RUNS（默认 3）
-// - 免费行（Ox 这类零价模型）：不受全局固定数限制。它的约束只剩机器本身 ——
+// - 非订阅行（走 ingress 的 API 行）：不受全局固定数限制。它的约束只剩机器本身 ——
 //   每个 claude CLI 进程 350MB~1GB、机器 1 vCPU/8G 无 swap，所以改成**内存闸**：
 //   MemAvailable 低于 NODESIGN_MIN_FREE_MEM_MB（默认 700）就拒，外加一个防失控的
 //   上限 NODESIGN_FREE_MAX_CONCURRENT_RUNS（默认 12）。内存闸对两档都生效（订阅行
 //   的固定数 3 本来就是按内存拍的，内存先见底时固定数也救不了）
 // - 每用户同时 1 个（admin 免）两档都一样：这是公平性不是资源
+//
+// ⭐⭐ **2026-08-30 判据从「免费/付费」改成「订阅/非订阅」**。起因：全员默认行换成
+// glm-5.3-flash-merge（付费但极便宜，$0.015/M）。按老判据它落进"付费"那一档，站点默认
+// 路径的并发天花板会从 12 掉到 3，而这台盒子实测峰值在飞 turn 是 4 —— 第 4 个人当场
+// 吃「现在有点挤」。
+// 这不是把闸放松，是**把闸对准它本来护的东西**：那个 3 从头到尾护的是站主的 Claude 订阅
+// （同时开太多 query 会烧额度、也会被上游限流），跟"这一轮花不花钱"没有关系。一条
+// $0.015/M 的网关行既不烧订阅、也不烧机器以外的任何东西，它该受的约束就是内存。
+// ⚠️ 于是**付费的 API 行现在也走 12 + 内存闸**（deepseek 视觉行、merge 行）。真要给某一家
+// 单独收并发，那是 per-upstream 的闸，不是把它塞回订阅那一档。
 
 export function memAvailableMb() {
   try {
@@ -236,13 +246,20 @@ export function memAvailableMb() {
   } catch { return null; }   // 非 Linux / 读不到 → 不以内存拒
 }
 
-/** 纯决策：输入全是数，方便测 */
-export function decideConcurrency({ running, mine, isAdmin, free, memMb, env = process.env }) {
+/**
+ * 纯决策：输入全是数，方便测。
+ * @param {boolean} offSubscription 这一轮**不花站主订阅**（走 ingress 的 API 行）。
+ *   ⚠️ 08-30 前这个参数叫 `free`、判据是"模型免不免费"，改名是因为那个名字骗过人一次：
+ *   默认行换成一条付费但极便宜的 API 行时，它被判进订阅那一档、天花板从 12 掉到 3。
+ */
+export function decideConcurrency({ running, mine, isAdmin, offSubscription, free, memMb, env = process.env }) {
+  // 老参数名还认（旧调用方 / 测试），但新名优先
+  const offSub = offSubscription !== undefined ? offSubscription : !!free;
   const minMem = Number(env.NODESIGN_MIN_FREE_MEM_MB) || 700;
   if (memMb != null && memMb < minMem) {
     return { ok: false, code: 'BUSY', message: `机器内存快满了（${running} 个任务在跑），稍等一会儿再发` };
   }
-  const globalMax = free
+  const globalMax = offSub
     ? (Number(env.NODESIGN_FREE_MAX_CONCURRENT_RUNS) || 12)
     : (Number(env.NODESIGN_MAX_CONCURRENT_RUNS) || 3);
   if (running >= globalMax) {
@@ -257,7 +274,7 @@ export function decideConcurrency({ running, mine, isAdmin, free, memMb, env = p
   return { ok: true };
 }
 
-export function checkConcurrency(user, { free = false } = {}) {
+export function checkConcurrency(user, { offSubscription = false, free = false } = {}) {
   // running turn → user 归属：runId 查 runs.user_id（不给 session 注册表加
   // userId 字段 —— 正在跑的 turn 就几个，查表成本可忽略）
   let mine = 0;
@@ -266,5 +283,8 @@ export function checkConcurrency(user, { free = false } = {}) {
       if (getRun(rid)?.userId === user?.id) mine += 1;
     }
   }
-  return decideConcurrency({ running: countRunningTurns(), mine, isAdmin: user?.role === 'admin', free, memMb: memAvailableMb() });
+  return decideConcurrency({
+    running: countRunningTurns(), mine, isAdmin: user?.role === 'admin',
+    offSubscription: offSubscription || free, memMb: memAvailableMb(),
+  });
 }

package/server/lib/rect.js

@@ -0,0 +1,50 @@
+/**
+ * server/lib/rect.js —— 矩形原语（2026-08-27 审计收敛）
+ *
+ * 收敛前的账：AABB 重叠判定在服务端手写了 4 份、包围盒 5 份、UNIT=24 两处
+ * export，各自维护、容差和空集语义悄悄分叉（bbox 空集有的返回 null 有的返回
+ * 零框）。改判定只改这一份；需要不同空集语义的调用方自己在出口包一层。
+ *
+ * 前端的对应物是 web/src/lib/board-geometry.js 的 rectsHit —— 语义必须一致
+ * （相邻贴边 = 不重叠）。改这边记得看那边。
+ */
+
+/** 网格步长：全部世界坐标的公倍数。曾在 board-place / sketch-layout 各 export 一份。 */
+export const UNIT = 24;
+
+/** AABB 重叠（贴边不算重叠）。pad = 双方各让的身位。 */
+export const overlaps = (a, b, pad = 0) => !(
+  a.x + a.w + pad <= b.x || b.x + b.w <= a.x - pad
+  || a.y + a.h + pad <= b.y || b.y + b.h <= a.y - pad
+);
+
+/** 一组矩形的包围盒；空集返回 null（要零框语义自己在出口兜）。 */
+export function bboxOf(rects) {
+  let x0 = Infinity; let y0 = Infinity; let x1 = -Infinity; let y1 = -Infinity;
+  for (const r of rects) {
+    x0 = Math.min(x0, r.x); y0 = Math.min(y0, r.y);
+    x1 = Math.max(x1, r.x + (r.w || 0)); y1 = Math.max(y1, r.y + (r.h || 0));
+  }
+  return Number.isFinite(x0) ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : null;
+}
+
+/** 点在矩形内（含边）。 */
+export const pointIn = (pt, r) => pt.x >= r.x && pt.x <= r.x + r.w && pt.y >= r.y && pt.y <= r.y + r.h;
+
+/**
+ * 线段 a→b 是否穿过矩形 r（Liang-Barsky 裁剪；端点擦边也算穿）。
+ * 落位引擎用它判「连线走廊」：新块和它锚点之间那条线会不会压在第三块身上。
+ */
+export function segHitsRect(a, b, r) {
+  const dx = b.x - a.x; const dy = b.y - a.y;
+  let t0 = 0; let t1 = 1;
+  const clip = (p, q) => {
+    if (p === 0) return q >= 0;               // 与这条边平行：q<0 = 整段在外
+    const t = q / p;
+    if (p < 0) { if (t > t1) return false; if (t > t0) t0 = t; }
+    else { if (t < t0) return false; if (t < t1) t1 = t; }
+    return true;
+  };
+  return clip(-dx, a.x - r.x) && clip(dx, r.x + r.w - a.x)
+    && clip(-dy, a.y - r.y) && clip(dy, r.y + r.h - a.y);
+}

package/server/lib/screen.js

@@ -0,0 +1,36 @@
+/**
+ * server/lib/screen.js —— 「一屏」的唯一基准（2026-08-29 纸范式刀 0）
+ *
+ * 纸范式拍板：一张纸 = **0.75 倍缩放下等于用户一屏**的矩形工作区。
+ * 在这之前「一屏」有三个同源近邻值各自散落（fitFor 的 /0.8、board-place 的
+ * ONE_SCREEN 1750×1125、sketch-layout 的 SKETCH_FIT 1700×1100），注释里互相
+ * 提醒「改缩放基准要几处一起看」—— 现在基准只有这一份，改这里就是改全部。
+ *
+ * DEFAULT_SCREEN 是没有视点上报时的兜底屏（普通笔记本 1400×900）；真实纸尺寸
+ * 永远优先按上报的 device 屏幕算（见 sketch-layout.js fitFor）。
+ */
+
+export const ZOOM_BASIS = 0.75;
+
+export const DEFAULT_SCREEN = { w: 1400, h: 900 };
+
+/** 兜底「一屏」世界像素（1400×900 ÷ 0.75 = 1867×1200） */
+export const ONE_SCREEN = {
+  w: Math.round(DEFAULT_SCREEN.w / ZOOM_BASIS),
+  h: Math.round(DEFAULT_SCREEN.h / ZOOM_BASIS),
+};
+
+/**
+ * 一张卡的高度天花板（2026-08-29 占位契约刀 B，站主定「一张纸的 40%」）。
+ *
+ * 生产真板上最高一条板书 **2471px** —— 312 宽、2471 高，一整章小说写成一根柱子。
+ * 卡的高度原来完全由内容决定、没有上限，于是两件坏事同时发生：版面被柱子劈开，
+ * 而落位系统按估算高度排好队之后，渲染回写又把卡撑大去压邻居。
+ *
+ * 定成固定值而不是「按当前纸算」，是因为卡的高度不该随看它的设备变 —— 同一块板
+ * 在手机和大屏上看，卡的版面必须是同一个。384 = 16 格，也接近 973 高的纸的 40%。
+ *
+ * 超出的部分不是丢掉：卡上折叠（可展开，展开是临时的、不改占位），工具如实告诉
+ * agent「你这条被折叠了，实际 N px」——「越界钳住但要说」。
+ */
+export const CARD_MAX_H = 384;

package/server/lib/sheet-state.js

@@ -0,0 +1,19 @@
+/**
+ * server/lib/sheet-state.js —— 「当前纸」的会话指针（2026-08-29 纸范式）
+ *
+ * 每个会话记一张「正写在哪张纸上」。进程内存不落盘：丢了也无害 —— 读侧回落到
+ * 登记时间最新的一张（board-sheets.js currentSheet 的兜底），agent 重新铺纸或
+ * 点名纸名都能续上。放 board.json 是错的：两个会话同时开工会互相抢指针。
+ */
+
+const cur = new Map();   // sessionId → sheet name
+
+export function setCurrentSheetId(sessionId, id) {
+  if (sessionId && typeof id === 'string') cur.set(sessionId, id);
+}
+
+export function currentSheetIdOf(sessionId) {
+  return (sessionId && cur.get(sessionId)) || null;
+}
+
+export function _resetSheetState() { cur.clear(); }

package/server/lib/sketch-array.js

@@ -0,0 +1,118 @@
+/**
+ * server/lib/sketch-array.js —— 阵列 / 环列 / 镜像 / 散布（2026-08-30 画图能力线刀④）
+ *
+ * 复杂图案大多是简单元素的规律重复，而**等距和对称恰是模型最不擅长的算术**
+ * （画一圈椅子 = 12 次三角函数）。这四个算子把规律归机器、元素归 agent：
+ *
+ *   repeat  {n, dx, dy}     沿直线摆 n 份（栅栏、窗、台阶）
+ *   ring    {n, cx, cy}     绕圆心转 n 份（圆桌椅子、钟面、花瓣）
+ *   mirror  {axis, at}      对称补一份（画半只蝴蝶得整只）
+ *   scatter {n, in:{…}}     区域内播撒 n 份、带大小抖动（星空、草地、碎石）
+ *
+ * 每一份都用**自己的种子**重生成笔迹 —— 抖动各不相同，看起来是手画了 n 遍，
+ * 不是图章盖了 n 下。scatter 的随机也是种子确定的：同一次调用重放结果一致。
+ */
+
+import { UNIT, transformD } from './sketch-layout.js';
+
+/** 与 sketch-layout 同款确定性随机（那边的没导出，够小就地一份） */
+function rng(seedStr) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < seedStr.length; i += 1) { h ^= seedStr.charCodeAt(i); h = Math.imul(h, 0x01000193) >>> 0; }
+  let a = h >>> 0;
+  return () => {
+    a = (a + 0x6D2B79F5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** 把 {rect,d}（d 局部于 rect）过一个**绝对坐标**变换，返回重建包围盒后的 {rect,d} */
+function applyAbs(base, fn) {
+  let minX = Infinity; let minY = Infinity; let maxX = -Infinity; let maxY = -Infinity;
+  const dAbs = transformD(base.d, (p) => {
+    const q = fn({ x: base.rect.x + p.x, y: base.rect.y + p.y });
+    if (q.x < minX) minX = q.x; if (q.x > maxX) maxX = q.x;
+    if (q.y < minY) minY = q.y; if (q.y > maxY) maxY = q.y;
+    return q;
+  });
+  if (!Number.isFinite(minX)) return base;
+  const P = 6;   // 与全族同款 pad（抖动和线宽的呼吸位；不补的话镜像副本比本尊瘦一圈）
+  const d = transformD(dAbs, (p) => ({ x: p.x - minX + P, y: p.y - minY + P }));
+  return { rect: { x: Math.round(minX - P), y: Math.round(minY - P), w: Math.max(4, Math.round(maxX - minX + P * 2)), h: Math.max(4, Math.round(maxY - minY + P * 2)) }, d };
+}
+
+/**
+ * 展开一个形状的算子。
+ * @param s        入参形状（可能带 repeat/ring/mirror/scatter；坐标全是格）
+ * @param makeOne  (seedSuffix) => {rect, d}  重新生成一份本尊（各份各自的抖）
+ * @param key      形状名（副本叫 key-2, key-3…）
+ * @returns {Array<{key,rect,d}>} 或 { error }
+ */
+export function expandModifiers(s, makeOne, key) {
+  const mods = ['repeat', 'ring', 'mirror', 'scatter'].filter((k) => s[k]);
+  if (!mods.length) return [{ key, ...makeOne('') }];
+  if (mods.length > 1) return { error: `形状 ${key}：repeat/ring/mirror/scatter 一次只能挂一个` };
+  const out = [];
+  const push = (i, piece) => out.push({ key: i === 0 ? key : `${key}-${i + 1}`, ...piece });
+
+  if (s.repeat) {
+    const { n, dx = 0, dy = 0 } = s.repeat;
+    if (!dx && !dy) return { error: `形状 ${key}：repeat 要给步长 dx/dy（格）——步长 0 是 n 份叠在原地` };
+    for (let i = 0; i < n; i += 1) {
+      const b = makeOne(`:${i}`);
+      push(i, { rect: { ...b.rect, x: Math.round(b.rect.x + dx * UNIT * i), y: Math.round(b.rect.y + dy * UNIT * i) }, d: b.d });
+    }
+    return out;
+  }
+  if (s.ring) {
+    const { n, cx, cy, upright = false } = s.ring;
+    const C = { x: cx * UNIT, y: cy * UNIT };
+    for (let i = 0; i < n; i += 1) {
+      const th = (Math.PI * 2 * i) / n;
+      const cos = Math.cos(th); const sin = Math.sin(th);
+      const b = makeOne(`:${i}`);
+      if (i === 0) { push(i, b); continue; }
+      if (upright) {
+        // 不转身，只沿圆周换座（侧视图里有重力的东西：帐篷、篝火边的人）
+        const bc = { x: b.rect.x + b.rect.w / 2, y: b.rect.y + b.rect.h / 2 };
+        const nc = {
+          x: C.x + (bc.x - C.x) * cos - (bc.y - C.y) * sin,
+          y: C.y + (bc.x - C.x) * sin + (bc.y - C.y) * cos,
+        };
+        push(i, { rect: { ...b.rect, x: Math.round(nc.x - b.rect.w / 2), y: Math.round(nc.y - b.rect.h / 2) }, d: b.d });
+        continue;
+      }
+      push(i, applyAbs(b, (p) => ({
+        x: C.x + (p.x - C.x) * cos - (p.y - C.y) * sin,
+        y: C.y + (p.x - C.x) * sin + (p.y - C.y) * cos,
+      })));
+    }
+    return out;
+  }
+  if (s.mirror) {
+    const { axis, at } = s.mirror;
+    const ax = at * UNIT;
+    push(0, makeOne(''));
+    push(1, applyAbs(makeOne(':m'), (p) => (axis === 'x' ? { x: 2 * ax - p.x, y: p.y } : { x: p.x, y: 2 * ax - p.y })));
+    return out;
+  }
+  if (s.scatter) {
+    const { n } = s.scatter;
+    const zone = s.scatter.in;
+    const R = { x: zone.x * UNIT, y: zone.y * UNIT, w: zone.w * UNIT, h: zone.h * UNIT };
+    const rand = rng(`scatter:${key}:${n}`);
+    for (let i = 0; i < n; i += 1) {
+      const b = makeOne(`:${i}`);
+      const k = 0.7 + rand() * 0.45;                       // 大小抖动 0.7~1.15
+      const scaled = applyAbs(b, (p) => ({ x: b.rect.x + (p.x - b.rect.x) * k, y: b.rect.y + (p.y - b.rect.y) * k }));
+      const x = R.x + rand() * Math.max(1, R.w - scaled.rect.w);
+      const y = R.y + rand() * Math.max(1, R.h - scaled.rect.h);
+      push(i, { rect: { ...scaled.rect, x: Math.round(x), y: Math.round(y) }, d: scaled.d });
+    }
+    return out;
+  }
+  return [{ key, ...makeOne('') }];
+}

package/server/lib/sketch-hatch.js

@@ -0,0 +1,99 @@
+/**
+ * server/lib/sketch-hatch.js —— 排线填充（2026-08-30 画图能力线）
+ *
+ * 线稿世界里唯一体面的"上色"：45° 手排线。闭合轮廓 → 一组扫描线段（偶奇规则），
+ * 端点带一点抖 —— 像人一笔一笔排出来的，不是激光刻的。
+ *
+ * 只对**闭合轮廓**生效（Z 收尾的子路径）：往开放折线里灌填充没有定义良好的
+ * 内部，硬灌就是把问题藏起来 —— 调用方大声拒。
+ */
+
+const f1 = (n) => Math.round(n * 10) / 10;
+
+function rng(seedStr) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < seedStr.length; i += 1) { h ^= seedStr.charCodeAt(i); h = Math.imul(h, 0x01000193) >>> 0; }
+  let a = h >>> 0;
+  return () => {
+    a = (a + 0x6D2B79F5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** 大写绝对 M/L/Q/C/Z → 多边形组（曲线采样 8 段；只收 Z 闭合的子路径） */
+export function flattenClosed(d) {
+  const tokens = String(d).match(/[MLQCZ]|-?\d*\.?\d+(?:[eE][-+]?\d+)?/g) || [];
+  const polys = [];
+  let pts = []; let i = 0; let closedAny = false;
+  const num = () => Number(tokens[i++]);
+  const flush = (closed) => { if (closed && pts.length >= 3) { polys.push(pts); closedAny = true; } pts = []; };
+  while (i < tokens.length) {
+    const t = tokens[i++];
+    if (t === 'M') { flush(false); pts = [{ x: num(), y: num() }]; continue; }
+    if (t === 'L') { pts.push({ x: num(), y: num() }); continue; }
+    if (t === 'Q' || t === 'C') {
+      const cps = t === 'Q' ? [{ x: num(), y: num() }] : [{ x: num(), y: num() }, { x: num(), y: num() }];
+      const end = { x: num(), y: num() };
+      const a = pts[pts.length - 1] || end;
+      for (let k = 1; k <= 8; k += 1) {
+        const u = k / 8;
+        let p;
+        if (t === 'Q') {
+          const v = 1 - u;
+          p = { x: v * v * a.x + 2 * v * u * cps[0].x + u * u * end.x, y: v * v * a.y + 2 * v * u * cps[0].y + u * u * end.y };
+        } else {
+          const v = 1 - u;
+          p = {
+            x: v ** 3 * a.x + 3 * v * v * u * cps[0].x + 3 * v * u * u * cps[1].x + u ** 3 * end.x,
+            y: v ** 3 * a.y + 3 * v * v * u * cps[0].y + 3 * v * u * u * cps[1].y + u ** 3 * end.y,
+          };
+        }
+        pts.push(p);
+      }
+      continue;
+    }
+    if (t === 'Z') { flush(true); continue; }
+  }
+  flush(false);
+  return { polys, closedAny };
+}
+
+/**
+ * 多边形组 → 45° 排线 d。偶奇规则（洞是真洞：月牙的内弧不会被排穿）。
+ * @returns {string} 空串 = 没有可填的面积
+ */
+export function hatchD(polys, seed = 'hatch', { spacing = 11, angle = Math.PI / 4 } = {}) {
+  if (!polys?.length) return '';
+  const cos = Math.cos(-angle); const sin = Math.sin(-angle);
+  const rot = polys.map((p) => p.map(({ x, y }) => ({ x: x * cos - y * sin, y: x * sin + y * cos })));
+  let minY = Infinity; let maxY = -Infinity;
+  for (const p of rot) for (const q of p) { if (q.y < minY) minY = q.y; if (q.y > maxY) maxY = q.y; }
+  if (!Number.isFinite(minY)) return '';
+  const rand = rng(seed);
+  const back = (x, y) => ({ x: x * Math.cos(angle) - y * Math.sin(angle), y: x * Math.sin(angle) + y * Math.cos(angle) });
+  const segs = [];
+  for (let y = minY + spacing * 0.6; y < maxY; y += spacing) {
+    const xs = [];
+    for (const p of rot) {
+      for (let k = 0; k < p.length; k += 1) {
+        const a = p[k]; const b = p[(k + 1) % p.length];
+        if ((a.y <= y && b.y > y) || (b.y <= y && a.y > y)) {
+          xs.push(a.x + ((y - a.y) / (b.y - a.y)) * (b.x - a.x));
+        }
+      }
+    }
+    xs.sort((m, n) => m - n);
+    for (let k = 0; k + 1 < xs.length; k += 2) {
+      if (xs[k + 1] - xs[k] < 3) continue;                     // 太窄的缝不排
+      const inset = 1.5;                                       // 别顶到轮廓线
+      const j = () => (rand() * 2 - 1) * 0.9;
+      const a = back(xs[k] + inset + j(), y + j());
+      const b = back(xs[k + 1] - inset + j(), y + j());
+      segs.push(`M ${f1(a.x)} ${f1(a.y)} L ${f1(b.x)} ${f1(b.y)}`);
+    }
+  }
+  return segs.join(' ');
+}