weaver-work-cli 0.1.29 → 0.1.31

package/dist/shortcuts/meeting/qr/encoder.js

@@ -0,0 +1,427 @@
+/**
+ * 零依赖 QR Code 编码器（字节模式 / 版本 1-40 / 纠错等级 L-M-Q-H / 8 种掩码）。
+ *
+ * 为什么自己写：CLI 是企业内网离线工具，`npm install -g` 走内部私服，多引一个第三方包
+ * （qrcode → pngjs/yargs/dijkstrajs …）就多一分装不上/装错版本的风险。二维码算法本身是
+ * 定死的有限状态机，自己实现把依赖成本降到 0。
+ *
+ * 编码链路（与 ISO/IEC 18004 一致，实现结构参考 nayuki qrcodegen 的公开算法）：
+ *   文本 → UTF-8 字节 → 选版本（容纳 4bit 模式 + 计数字段 + 数据 + 终止符）
+ *   → 数据码字 → Reed-Solomon 分块纠错 → 交织 → 功能图形（定位/定标/时序/格式/版本）
+ *   → 之字形铺设 → 掩码 + 罚分择优 → 布尔矩阵
+ *
+ * 只做字节模式：中文/URL/JSON 走 UTF-8 字节，容量与通用扫码器完全兼容。
+ * 不做：汉字模式（GB2312 编码）、ECI、结构化追加。
+ */
+/** ECC_CODEWORDS_PER_BLOCK[ecc][version]（索引 0 占位，版本 1-40）。 */
+const ECC_CODEWORDS_PER_BLOCK = {
+    L: [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    M: [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+    Q: [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    H: [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+};
+/** NUM_ECC_BLOCKS[ecc][version]（索引 0 占位，版本 1-40）。 */
+const NUM_ECC_BLOCKS = {
+    L: [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+    M: [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+    Q: [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+    H: [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],
+};
+/** 格式信息里纠错等级的编码。 */
+const ECC_FORMAT_BITS = { L: 1, M: 0, Q: 3, H: 2 };
+const MIN_VERSION = 1;
+const MAX_VERSION = 40;
+function getBit(value, index) {
+    return ((value >>> index) & 1) !== 0;
+}
+/** 某个版本的原始数据模块数（比特）；减去功能图形与格式/版本信息占位。 */
+function getNumRawDataModules(version) {
+    let result = (16 * version + 128) * version + 64;
+    if (version >= 2) {
+        const numAlign = Math.floor(version / 7) + 2;
+        result -= (25 * numAlign - 10) * numAlign - 55;
+        if (version >= 7)
+            result -= 36;
+    }
+    return result;
+}
+function getNumDataCodewords(version, ecc) {
+    return Math.floor(getNumRawDataModules(version) / 8) - ECC_CODEWORDS_PER_BLOCK[ecc][version] * NUM_ECC_BLOCKS[ecc][version];
+}
+/** 字节模式的字符计数位数：版本 1-9 为 8 位，10-40 为 16 位。 */
+function getCharCountBits(version) {
+    return version <= 9 ? 8 : 16;
+}
+/** GF(2^8) 乘法，本原多项式 0x11D。 */
+function gfMultiply(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z & 0xff;
+}
+/** 生成多项式 ∏(x - α^i)，系数按高次到低次（不含首项 1）。 */
+function rsGeneratorPoly(degree) {
+    const result = new Array(degree).fill(0);
+    result[degree - 1] = 1;
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        for (let j = 0; j < degree; j++) {
+            result[j] = gfMultiply(result[j], root);
+            if (j + 1 < degree)
+                result[j] ^= result[j + 1];
+        }
+        root = gfMultiply(root, 0x02);
+    }
+    return result;
+}
+/** 计算一段数据码字的纠错码字（多项式除法取余）。 */
+function rsComputeRemainder(data, degree) {
+    const generator = rsGeneratorPoly(degree);
+    const remainder = new Array(degree).fill(0);
+    for (const byte of data) {
+        const factor = byte ^ remainder.shift();
+        remainder.push(0);
+        for (let i = 0; i < degree; i++) {
+            remainder[i] ^= gfMultiply(generator[i], factor);
+        }
+    }
+    return remainder;
+}
+function getAlignmentPatternPositions(version) {
+    if (version === 1)
+        return [];
+    const size = version * 4 + 17;
+    const numAlign = Math.floor(version / 7) + 2;
+    const step = Math.floor((version * 8 + numAlign * 3 + 5) / (numAlign * 4 - 4)) * 2;
+    const result = [6];
+    for (let pos = size - 7; result.length < numAlign; pos -= step) {
+        result.splice(1, 0, pos);
+    }
+    return result;
+}
+function maskPredicate(mask, x, y) {
+    switch (mask) {
+        case 0: return (x + y) % 2 === 0;
+        case 1: return y % 2 === 0;
+        case 2: return x % 3 === 0;
+        case 3: return (x + y) % 3 === 0;
+        case 4: return (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+        case 5: return ((x * y) % 2) + ((x * y) % 3) === 0;
+        case 6: return (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
+        case 7: return (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
+        default: throw new Error(`invalid mask: ${mask}`);
+    }
+}
+/** 掩码罚分（N1 连串/N2 色块/N3 类定位图形/N4 深浅比）。 */
+function getPenaltyScore(modules, size) {
+    let result = 0;
+    const dark = (x, y) => modules[y][x];
+    // N1：横向/纵向连续同色 >= 5
+    for (let y = 0; y < size; y++) {
+        let runColor = dark(0, y);
+        let runLength = 1;
+        for (let x = 1; x < size; x++) {
+            if (dark(x, y) === runColor) {
+                runLength++;
+            }
+            else {
+                if (runLength >= 5)
+                    result += 3 + (runLength - 5);
+                runColor = dark(x, y);
+                runLength = 1;
+            }
+        }
+        if (runLength >= 5)
+            result += 3 + (runLength - 5);
+    }
+    for (let x = 0; x < size; x++) {
+        let runColor = dark(x, 0);
+        let runLength = 1;
+        for (let y = 1; y < size; y++) {
+            if (dark(x, y) === runColor) {
+                runLength++;
+            }
+            else {
+                if (runLength >= 5)
+                    result += 3 + (runLength - 5);
+                runColor = dark(x, y);
+                runLength = 1;
+            }
+        }
+        if (runLength >= 5)
+            result += 3 + (runLength - 5);
+    }
+    // N2：2x2 同色块
+    for (let y = 0; y < size - 1; y++) {
+        for (let x = 0; x < size - 1; x++) {
+            const color = dark(x, y);
+            if (color === dark(x + 1, y) && color === dark(x, y + 1) && color === dark(x + 1, y + 1)) {
+                result += 3;
+            }
+        }
+    }
+    // N3：1:1:3:1:1 且一侧有 4 个浅色的类定位图形（越界一律当浅色，避免 start-4 越界）
+    const safeDark = (x, y) => (x < 0 || y < 0 || x >= size || y >= size ? false : modules[y][x]);
+    const finderLike = (get, start) => {
+        const pattern = [true, false, true, true, true, false, true];
+        for (let i = 0; i < 7; i++) {
+            if (get(start + i) !== pattern[i])
+                return false;
+        }
+        let before = true;
+        for (let i = 1; i <= 4; i++)
+            if (get(start - i) !== false)
+                before = false;
+        let after = true;
+        for (let i = 7; i < 11; i++)
+            if (get(start + i) !== false)
+                after = false;
+        return before || after;
+    };
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x + 10 < size; x++) {
+            if (finderLike((i) => safeDark(i, y), x))
+                result += 40;
+        }
+    }
+    for (let x = 0; x < size; x++) {
+        for (let y = 0; y + 10 < size; y++) {
+            if (finderLike((i) => safeDark(x, i), y))
+                result += 40;
+        }
+    }
+    // N4：深色比例偏离 50%
+    let darkCount = 0;
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++)
+            if (dark(x, y))
+                darkCount++;
+    }
+    const total = size * size;
+    const k = Math.ceil(Math.abs(darkCount * 20 - total * 10) / total) - 1;
+    result += Math.max(0, k) * 10;
+    return result;
+}
+function buildFunctionPatterns(version) {
+    const size = version * 4 + 17;
+    const modules = Array.from({ length: size }, () => new Array(size).fill(false));
+    const isFunction = Array.from({ length: size }, () => new Array(size).fill(false));
+    const setFunction = (x, y, isDark) => {
+        if (x < 0 || y < 0 || x >= size || y >= size)
+            return;
+        modules[y][x] = isDark;
+        isFunction[y][x] = true;
+    };
+    // 时序图形
+    for (let i = 0; i < size; i++) {
+        setFunction(6, i, i % 2 === 0);
+        setFunction(i, 6, i % 2 === 0);
+    }
+    // 三个定位图形（含分隔符）
+    const drawFinder = (cx, cy) => {
+        for (let dy = -4; dy <= 4; dy++) {
+            for (let dx = -4; dx <= 4; dx++) {
+                const dist = Math.max(Math.abs(dx), Math.abs(dy));
+                setFunction(cx + dx, cy + dy, dist !== 2 && dist !== 4);
+            }
+        }
+    };
+    drawFinder(3, 3);
+    drawFinder(size - 4, 3);
+    drawFinder(3, size - 4);
+    // 定标图形
+    const alignPositions = getAlignmentPatternPositions(version);
+    const numAlign = alignPositions.length;
+    for (let i = 0; i < numAlign; i++) {
+        for (let j = 0; j < numAlign; j++) {
+            const isCorner = (i === 0 && j === 0) || (i === 0 && j === numAlign - 1) || (i === numAlign - 1 && j === 0);
+            if (isCorner)
+                continue;
+            const cx = alignPositions[i];
+            const cy = alignPositions[j];
+            for (let dy = -2; dy <= 2; dy++) {
+                for (let dx = -2; dx <= 2; dx++) {
+                    setFunction(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+                }
+            }
+        }
+    }
+    // 先用掩码 0 写一份占位格式信息（真正格式信息在掩码确定后重写）
+    drawFormatBits(modules, isFunction, size, version, 'L', 0);
+    // 版本信息（版本 >= 7）
+    if (version >= 7) {
+        let rem = version;
+        for (let i = 0; i < 12; i++)
+            rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
+        const bits = (version << 12) | rem;
+        for (let i = 0; i < 18; i++) {
+            const bit = getBit(bits, i);
+            const a = size - 11 + (i % 3);
+            const b = Math.floor(i / 3);
+            setFunction(a, b, bit);
+            setFunction(b, a, bit);
+        }
+    }
+    return { size, modules, isFunction };
+}
+function drawFormatBits(modules, isFunction, size, version, ecc, mask) {
+    void version;
+    const data = (ECC_FORMAT_BITS[ecc] << 3) | mask;
+    let rem = data;
+    for (let i = 0; i < 10; i++)
+        rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+    const bits = ((data << 10) | rem) ^ 0x5412;
+    const setFunction = (x, y, isDark) => {
+        modules[y][x] = isDark;
+        isFunction[y][x] = true;
+    };
+    // 左上角副本
+    for (let i = 0; i <= 5; i++)
+        setFunction(8, i, getBit(bits, i));
+    setFunction(8, 7, getBit(bits, 6));
+    setFunction(8, 8, getBit(bits, 7));
+    setFunction(7, 8, getBit(bits, 8));
+    for (let i = 9; i < 15; i++)
+        setFunction(14 - i, 8, getBit(bits, i));
+    // 右上 + 左下副本
+    for (let i = 0; i < 8; i++)
+        setFunction(size - 1 - i, 8, getBit(bits, i));
+    for (let i = 8; i < 15; i++)
+        setFunction(8, size - 15 + i, getBit(bits, i));
+    // 固定深色模块
+    setFunction(8, size - 8, true);
+}
+function drawCodewords(matrix, codewords) {
+    const { size, modules, isFunction } = matrix;
+    let index = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5;
+        for (let vert = 0; vert < size; vert++) {
+            for (let j = 0; j < 2; j++) {
+                const x = right - j;
+                const upward = ((right + 1) & 2) === 0;
+                const y = upward ? size - 1 - vert : vert;
+                if (!isFunction[y][x] && index < codewords.length * 8) {
+                    modules[y][x] = getBit(codewords[index >>> 3], 7 - (index & 7));
+                    index++;
+                }
+            }
+        }
+    }
+}
+function applyMask(matrix, mask) {
+    const { size, modules, isFunction } = matrix;
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            if (isFunction[y][x])
+                continue;
+            if (maskPredicate(mask, x, y))
+                modules[y][x] = !modules[y][x];
+        }
+    }
+}
+function buildCodewords(bytes, version, ecc) {
+    const capacityBits = getNumDataCodewords(version, ecc) * 8;
+    const bits = [];
+    const appendBits = (value, length) => {
+        for (let i = length - 1; i >= 0; i--)
+            bits.push((value >>> i) & 1);
+    };
+    appendBits(0b0100, 4);
+    appendBits(bytes.length, getCharCountBits(version));
+    for (const byte of bytes)
+        appendBits(byte, 8);
+    appendBits(0, Math.min(4, capacityBits - bits.length));
+    appendBits(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xec; bits.length < capacityBits; pad ^= 0xec ^ 0x11)
+        appendBits(pad, 8);
+    const dataCodewords = new Array(bits.length / 8).fill(0);
+    bits.forEach((bit, i) => {
+        dataCodewords[i >>> 3] |= bit << (7 - (i & 7));
+    });
+    const numBlocks = NUM_ECC_BLOCKS[ecc][version];
+    const blockEccLen = ECC_CODEWORDS_PER_BLOCK[ecc][version];
+    const rawCodewords = Math.floor(getNumRawDataModules(version) / 8);
+    const numShortBlocks = numBlocks - (rawCodewords % numBlocks);
+    const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+    const blocks = [];
+    let offset = 0;
+    for (let i = 0; i < numBlocks; i++) {
+        const dataLen = shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1);
+        const data = dataCodewords.slice(offset, offset + dataLen);
+        offset += dataLen;
+        const block = data.slice();
+        const remainder = rsComputeRemainder(data, blockEccLen);
+        // 短块补一个占位 0（夹在数据与纠错码字之间），交织时跳过，保证各块等长
+        if (i < numShortBlocks)
+            block.push(0);
+        block.push(...remainder);
+        blocks.push(block);
+    }
+    const result = [];
+    for (let i = 0; i < blocks[0].length; i++) {
+        for (let j = 0; j < blocks.length; j++) {
+            if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) {
+                result.push(blocks[j][i]);
+            }
+        }
+    }
+    return result;
+}
+/** 把文本编码成二维码布尔矩阵。 */
+export function encodeQrText(text, options = {}) {
+    if (typeof text !== 'string' || text.length === 0) {
+        throw new Error('text_required: 二维码内容不能为空');
+    }
+    if (text.length > 4000) {
+        throw new Error('text_too_long: 二维码内容超长（单码上限约 2953 字节，UTF-8 中文约 980 字）');
+    }
+    const ecc = options.ecc ?? 'M';
+    if (!['L', 'M', 'Q', 'H'].includes(ecc)) {
+        throw new Error(`ecc_invalid: 纠错等级只能是 L/M/Q/H，收到 ${String(options.ecc)}`);
+    }
+    const bytes = Array.from(Buffer.from(text, 'utf8'));
+    const minVersion = Math.max(MIN_VERSION, options.minVersion ?? MIN_VERSION);
+    const maxVersion = Math.min(MAX_VERSION, options.maxVersion ?? MAX_VERSION);
+    let version = -1;
+    for (let v = minVersion; v <= maxVersion; v++) {
+        const capacityBits = getNumDataCodewords(v, ecc) * 8;
+        const neededBits = 4 + getCharCountBits(v) + bytes.length * 8;
+        if (neededBits <= capacityBits) {
+            version = v;
+            break;
+        }
+    }
+    if (version < 0) {
+        throw new Error(`capacity_exceeded: ${bytes.length} 字节超出 ECM=${ecc} 的最大容量（版本 ${maxVersion}）`);
+    }
+    const codewords = buildCodewords(bytes, version, ecc);
+    const candidateMasks = options.mask === undefined
+        ? [0, 1, 2, 3, 4, 5, 6, 7]
+        : [options.mask];
+    if (options.mask !== undefined && (options.mask < 0 || options.mask > 7)) {
+        throw new Error(`mask_invalid: 掩码只能是 0-7，收到 ${String(options.mask)}`);
+    }
+    let best = null;
+    for (const mask of candidateMasks) {
+        const matrix = buildFunctionPatterns(version);
+        drawCodewords(matrix, codewords);
+        applyMask(matrix, mask);
+        drawFormatBits(matrix.modules, matrix.isFunction, matrix.size, version, ecc, mask);
+        const score = getPenaltyScore(matrix.modules, matrix.size);
+        if (!best || score < best.score) {
+            best = { mask, modules: matrix.modules, score };
+        }
+    }
+    return {
+        size: version * 4 + 17,
+        version,
+        ecc,
+        mask: best.mask,
+        modules: best.modules,
+        byteLength: bytes.length,
+    };
+}

package/dist/shortcuts/meeting/qr/render.js

@@ -0,0 +1,103 @@
+/**
+ * 二维码矩阵 → 图片渲染（PNG / SVG），零依赖。
+ *
+ * PNG 用最小实现：8bit 灰度、filter 0、zlib deflate（node:zlib 内置）。
+ * 不出彩色/带 Logo 版本——扫码器对高对比度纯黑白最稳，参会码要能被门禁读头秒读。
+ */
+import { deflateSync } from 'node:zlib';
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const typeBytes = Buffer.from(type, 'ascii');
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length, 0);
+    const body = Buffer.concat([typeBytes, Buffer.from(data)]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(body), 0);
+    return Buffer.concat([length, body, crc]);
+}
+/** 把矩阵渲染成 PNG（8bit 灰度，深色=0，浅色=255）。 */
+export function renderQrPng(matrix, options = {}) {
+    const scale = Math.max(1, Math.floor(options.scale ?? 8));
+    const margin = Math.max(0, Math.floor(options.margin ?? 4));
+    const modulesPerSide = matrix.size + margin * 2;
+    const pixelSize = modulesPerSide * scale;
+    const rowBytes = pixelSize;
+    const raw = Buffer.alloc((rowBytes + 1) * pixelSize);
+    let cursor = 0;
+    for (let py = 0; py < pixelSize; py++) {
+        raw[cursor++] = 0; // filter type: none
+        const my = Math.floor(py / scale) - margin;
+        for (let px = 0; px < pixelSize; px++) {
+            const mx = Math.floor(px / scale) - margin;
+            const isDark = my >= 0 && mx >= 0 && my < matrix.size && mx < matrix.size
+                ? matrix.modules[my][mx]
+                : false;
+            raw[cursor++] = isDark ? 0 : 255;
+        }
+    }
+    const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(pixelSize, 0);
+    ihdr.writeUInt32BE(pixelSize, 4);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 0; // color type: grayscale
+    ihdr[10] = 0; // compression
+    ihdr[11] = 0; // filter
+    ihdr[12] = 0; // interlace
+    return Buffer.concat([
+        signature,
+        chunk('IHDR', ihdr),
+        chunk('IDAT', deflateSync(raw, { level: 9 })),
+        chunk('IEND', new Uint8Array(0)),
+    ]);
+}
+/** 把矩阵渲染成 SVG（矢量，便于印刷/嵌入文档）。 */
+export function renderQrSvg(matrix, options = {}) {
+    const scale = Math.max(1, Math.floor(options.scale ?? 8));
+    const margin = Math.max(0, Math.floor(options.margin ?? 4));
+    const modulesPerSide = matrix.size + margin * 2;
+    const pixelSize = modulesPerSide * scale;
+    const rects = [];
+    for (let y = 0; y < matrix.size; y++) {
+        let x = 0;
+        while (x < matrix.size) {
+            if (!matrix.modules[y][x]) {
+                x++;
+                continue;
+            }
+            let runEnd = x;
+            while (runEnd < matrix.size && matrix.modules[y][runEnd])
+                runEnd++;
+            const width = (runEnd - x) * scale;
+            rects.push(`<rect x="${(x + margin) * scale}" y="${(y + margin) * scale}" width="${width}" height="${scale}"/>`);
+            x = runEnd;
+        }
+    }
+    return [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${pixelSize}" height="${pixelSize}" viewBox="0 0 ${pixelSize} ${pixelSize}" shape-rendering="crispEdges">`,
+        `<rect width="100%" height="100%" fill="#ffffff"/>`,
+        `<g fill="#000000">`,
+        ...rects,
+        `</g>`,
+        `</svg>`,
+        '',
+    ].join('\n');
+}

