@dsh-libing/knowledge-base 0.1.0 → 0.1.3

package/lib/contract.d.ts

@@ -119,8 +119,12 @@ export declare const publicJobSchema: z.ZodObject<{
         modelTimeoutMs: z.ZodDefault<z.ZodNumber>;
         modelAttempts: z.ZodDefault<z.ZodNumber>;
         visionConcurrency: z.ZodDefault<z.ZodNumber>;
+        maxModelCallsLimit: z.ZodDefault<z.ZodNumber>;
+        maxModelTokensLimit: z.ZodDefault<z.ZodNumber>;
+        uploadRetentionDays: z.ZodDefault<z.ZodNumber>;
         maxModelCalls: z.ZodDefault<z.ZodNumber>;
         maxModelTokens: z.ZodDefault<z.ZodNumber>;
+        imageTimeoutMs: z.ZodDefault<z.ZodNumber>;
         visionMaxEdge: z.ZodDefault<z.ZodNumber>;
         visionTileSize: z.ZodDefault<z.ZodNumber>;
         visionMaxTiles: z.ZodDefault<z.ZodNumber>;
@@ -189,6 +193,13 @@ export declare const publicJobSchema: z.ZodObject<{
             chunkId: z.ZodString;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    pendingCalls: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    legacyUsageCount: z.ZodDefault<z.ZodNumber>;
+    legacyCallCount: z.ZodDefault<z.ZodNumber>;
+    reportSummary: z.ZodOptional<z.ZodObject<{
+        issues: z.ZodNumber;
+        blocking: z.ZodNumber;
+    }, z.core.$strip>>;
     failures: z.ZodArray<z.ZodObject<{
         at: z.ZodString;
         stage: z.ZodEnum<{
@@ -437,8 +448,12 @@ export declare const stateSchema: z.ZodObject<{
             modelTimeoutMs: z.ZodDefault<z.ZodNumber>;
             modelAttempts: z.ZodDefault<z.ZodNumber>;
             visionConcurrency: z.ZodDefault<z.ZodNumber>;
+            maxModelCallsLimit: z.ZodDefault<z.ZodNumber>;
+            maxModelTokensLimit: z.ZodDefault<z.ZodNumber>;
+            uploadRetentionDays: z.ZodDefault<z.ZodNumber>;
             maxModelCalls: z.ZodDefault<z.ZodNumber>;
             maxModelTokens: z.ZodDefault<z.ZodNumber>;
+            imageTimeoutMs: z.ZodDefault<z.ZodNumber>;
             visionMaxEdge: z.ZodDefault<z.ZodNumber>;
             visionTileSize: z.ZodDefault<z.ZodNumber>;
             visionMaxTiles: z.ZodDefault<z.ZodNumber>;
@@ -507,6 +522,13 @@ export declare const stateSchema: z.ZodObject<{
                 chunkId: z.ZodString;
             }, z.core.$strip>>;
         }, z.core.$strip>;
+        pendingCalls: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        legacyUsageCount: z.ZodDefault<z.ZodNumber>;
+        legacyCallCount: z.ZodDefault<z.ZodNumber>;
+        reportSummary: z.ZodOptional<z.ZodObject<{
+            issues: z.ZodNumber;
+            blocking: z.ZodNumber;
+        }, z.core.$strip>>;
         failures: z.ZodArray<z.ZodObject<{
             at: z.ZodString;
             stage: z.ZodEnum<{
@@ -557,6 +579,9 @@ export declare const stateSchema: z.ZodObject<{
         outputPath: z.ZodNullable<z.ZodString>;
         reused: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    jobTotal: z.ZodDefault<z.ZodNumber>;
+    jobOffset: z.ZodDefault<z.ZodNumber>;
+    activeJobs: z.ZodDefault<z.ZodNumber>;
     dataRoot: z.ZodString;
     config: z.ZodObject<{
         chunkTargetChars: z.ZodNumber;
@@ -669,8 +694,8 @@ export declare const treeDocumentSchema: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     chunks: z.ZodArray<z.ZodObject<{
-        summary: z.ZodDefault<z.ZodString>;
         path: z.ZodString;
+        summary: z.ZodDefault<z.ZodString>;
         title: z.ZodString;
         headingPath: z.ZodArray<z.ZodString>;
         oversizedReason: z.ZodOptional<z.ZodString>;
@@ -972,8 +997,8 @@ export declare const treeSchema: z.ZodObject<{
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
         chunks: z.ZodArray<z.ZodObject<{
-            summary: z.ZodDefault<z.ZodString>;
             path: z.ZodString;
+            summary: z.ZodDefault<z.ZodString>;
             title: z.ZodString;
             headingPath: z.ZodArray<z.ZodString>;
             oversizedReason: z.ZodOptional<z.ZodString>;
@@ -1195,3 +1220,9 @@ export declare const uploadResultSchema: z.ZodObject<{
     filename: z.ZodString;
     bytes: z.ZodNumber;
 }, z.core.$strip>;
+export declare const jobUsagePageSchema: z.ZodObject<{
+    records: z.ZodArray<z.ZodJSONSchema>;
+    offset: z.ZodNumber;
+    total: z.ZodNumber;
+    next: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;

package/lib/contract.js

@@ -4,7 +4,7 @@ import { jobSchema, registrySchema, librarySchema, publishedDocumentSchema, repo
 export const publicJobSchema = jobSchema.omit({ schema: true, overlays: true }).extend({ outputPath: z.string().nullable(), reused: z.boolean().optional() });
 export const locationSchema = z.object({ kbPath: z.string(), revision: z.string().nullable(), wikiPath: z.string().nullable(), indexPath: z.string().nullable() });
 export const libraryViewSchema = librarySchema.extend({ location: locationSchema, summary: z.object({ revision: z.string().nullable(), documentCount: z.number(), chunkCount: z.number(), coverageIncomplete: z.boolean() }) });
-export const stateSchema = z.object({ hostVersion: z.string(), kbs: z.array(libraryViewSchema), deletedKbs: z.array(librarySchema), activities: registrySchema.shape.activities, jobs: z.array(publicJobSchema), dataRoot: z.string(), config: z.object({ chunkTargetChars: z.number(), visionProvider: z.string(), visionModel: z.string(), maxInputBytes: z.number() }) });
+export const stateSchema = z.object({ hostVersion: z.string(), kbs: z.array(libraryViewSchema), deletedKbs: z.array(librarySchema), activities: registrySchema.shape.activities, jobs: z.array(publicJobSchema), jobTotal: z.number().int().nonnegative().default(0), jobOffset: z.number().int().nonnegative().default(0), activeJobs: z.number().int().nonnegative().default(0), dataRoot: z.string(), config: z.object({ chunkTargetChars: z.number(), visionProvider: z.string(), visionModel: z.string(), maxInputBytes: z.number() }) });
 export const treeDocumentSchema = publishedDocumentSchema.extend({ chunks: z.array(publishedDocumentSchema.shape.chunks.element.omit({ segments: true, anchors: true })), figures: z.array(publishedDocumentSchema.shape.figures.element.extend({ expectedHash: z.string().optional() })) });
 export const treeSchema = z.object({ kbId: z.string(), revision: z.string(), location: locationSchema.optional(), previewJobId: z.string().optional(), coverageIncomplete: z.boolean(), report: reportSchema, documents: z.array(treeDocumentSchema) });
 export const readSchema = z.object({ kbId: z.string(), chunkId: z.string(), revision: z.string(), text: z.string(), complete: z.boolean(), truncated: z.boolean().optional(), previewJobId: z.string().optional(),
@@ -16,3 +16,4 @@ export const modelsSchema = z.object({ providers: z.array(z.object({ id: z.strin
 export const schemaResultSchema = z.object({ content: z.string(), hash: z.string() });
 export const inspectSchema = z.object({ sourceFormat: z.literal('pdf'), pageCount: z.number(), outlineCount: z.number(), samples: z.array(z.object({ page: z.number(), chars: z.number(), hasGraphics: z.boolean(), possibleOcr: z.boolean(), hasStructure: z.boolean() })), possibleOcr: z.boolean(), note: z.string() });
 export const uploadResultSchema = z.object({ receiptId: z.string(), filename: z.string(), bytes: z.number() });
+export const jobUsagePageSchema = z.object({ records: z.array(z.json()), offset: z.number().int().nonnegative(), total: z.number().int().nonnegative(), next: z.number().int().nonnegative().nullable() });

package/lib/data.d.ts

@@ -1528,8 +1528,12 @@ export declare const jobSchema: z.ZodObject<{
         modelTimeoutMs: z.ZodDefault<z.ZodNumber>;
         modelAttempts: z.ZodDefault<z.ZodNumber>;
         visionConcurrency: z.ZodDefault<z.ZodNumber>;
+        maxModelCallsLimit: z.ZodDefault<z.ZodNumber>;
+        maxModelTokensLimit: z.ZodDefault<z.ZodNumber>;
+        uploadRetentionDays: z.ZodDefault<z.ZodNumber>;
         maxModelCalls: z.ZodDefault<z.ZodNumber>;
         maxModelTokens: z.ZodDefault<z.ZodNumber>;
+        imageTimeoutMs: z.ZodDefault<z.ZodNumber>;
         visionMaxEdge: z.ZodDefault<z.ZodNumber>;
         visionTileSize: z.ZodDefault<z.ZodNumber>;
         visionMaxTiles: z.ZodDefault<z.ZodNumber>;
@@ -1599,6 +1603,13 @@ export declare const jobSchema: z.ZodObject<{
             chunkId: z.ZodString;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    pendingCalls: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    legacyUsageCount: z.ZodDefault<z.ZodNumber>;
+    legacyCallCount: z.ZodDefault<z.ZodNumber>;
+    reportSummary: z.ZodOptional<z.ZodObject<{
+        issues: z.ZodNumber;
+        blocking: z.ZodNumber;
+    }, z.core.$strip>>;
     usage: z.ZodObject<{
         calls: z.ZodNumber;
         tokens: z.ZodNumber;

package/lib/data.js

@@ -69,6 +69,8 @@ export const jobSchema = z.object({ jobId: idSchema, kbId: idSchema, docId: idSc
     progress: z.object({ totalPages: z.number().optional(), parsedPages: z.number().optional(), ocrPages: z.number().optional(), tables: z.number().optional(), blocks: z.number().optional(), currentPage: z.number().optional(),
         totalFigures: z.number().optional(), completedFigures: z.number().optional(), inflightFigures: z.array(z.object({ occurrenceId: z.string(), caption: z.string() })).optional(),
         totalChunks: z.number().optional(), indexedChunks: z.number().optional(), currentChunk: z.object({ title: z.string(), headingPath: z.array(z.string()), chunkId: z.string() }).optional() }),
+    pendingCalls: z.array(z.number().int().positive()).max(16).default([]), legacyUsageCount: z.number().int().nonnegative().default(0), legacyCallCount: z.number().int().nonnegative().default(0),
+    reportSummary: z.object({ issues: z.number().int().nonnegative(), blocking: z.number().int().nonnegative() }).optional(),
     usage: usageSchema, failures: z.array(z.object({ at: z.string(), stage: jobStateSchema, error: z.string() })), events: z.array(z.object({ at: z.string(), state: jobStateSchema })).optional(),
     figureRefresh: z.object({ occurrenceId: z.string(), token: z.string() }).nullable().optional(), visionCapability: z.string().optional(), parserVersion: z.string().optional(),
     pageStart: z.number().optional(), pageEnd: z.number().optional(), pdf: z.object({ pageCount: z.number(), selectedPages: rangeSchema, outlineCount: z.number().optional() }).optional(),

package/lib/figures/image-client.d.ts

@@ -0,0 +1,5 @@
+import type { Settings } from '../config.ts';
+export declare function runImageWorker(file: string, config: Settings, save: (data: Uint8Array, coordinates: Record<string, string | number>) => Promise<void>, signal?: AbortSignal): Promise<{
+    width: number;
+    height: number;
+}>;

package/lib/figures/image-client.js

@@ -0,0 +1,58 @@
+import { Worker } from 'node:worker_threads';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { checkAbort, deferred } from "../util.js";
+import { imageGate } from "./image-gate.js";
+import { imageMessageSchema, imageOptionsSchema } from "./image-protocol.js";
+export async function runImageWorker(file, config, save, signal) {
+    const options = imageOptionsSchema.parse({ visionMaxEdge: config.visionMaxEdge, visionTileSize: config.visionTileSize, visionMaxTiles: config.visionMaxTiles });
+    const release = await imageGate.acquire(signal);
+    let worker, saving;
+    const result = deferred(), abort = () => result.reject(signal?.reason ?? new Error('图片预处理已取消'));
+    let timer, complete = false, next = 1;
+    try {
+        checkAbort(signal);
+        const js = new URL('./image-worker.js', import.meta.url), source = !existsSync(fileURLToPath(js));
+        worker = new Worker(source ? new URL('./image-worker.ts', import.meta.url) : js, { workerData: { file, options }, execArgv: source ? ['--import', 'tsx/esm'] : [], resourceLimits: { maxOldGenerationSizeMb: 512 } });
+        const current = worker;
+        timer = setTimeout(() => result.reject(new Error('图片预处理超时')), Math.min(config.imageTimeoutMs, 120000));
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        current.on('error', error => result.reject(error));
+        current.on('exit', code => { if (!complete)
+            result.reject(new Error(`图片预处理进程退出（${code}）`)); });
+        current.on('message', (raw) => {
+            try {
+                const value = imageMessageSchema.parse(raw);
+                if (value.kind === 'error')
+                    result.reject(new Error(value.message));
+                else if (value.kind === 'done') {
+                    complete = true;
+                    result.resolve({ width: value.width, height: value.height });
+                }
+                else {
+                    if (saving || value.id !== next++ || value.data.length > 8 * 1024 * 1024)
+                        throw new Error('图片预处理输出无效');
+                    saving = Promise.resolve().then(() => { checkAbort(signal); return save(value.data, value.coordinates); }).then(() => { checkAbort(signal); saving = undefined; current.postMessage({ ack: value.id }); });
+                    void saving.catch(error => result.reject(error));
+                }
+            }
+            catch (error) {
+                result.reject(error);
+            }
+        });
+        return await result.promise;
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', abort);
+        try {
+            await worker?.terminate();
+            await saving?.catch(() => { });
+        }
+        finally {
+            release();
+        }
+    }
+}

package/lib/figures/image-gate.d.ts

@@ -0,0 +1,12 @@
+/** One process-wide bitmap worker, including all knowledge bases and runtime instances. */
+export declare class ImageGate {
+    active: boolean;
+    private queue;
+    get waiting(): number;
+    acquire(signal?: AbortSignal): Promise<() => void>;
+    private release;
+}
+declare global {
+    var __dshLibingKnowledgeImageGateV1: ImageGate | undefined;
+}
+export declare const imageGate: ImageGate;

package/lib/figures/image-gate.js

@@ -0,0 +1,39 @@
+import { checkAbort } from "../util.js";
+/** One process-wide bitmap worker, including all knowledge bases and runtime instances. */
+export class ImageGate {
+    active = false;
+    queue = [];
+    get waiting() { return this.queue.length; }
+    async acquire(signal) {
+        checkAbort(signal);
+        if (!this.active) {
+            this.active = true;
+            return this.release();
+        }
+        if (this.queue.length >= 32)
+            throw new Error('图片预处理等待队列已满，请稍后重试');
+        return new Promise((resolve, reject) => {
+            const entry = { ...signal ? { signal } : {}, resolve, reject, abort: () => { signal?.removeEventListener('abort', entry.abort); this.queue = this.queue.filter(e => e !== entry); reject(signal?.reason ?? new Error('图片预处理已取消')); } };
+            this.queue.push(entry);
+            signal?.addEventListener('abort', entry.abort, { once: true });
+            if (signal?.aborted)
+                entry.abort();
+        });
+    }
+    release() {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = this.queue.shift();
+            if (next) {
+                next.signal?.removeEventListener('abort', next.abort);
+                next.resolve(this.release());
+            }
+            else
+                this.active = false;
+        };
+    }
+}
+export const imageGate = globalThis.__dshLibingKnowledgeImageGateV1 ??= new ImageGate();

package/lib/figures/image-protocol.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const imageOptionsSchema: z.ZodObject<{
+    visionMaxEdge: z.ZodNumber;
+    visionTileSize: z.ZodNumber;
+    visionMaxTiles: z.ZodNumber;
+}, z.core.$strict>;
+export declare const imageMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"image">;
+    id: z.ZodNumber;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    coordinates: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"done">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strip>], "kind">;

package/lib/figures/image-protocol.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const imageOptionsSchema = z.strictObject({
+    visionMaxEdge: z.number().int().min(1).max(4096), visionTileSize: z.number().int().min(1).max(4096), visionMaxTiles: z.number().int().min(1).max(64),
+});
+export const imageMessageSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('image'), id: z.number().int().positive(), data: z.instanceof(Uint8Array), coordinates: z.record(z.string(), z.union([z.string(), z.number()])) }),
+    z.object({ kind: z.literal('done'), width: z.number().int().positive(), height: z.number().int().positive() }),
+    z.object({ kind: z.literal('error'), message: z.string() }),
+]);

package/lib/figures/image-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/figures/image-worker.js

@@ -0,0 +1,60 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { readFile, stat } from 'node:fs/promises';
+import { Jimp, ResizeStrategy } from 'jimp';
+import { imageSize } from 'image-size';
+import { z } from 'zod';
+import { imageOptionsSchema } from "./image-protocol.js";
+import { message, required } from "../util.js";
+const port = required(parentPort);
+async function run() {
+    const { file, options } = z.object({ file: z.string(), options: imageOptionsSchema }).parse(workerData);
+    if ((await stat(file)).size > 32 * 1024 * 1024)
+        throw new Error('单张图片超过 32 MiB，请提供较小的位图');
+    const data = await readFile(file), dimensions = imageSize(data);
+    if (data.length > 32 * 1024 * 1024)
+        throw new Error('单张图片超过 32 MiB，请提供较小的位图');
+    if (!dimensions.width || !dimensions.height || dimensions.width * dimensions.height > 50000000)
+        throw new Error('图片像素过大，请提供分辨率较低的版本');
+    const image = await Jimp.read(data), { width, height } = image.bitmap;
+    if (width * height > 50000000)
+        throw new Error('图片像素过大，请提供分辨率较低的版本');
+    const tile = options.visionTileSize, step = Math.max(1, Math.floor(tile * .85)), tiled = Math.max(width, height) > options.visionMaxEdge;
+    const columns = Math.max(1, Math.ceil((width - tile) / step) + 1), rows = Math.max(1, Math.ceil((height - tile) / step) + 1);
+    if (tiled && columns * rows > options.visionMaxTiles)
+        throw new Error(`大图需要 ${columns * rows} 个裁片，超过 visionMaxTiles；请拆分图片或提高上限`);
+    let id = 0;
+    const send = async (bitmap, coordinates) => {
+        const bytes = await bitmap.getBuffer('image/png');
+        if (bytes.length > 8 * 1024 * 1024)
+            throw new Error('图像转换后超过单张 8 MiB，请降低 visionTileSize');
+        const packet = new Uint8Array(bytes), current = ++id;
+        const acknowledged = new Promise((resolve, reject) => port.once('message', raw => {
+            const ack = z.object({ ack: z.literal(current) }).safeParse(raw);
+            if (ack.success)
+                resolve();
+            else
+                reject(new Error('图片保存确认无效'));
+        }));
+        port.postMessage({ kind: 'image', id: current, data: packet, coordinates }, [packet.buffer]);
+        await acknowledged;
+    };
+    // A separate bitmap descriptor shares the read-only source buffer; resize allocates only the overview.
+    const overview = new Jimp({ ...image.bitmap });
+    if (tiled) {
+        const ratio = options.visionMaxEdge / Math.max(width, height);
+        overview.resize({ w: Math.max(1, Math.round(width * ratio)), h: Math.max(1, Math.round(height * ratio)), mode: ResizeStrategy.BILINEAR });
+    }
+    await send(overview, { kind: 'overview', originalWidth: width, originalHeight: height });
+    if (tiled)
+        for (let row = 0; row < rows; row++)
+            for (let col = 0; col < columns; col++) {
+                const x = Math.min(col * step, Math.max(0, width - tile)), y = Math.min(row * step, Math.max(0, height - tile)), w = Math.min(tile, width), h = Math.min(tile, height);
+                // Copy only the requested region; never clone the full source for a tile.
+                const bitmap = new Jimp({ width: w, height: h });
+                for (let line = 0; line < h; line++)
+                    image.bitmap.data.copy(bitmap.bitmap.data, line * w * 4, ((y + line) * width + x) * 4, ((y + line) * width + x + w) * 4);
+                await send(bitmap, { kind: 'tile', x, y, width: w, height: h, originalWidth: width, originalHeight: height });
+            }
+    port.postMessage({ kind: 'done', width, height });
+}
+void run().catch(error => port.postMessage({ kind: 'error', message: message(error) })).finally(() => port.close());

package/lib/figures/process.d.ts

@@ -5,9 +5,9 @@ import type { Block, Document, Job, Overlay } from '../data.ts';
 import type { Models, PreparedImage } from '../models.ts';
 export declare function figureContext(blocks: Block[], index: number, headingPath: string[]): string;
 export declare function prepareImage(ctx: Context, file: string, config: Settings, signal?: AbortSignal): Promise<{
-    images: PreparedImage[];
     width: number;
     height: number;
+    images: PreparedImage[];
 }>;
 export declare function figureEntries(document: Document): {
     block: Block;

package/lib/figures/process.js

@@ -2,9 +2,7 @@ import { z } from 'zod';
 import { figureSchema, figureDataSchema, FIGURE_TYPES } from "../data.js";
 import { required, message } from "../util.js";
 const classificationSchema = z.object({ types: z.array(z.enum(FIGURE_TYPES)).min(1), reason: z.string() });
-import { Jimp } from 'jimp';
-import { imageSize } from 'image-size';
-import { readFile } from 'node:fs/promises';
+import { runImageWorker } from "./image-client.js";
 import { join } from 'node:path';
 import { atomicWrite, checkAbort, clip, hash, readJson } from "../util.js";
 import { BudgetError } from "../models.js";
@@ -13,41 +11,14 @@ export function figureContext(blocks, index, headingPath) {
     return JSON.stringify({ headingPath, caption: required(blocks[index]).caption, nearby: blocks.slice(Math.max(0, index - 2), index + 3).filter(b => b.type !== 'figure').map(b => clip(b.text || '', 1000)) });
 }
 export async function prepareImage(ctx, file, config, signal) {
-    checkAbort(signal);
-    const data = await readFile(file);
-    if (data.length > 32 * 1024 * 1024)
-        throw new Error('单张图片超过 32 MiB，请提供较小的位图');
-    const dimensions = imageSize(data);
-    if (!dimensions.width || !dimensions.height || dimensions.width * dimensions.height > 50000000)
-        throw new Error('图片像素过大，请提供分辨率较低的版本');
-    const image = await Jimp.read(data);
-    const { width, height } = image.bitmap;
-    if (width * height > 50000000)
-        throw new Error('图片像素过大，请提供分辨率较低的版本');
     const images = [];
-    const add = async (bitmap, coordinates) => {
+    const dimensions = await runImageWorker(file, config, async (data, coordinates) => {
+        checkAbort(signal);
+        const attachment = await ctx.attachments.saveImage({ data: Buffer.from(data.buffer, data.byteOffset, data.byteLength), mediaType: 'image/png', name: 'kb-figure.png' });
         checkAbort(signal);
-        const bytes = await bitmap.getBuffer('image/png');
-        if (bytes.length > 8 * 1024 * 1024)
-            throw new Error('图像转换后超过单张 8 MiB，请降低 visionTileSize');
-        const attachment = await ctx.attachments.saveImage({ data: bytes, mediaType: 'image/png', name: 'kb-figure.png' });
         images.push({ attachment, coordinates });
-    };
-    const overview = image.clone();
-    if (Math.max(width, height) > config.visionMaxEdge)
-        overview.scale(config.visionMaxEdge / Math.max(width, height));
-    await add(overview, { kind: 'overview', originalWidth: width, originalHeight: height });
-    if (Math.max(width, height) > config.visionMaxEdge) {
-        const tile = config.visionTileSize, step = Math.max(1, Math.floor(tile * .85)), columns = Math.max(1, Math.ceil((width - tile) / step) + 1), rows = Math.max(1, Math.ceil((height - tile) / step) + 1);
-        if (columns * rows > config.visionMaxTiles)
-            throw new Error(`大图需要 ${columns * rows} 个裁片，超过 visionMaxTiles；请拆分图片或提高上限`);
-        for (let row = 0; row < rows; row++)
-            for (let col = 0; col < columns; col++) {
-                const x = Math.min(col * step, Math.max(0, width - tile)), y = Math.min(row * step, Math.max(0, height - tile)), w = Math.min(tile, width), h = Math.min(tile, height);
-                await add(image.clone().crop({ x, y, w, h }), { kind: 'tile', x, y, width: w, height: h, originalWidth: width, originalHeight: height });
-            }
-    }
-    return { images, width, height };
+    }, signal);
+    return { images, ...dimensions };
 }
 export function figureEntries(document) {
     let heading = [];

package/lib/indexes.js

@@ -71,11 +71,18 @@ export async function writeIndexes(dir, documents, config, revision) {
     };
     for (const document of documents) {
         const base = posix.join('wiki/documents', document.docId);
+        const byId = new Map(document.nodes.map(node => [node.nodeId, node]));
+        const byNode = new Map();
+        for (const chunk of document.chunks) {
+            const group = byNode.get(chunk.nodeId) || [];
+            group.push(chunk);
+            byNode.set(chunk.nodeId, group);
+        }
         for (const node of document.nodes) {
             const parents = [];
             let current = node;
             while (current.parentId) {
-                current = required(document.nodes.find(n => n.nodeId === current.parentId));
+                current = required(byId.get(current.parentId));
                 if (current.nodeId !== 'root')
                     parents.unshift(current.nodeId);
             }
@@ -83,7 +90,7 @@ export async function writeIndexes(dir, documents, config, revision) {
             node.indexPath = path;
         }
         for (const node of document.nodes) {
-            const entries = [...node.children.map(childId => required(document.nodes.find(x => x.nodeId === childId))).map(child => ({ title: child.title, path: child.indexPath, nodeId: child.nodeId, docId: document.docId, summary: '章节导航', reviewStatus: 'navigation' })), ...document.chunks.filter(c => c.nodeId === node.nodeId).map(c => ({ title: c.title, path: c.path, chunkId: c.chunkId, docId: c.docId, summary: c.summary, fullChars: c.fullChars, keywords: c.keywords, reviewStatus: c.reviewStatus, ...c.pageRange ? { pageRange: c.pageRange } : {} }))];
+            const entries = [...node.children.map(childId => required(byId.get(childId))).map(child => ({ title: child.title, path: child.indexPath, nodeId: child.nodeId, docId: document.docId, summary: '章节导航', reviewStatus: 'navigation' })), ...(byNode.get(node.nodeId) || []).map(c => ({ title: c.title, path: c.path, chunkId: c.chunkId, docId: c.docId, summary: c.summary, fullChars: c.fullChars, keywords: c.keywords, reviewStatus: c.reviewStatus, ...c.pageRange ? { pageRange: c.pageRange } : {} }))];
             await writeCatalog(`${document.docId}-${node.nodeId}`, required(node.indexPath), node.title, document.sourceFormat === 'pdf' ? [{ line: `> ${pdfScope(document)}\n\n` }, ...entries] : entries);
         }
         for (const chunk of document.chunks) {