package/dist/shortcuts/workflow/operations/form.js

@@ -1640,8 +1640,14 @@ function extractWorkflowMemorySection(promptText, workflowId) {
  * best-effort：读不到（没开通记忆 / 404 / 接口故障）一律返回空串 —— 对模型而言
  * 「没有记忆」和「读取失败」的处理完全一样（按新用户处理、不要重试），不需要再分档。
  * 绝不阻断表单载入（与 `workflow.memoryPrompt` 同口径）。
+ *
+ * ★ 2026-10-28 用户裁定：**小e 环境不读记忆** —— 这一档的调用方（`createRequestDirect`）不再下发提示词
+ * 属性，`createForm` 侧同样不消费，所以这条请求纯属白花一趟（小e 真机 200–400 ms）。返回空串 ⇒
+ * 两个命令都不会出现 `workflowMemory` / `userMemory`。非小e 行为不变。
  */
 async function fetchWorkflowMemory(workflowId, env) {
+    if (hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.()))
+        return '';
     try {
         const response = await env.host.workflowRequest({
             method: 'POST',
@@ -5542,11 +5548,13 @@ function summarizeApiSpans(spans) {
  *    这条命令的 `risk` 因此从 `high-risk-write` 降为 `read`。
  * 3. **只返回填参原料**：`fields`（含 `initialValue`）、`historyRequestData`、`userMemory`
  *    （＝该工作流的记忆 `workflowMemory`），外加 `status` / `workflow` 两个元信息。
+ *    **小e 档不返回 `userMemory`**（2026-10-28 用户裁定）：这一档不读记忆（见 `fetchWorkflowMemory`），
+ *    提示词属性也没有下游，所以整个键都不出现（不是空串）。
  * 4. **不返回系统字段**：`systemFields` / `systemFieldWarning` 整块不出现（标题/紧急程度/密级的默认值
  *    与选项清单都不给）。
  * 5. **输出降级**（按 20,000 **字符**，与 `createForm` 同一个宿主口径）：
- *    全量超线 ⇒ `historyRequestData` 留空数组（键还在）；仍超 ⇒ `userMemory` 留空串（键还在）；
- *    **`fields` 自己也超线时不再裁**（宁大不丢）—— 它是唯一不可省的，砍了这条命令就没有意义。
+ *    全量超线 ⇒ `historyRequestData` 留空数组（键还在）；仍超 ⇒ `userMemory` 留空串（键还在；小e 档没有
+ *    这个键，不补）；**`fields` 自己也超线时不再裁**（宁大不丢）—— 它是唯一不可省的，砍了这条命令就没有意义。
  *
  * ## 耗时
  * 与 `createForm` 完全同口径，全部收在 `timing` 一个桶里：`durationMs`（整条命令）/
@@ -5573,12 +5581,15 @@ async function commandCreateRequestDirect(args, env) {
     // 句柄类（contextId/requestId/requestName）、`form`、`continuation`、`requiredInfoWarning` 全部不出
     // —— 本命令不发起，这些字段没有下游（2026-10-22 用户裁定）。`contextId` 仍在上面的守卫里用于
     // 判断"表单到底载入成功没有"，只是不再交出去。
+    //
+    // 小e 档不返回 `userMemory`（2026-10-28 用户裁定）：这一档本来就不读记忆，提示词属性没有下游。
+    const isXiaoE = hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
     const data = {
         status: payload.status,
         workflow: payload.workflow,
         fields: payload.fields,
         historyRequestData: payload.historyRequestData,
-        userMemory: String(payload.workflowMemory ?? ''),
+        ...(isXiaoE ? {} : { userMemory: String(payload.workflowMemory ?? '') }),
     };
     // 判线必须把「稍后才求得出」的耗时键先按位数占住（与 `createForm` 同一个哨兵口径，宁可高估），
     // 否则边界上的表单会被判成"没超"、然后在宿主那儿被真截断。
@@ -5592,9 +5603,10 @@ async function commandCreateRequestDirect(args, env) {
     };
     const overLine = () => finalStdoutChars({ ...data, ...reserve }, 'workflow.createRequestDirect') > CREATE_FORM_STDOUT_SAFE_CHARS;
     // 两级降级：先砍历史（留空 key）→ 再砍记忆（留空 key）。`fields` 不参与裁剪。
+    // 小e 档没有 `userMemory` 这个键，第二级跳过（不能借"写空串"把它重新加回来）。
     if (overLine()) {
         data.historyRequestData = [];
-        if (overLine())
+        if ('userMemory' in data && overLine())
             data.userMemory = '';
     }
     return workflowSuccess('workflow.createRequestDirect', {
@@ -6703,7 +6715,7 @@ const workflowCreateRequestDirect = {
     resource: 'workflow',
     method: 'createRequestDirect',
     action: 'workflow.createRequestDirect',
-    summary: '取数（不发起、不调智能体、不写库）：载入发起表单后直接返回 fields（含 initialValue）、historyRequestData、userMemory，供你拼好 data 后再调 createRequest。不返回系统字段（标题/紧急程度/密级的默认值与选项），也不返回句柄、form、continuation。输出超过 2 万字符时依次降级：先让 historyRequestData 变成空数组，仍超再让 userMemory 变成空串（键都保留）。耗时全部收在 timing 一个键里：{durationMs, apiDurations, apiSlowest, authMs}',
+    summary: '取数（不发起、不调智能体、不写库）：载入发起表单后直接返回 fields（含 initialValue）、historyRequestData、userMemory，供你拼好 data 后再调 createRequest（小e 环境不读记忆，也不返回 userMemory）。不返回系统字段（标题/紧急程度/密级的默认值与选项），也不返回句柄、form、continuation。输出超过 2 万字符时依次降级：先让 historyRequestData 变成空数组，仍超再让 userMemory 变成空串（键都保留）。耗时全部收在 timing 一个键里：{durationMs, apiDurations, apiSlowest, authMs}',
     capability: 'read',
     risk: 'read',
     requiresConfirmation: false,