@dsh-libing/knowledge-base 0.1.0 → 0.1.4

package/lib/routes.js

@@ -1,15 +1,20 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { API, browserBuildSchema, jobActionSchema, catalogQuerySchema, readQuerySchema, searchSchema, assetQuerySchema, revisionQuerySchema } from "./shared.js";
+import { API, jobListQuerySchema, jobDetailsQuerySchema, jobUsageQuerySchema, browserBuildSchema, jobActionSchema, catalogQuerySchema, readQuerySchema, searchSchema, assetQuerySchema, revisionQuerySchema } from "./shared.js";
 import { figureDataSchema, overlaySchema } from "./data.js";
 import { inspectPdf } from "./document/pdf-session.js";
 import { hash, safePath, message, required, fileBytes, checkAbort } from "./util.js";
 const HOST_VERSION = z.object({ version: z.string() }).parse(JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))).version;
-const id = z.string().regex(/^[a-z0-9][a-z0-9-]{0,95}$/u), name = z.string().trim().min(1).max(120), digest = z.string().regex(/^[a-f0-9]{64}$/u);
-const libraryArgs = z.strictObject({ kbId: id }), managementArgs = libraryArgs.extend({ confirmName: name });
+const id = z.string().regex(/^[a-z0-9][a-z0-9-]{0,95}$/u);
+const name = z.string().trim().min(1).max(120);
+const digest = z.string().regex(/^[a-f0-9]{64}$/u);
+const libraryArgs = z.strictObject({ kbId: id });
+const managementArgs = libraryArgs.extend({ confirmName: name });
 const reviewSchema = z.strictObject({ kbId: id, revision: id, docId: id, occurrenceId: id, expectedHash: digest, action: z.enum(['reidentify', 'restore']).optional(), figure: z.union([figureDataSchema.strict(), z.strictObject({ ignore: z.literal(true) }), z.strictObject({ skip: z.literal(true) })]).optional(), visionProvider: z.string().optional(), visionModel: z.string().optional() }).refine(value => Boolean(value.action) !== Boolean(value.figure), '指定一个复核操作或内容');
-const draftQuery = z.strictObject({ jobId: id }), sourceQuery = revisionQuerySchema.extend({ docId: id }), draftAssetQuery = draftQuery.extend({ docId: id, assetId: id });
+const draftQuery = z.strictObject({ jobId: id });
+const sourceQuery = revisionQuerySchema.extend({ docId: id });
+const draftAssetQuery = draftQuery.extend({ docId: id, assetId: id });
 const draftReadQuery = draftQuery.extend(readQuerySchema.omit({ kbId: true, revision: true }).shape);
 const headers = { 'cache-control': 'no-store', 'x-content-type-options': 'nosniff', 'referrer-policy': 'no-referrer' };
 function query(request) {
@@ -69,16 +74,19 @@ export function routes(runtime, ctx) {
             throw new Error('PDF 原件不存在于所选版本中');
         return binary((await store.rawSource(snapshot.kbId, doc)).data, 'application/pdf');
     };
-    const image = async (asset, file) => {
+    const image = async (asset, file, verified) => {
         if (!['image/png', 'image/jpeg', 'image/webp', 'image/gif', 'image/bmp', 'image/tiff'].includes(asset.mime))
             throw new Error('不支持浏览此图片格式，请提供 PNG/JPEG 预览');
-        const data = await fileBytes(file, config.maxUncompressedBytes);
-        if (`a-${hash(data).slice(0, 20)}` !== asset.assetId)
+        const data = verified ?? await fileBytes(file, config.maxUncompressedBytes);
+        if (!verified && `a-${hash(data).slice(0, 20)}` !== asset.assetId)
             throw new Error('图片内容与清单不一致');
         return binary(data, asset.mime);
     };
     const tree = (snapshot, kbId) => ({ kbId, revision: snapshot.revision, coverageIncomplete: snapshot.manifest.coverageIncomplete, report: snapshot.manifest.report, documents: snapshot.manifest.documents.map(doc => ({ ...doc, chunks: doc.chunks.map(({ segments: _segments, anchors: _anchors, ...chunk }) => chunk) })) });
-    add('list', 'GET', async (request) => { z.strictObject({}).parse(query(request)); return ({ hostVersion: HOST_VERSION, kbs: await Promise.all((await store.list()).map(async (kb) => ({ ...kb, ...await store.inspect(kb.kbId) }))), deletedKbs: await store.deleted(), activities: await store.activities(), jobs: jobs.list(), dataRoot: store.root, config: { chunkTargetChars: config.chunkTargetChars, visionProvider: config.visionProvider, visionModel: config.visionModel, maxInputBytes: config.maxInputBytes } }); });
+    add('list', 'GET', async (request) => { const args = jobListQuerySchema.parse(query(request)); if (args.jobsKbId)
+        await store.kb(args.jobsKbId); return ({ hostVersion: HOST_VERSION, ...await store.overview(), ...jobs.list(args.jobsKbId, args.jobOffset, args.jobLimit), dataRoot: store.root, config: { chunkTargetChars: config.chunkTargetChars, visionProvider: config.visionProvider, visionModel: config.visionModel, maxInputBytes: config.maxInputBytes } }); });
+    add('job-details', 'GET', async (request) => { const args = jobDetailsQuerySchema.parse(query(request)); return jobs.details(args.jobId, args.section === 'report'); });
+    add('job-usage', 'GET', async (request) => { const args = jobUsageQuerySchema.parse(query(request)); return jobs.usage(args.jobId, args.offset, args.limit, request.signal); });
     add('create', 'POST', async (request) => store.create((await body(request, z.strictObject({ name }))).name));
     add('delete', 'POST', async (request) => { const args = await body(request, managementArgs); return jobs.trash(args.kbId, args.confirmName); });
     add('restore', 'POST', async (request) => jobs.restore((await body(request, libraryArgs)).kbId));
@@ -90,32 +98,52 @@ export function routes(runtime, ctx) {
         return store.upload(await bytes(request, config.maxInputBytes), args.filename);
     });
     add('inspect-document', 'POST', async (request) => {
-        const { receiptId } = await body(request, z.strictObject({ receiptId: id })), uploaded = await store.uploaded(receiptId);
+        const { receiptId } = await body(request, z.strictObject({ receiptId: id }));
+        const uploaded = await store.uploaded(receiptId);
         if (!/\.pdf$/iu.test(uploaded.filename))
             throw new Error('文档预检只支持 PDF');
         return inspectPdf(await safePath(store.root, join('uploads', receiptId + '.bin')), config, request.signal);
     });
-    add('source', 'GET', async (request) => { const args = sourceQuery.parse(query(request)), kb = await store.kb(args.kbId); return original({ ...await store.revision(kb.kbId, args.revision), kbId: kb.kbId }, args.docId); });
+    add('source', 'GET', async (request) => { const args = sourceQuery.parse(query(request)); const kb = await store.kb(args.kbId); return original({ ...await store.revision(kb.kbId, args.revision), kbId: kb.kbId }, args.docId); });
     add('draft-source', 'GET', async (request) => { const args = draftQuery.extend({ docId: id }).parse(query(request)); return original(await jobs.preview(args.jobId), args.docId); });
     add('build', 'POST', async (request) => jobs.submit(await body(request, browserBuildSchema)));
     add('job', 'POST', async (request) => { const args = await body(request, jobActionSchema); return jobs.action(args.jobId, args.action, args); });
     add('draft', 'GET', async (request) => { const snapshot = await jobs.preview(draftQuery.parse(query(request)).jobId); return { ...tree(snapshot, snapshot.kbId), previewJobId: snapshot.jobId, coverageIncomplete: true }; });
     add('draft-read', 'GET', async (request) => {
-        const { jobId, ...args } = draftReadQuery.parse(query(request)), snapshot = await jobs.preview(jobId), chunk = required(snapshot.manifest.documents.flatMap(d => d.chunks).find(c => c.chunkId === args.chunkId), '草稿片段');
+        const { jobId, ...args } = draftReadQuery.parse(query(request));
+        const snapshot = await jobs.preview(jobId);
+        const chunk = required(snapshot.manifest.documents.flatMap(d => d.chunks).find(c => c.chunkId === args.chunkId), '草稿片段');
         const value = retrieval.readSnapshot(snapshot.kbId, { ...snapshot, chunk, content: await store.chunkContent(snapshot, chunk) }, { ...args, kbId: snapshot.kbId });
         return { ...value, previewJobId: jobId, warnings: ['待发布预览：未向 Agent 检索开放', ...value.warnings] };
     });
-    add('draft-asset', 'GET', async (request) => { const args = draftAssetQuery.parse(query(request)), snapshot = await jobs.preview(args.jobId), doc = required(snapshot.manifest.documents.find(d => d.docId === args.docId), '草稿文档'), asset = required(doc.assets.find(a => a.assetId === args.assetId), '草稿图片'); return image(asset, await safePath(snapshot.root, join('sources', doc.docId, asset.path))); });
+    add('draft-asset', 'GET', async (request) => { const args = draftAssetQuery.parse(query(request)); const snapshot = await jobs.preview(args.jobId); const doc = required(snapshot.manifest.documents.find(d => d.docId === args.docId), '草稿文档'); const asset = required(doc.assets.find(a => a.assetId === args.assetId), '草稿图片'); return image(asset, await safePath(snapshot.root, join('sources', doc.docId, asset.path))); });
     add('catalog', 'GET', async (request) => retrieval.catalog(catalogQuerySchema.parse(query(request))));
-    add('tree', 'GET', async (request) => { const args = revisionQuerySchema.parse(query(request)), kb = await store.kb(args.kbId), snapshot = await store.revision(kb.kbId, args.revision), overlays = await store.overlays(kb.kbId), value = tree(snapshot, kb.kbId); return { ...value, location: await store.location(kb.kbId, snapshot.revision), documents: value.documents.map(doc => ({ ...doc, figures: doc.figures.map(figure => ({ ...figure, expectedHash: hash(overlays[figure.overlayKey] || null) })) })) }; });
+    add('tree', 'GET', async (request) => { const args = revisionQuerySchema.parse(query(request)); const { kb, snapshot } = await store.open(args.kbId, args.revision); const overlays = await store.overlays(kb.kbId); const value = tree(snapshot, kb.kbId); return { ...value, location: await store.snapshotLocation(kb.kbId, snapshot), documents: value.documents.map(doc => ({ ...doc, figures: doc.figures.map(figure => ({ ...figure, expectedHash: hash(overlays[figure.overlayKey] || null) })) })) }; });
     add('read', 'GET', async (request) => retrieval.read(readQuerySchema.parse(query(request))));
     add('search', 'POST', async (request) => retrieval.search(await body(request, searchSchema)));
-    add('asset', 'GET', async (request) => { const args = assetQuerySchema.parse(query(request)), kb = await store.kb(args.kbId), asset = await store.asset(kb.kbId, args.revision, args.docId, args.assetId); return image(asset.asset, asset.file); });
-    add('schema', 'GET', async (request) => { const kb = await store.kb(libraryArgs.parse(query(request)).kbId), content = await store.schema(kb.kbId); return { content, hash: hash(content) }; });
-    add('schema', 'POST', async (request) => { const args = await body(request, libraryArgs.extend({ content: z.string().max(20000), expectedHash: digest })), kb = await store.kb(args.kbId); return store.setSchema(kb.kbId, args.content, args.expectedHash); });
+    add('asset', 'GET', async (request) => { const args = assetQuerySchema.parse(query(request)); const kb = await store.kb(args.kbId); const asset = await store.asset(kb.kbId, args.revision, args.docId, args.assetId); return image(asset.asset, asset.file, asset.data); });
+    add('schema', 'GET', async (request) => { const kb = await store.kb(libraryArgs.parse(query(request)).kbId); const content = await store.schema(kb.kbId); return { content, hash: hash(content) }; });
+    add('schema', 'POST', async (request) => { const args = await body(request, libraryArgs.extend({ content: z.string().max(20000), expectedHash: digest })); const kb = await store.kb(args.kbId); return store.setSchema(kb.kbId, args.content, args.expectedHash); });
     add('review', 'POST', async (request) => {
-        const args = await body(request, reviewSchema), kb = await store.kb(args.kbId);
-        const figure = args.action ? null : args.figure && 'ignore' in args.figure ? { ignore: true } : args.figure && 'skip' in args.figure ? { skip: true, types: ['decoration'], description: '人工确认装饰图', visibleLabels: [], relations: [], uncertainties: [], needsReview: false } : args.figure;
+        const args = await body(request, reviewSchema);
+        const kb = await store.kb(args.kbId);
+        let figure;
+        if (args.action) {
+            figure = null;
+        }
+        else {
+            if (args.figure && 'ignore' in args.figure) {
+                figure = { ignore: true };
+            }
+            else {
+                if (args.figure && 'skip' in args.figure) {
+                    figure = { skip: true, types: ['decoration'], description: '人工确认装饰图', visibleLabels: [], relations: [], uncertainties: [], needsReview: false };
+                }
+                else {
+                    figure = args.figure;
+                }
+            }
+        }
         if (figure && JSON.stringify(figure).length > config.figureMaxChars * 3)
             throw new Error('图片复核内容超过预算');
         return jobs.review(kb.kbId, args.revision, args.docId, args.occurrenceId, figure === null ? null : overlaySchema.parse(figure), args.expectedHash, { restore: args.action === 'restore', visionProvider: args.visionProvider, visionModel: args.visionModel });
@@ -139,11 +167,29 @@ export function routes(runtime, ctx) {
                 try {
                     await runtime.ready;
                     checkAbort(request.signal);
-                    const handler = required(methods.get(z.enum(['GET', 'POST', 'HEAD']).parse(request.method)), '请求方法'), value = await runtime.run(signal => handler(new Request(request, { signal })), request.signal);
+                    const handler = required(methods.get(z.enum(['GET', 'POST', 'HEAD']).parse(request.method)), '请求方法');
+                    const value = await runtime.run(signal => handler(new Request(request, { signal })), request.signal);
                     return value instanceof Response ? value : json(value);
                 }
                 catch (error) {
-                    const detail = message(error), status = error instanceof z.ZodError || error instanceof SyntaxError ? 400 : /变化|冲突|已存在|未退出|正在关闭/u.test(detail) ? 409 : /无效|必须|不支持|不能|只能|不在回收站|超过|过大|缺少|缺失|尚无|不存在|提供|请选择|待复核|重复/u.test(detail) ? 400 : 500;
+                    const detail = message(error);
+                    let status;
+                    if (error instanceof z.ZodError || error instanceof SyntaxError) {
+                        status = 400;
+                    }
+                    else {
+                        if (/变化|冲突|已存在|未退出|正在关闭/u.test(detail)) {
+                            status = 409;
+                        }
+                        else {
+                            if (/无效|必须|不支持|不能|只能|不在回收站|超过|过大|缺少|缺失|尚无|不存在|提供|请选择|待复核|重复/u.test(detail)) {
+                                status = 400;
+                            }
+                            else {
+                                status = 500;
+                            }
+                        }
+                    }
                     if (status === 500)
                         ctx.logger.warn(`knowledge-base: ${detail}`);
                     return json({ error: detail }, status);

package/lib/runtime.d.ts

@@ -18,8 +18,12 @@ export declare function createRuntime(ctx: Context, raw?: Config): {
         modelTimeoutMs: number;
         modelAttempts: number;
         visionConcurrency: number;
+        maxModelCallsLimit: number;
+        maxModelTokensLimit: number;
+        uploadRetentionDays: number;
         maxModelCalls: number;
         maxModelTokens: number;
+        imageTimeoutMs: number;
         visionMaxEdge: number;
         visionTileSize: number;
         visionMaxTiles: number;

package/lib/runtime.js

@@ -7,10 +7,16 @@ import { Jobs } from "./jobs.js";
 import { Retrieval } from "./retrieval.js";
 /** One root owner; admitted tasks are durable and the close promise drains them once. */
 export function createRuntime(ctx, raw = {}) {
-    const config = resolveConfig(raw), store = new Store(config), models = new Models(ctx, config), jobs = new Jobs(store, models, config), retrieval = new Retrieval(store, config);
+    const config = resolveConfig(raw);
+    const store = new Store(config);
+    const models = new Models(ctx, config);
+    const jobs = new Jobs(store, models, config);
+    const retrieval = new Retrieval(store, config);
     const ready = mkdir(store.root, { recursive: true }).then(() => jobs.init());
-    let closing, stopped = false;
-    const controller = new AbortController(), pending = new Set();
+    let closing;
+    let stopped = false;
+    const controller = new AbortController();
+    const pending = new Set();
     const run = (operation, signal) => {
         if (stopped)
             return Promise.reject(new Error('任务服务正在关闭'));
@@ -32,7 +38,12 @@ export function createRuntime(ctx, raw = {}) {
             }
             finally {
                 await Promise.allSettled(pending);
-                await jobs.close();
+                try {
+                    await jobs.close();
+                }
+                finally {
+                    store.revisionCache.clear();
+                }
             }
         })();
         return closing;

package/lib/settings.d.ts

@@ -11,8 +11,12 @@ export declare const settingsSchema: 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>;

package/lib/settings.js

@@ -6,13 +6,16 @@ export const settingsSchema = z.strictObject({
     catalogMaxChars: positive.min(512).default(6000), candidateLimit: positive.max(30).default(6),
     maxInputBytes: positive.default(64 * 1024 * 1024), maxUncompressedBytes: positive.default(256 * 1024 * 1024), maxArchiveEntries: positive.default(10000),
     modelTimeoutMs: positive.default(90000), modelAttempts: positive.default(3), visionConcurrency: positive.max(8).default(2),
-    maxModelCalls: positive.default(1000), maxModelTokens: positive.default(2000000), visionMaxEdge: positive.default(2048),
-    visionTileSize: positive.default(1536), visionMaxTiles: positive.default(12), modelMaxOutputTokens: positive.default(4096),
+    maxModelCallsLimit: positive.max(100000).default(10000), maxModelTokensLimit: positive.max(1000000000).default(20000000), uploadRetentionDays: positive.max(365).default(7),
+    maxModelCalls: positive.max(100000).default(1000), maxModelTokens: positive.max(1000000000).default(2000000), imageTimeoutMs: positive.max(120000).default(60000), visionMaxEdge: positive.max(4096).default(2048),
+    visionTileSize: positive.max(4096).default(1536), visionMaxTiles: positive.max(64).default(12), modelMaxOutputTokens: positive.default(4096),
     summaryMaxChars: positive.default(160), figureMaxChars: positive.default(6000), pdfMaxPages: positive.default(2000),
     pdfMaxPagePixels: positive.default(12000000), pdfPageTimeoutMs: positive.default(60000),
     libreOfficePath: z.string().default(''), visionProvider: z.string().default(''), visionModel: z.string().default(''),
     summaryProvider: z.string().default(''), summaryModel: z.string().default(''), skipImages: z.boolean().default(false), acceptPartial: z.boolean().default(false),
 }).superRefine((value, context) => {
+    if (value.maxModelCalls > value.maxModelCallsLimit || value.maxModelTokens > value.maxModelTokensLimit)
+        context.addIssue({ code: 'custom', message: '默认任务预算不能超过宿主预算上限' });
     for (const kind of ['vision', 'summary'])
         if (Boolean(value[`${kind}Provider`]) !== Boolean(value[`${kind}Model`]))
             context.addIssue({ code: 'custom', message: `${kind}Provider / ${kind}Model 必须成对配置` });

package/lib/shared.d.ts

@@ -93,3 +93,20 @@ export declare const revisionQuerySchema: z.ZodObject<{
     kbId: z.ZodString;
     revision: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const jobListQuerySchema: z.ZodObject<{
+    jobsKbId: z.ZodOptional<z.ZodString>;
+    jobOffset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    jobLimit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const jobDetailsQuerySchema: z.ZodObject<{
+    jobId: z.ZodString;
+    section: z.ZodDefault<z.ZodEnum<{
+        report: "report";
+        details: "details";
+    }>>;
+}, z.core.$strict>;
+export declare const jobUsageQuerySchema: z.ZodObject<{
+    jobId: z.ZodString;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;

package/lib/shared.js

@@ -15,3 +15,6 @@ export const searchSchema = z.strictObject({ kbId: selector, revision: id.option
 export const readQuerySchema = z.strictObject({ kbId: selector, revision: id.optional(), chunkId: id, query: z.string().max(2000).optional(), keywords: keywordsSchema.optional(), segmentIndex: z.coerce.number().int().nonnegative().optional(), offset: z.coerce.number().int().nonnegative().optional() });
 export const assetQuerySchema = z.strictObject({ kbId: selector, revision: id.optional(), docId: id, assetId: id });
 export const revisionQuerySchema = z.strictObject({ kbId: selector, revision: id.optional() });
+export const jobListQuerySchema = z.strictObject({ jobsKbId: id.optional(), jobOffset: z.coerce.number().int().nonnegative().max(1000000).default(0), jobLimit: z.coerce.number().int().min(1).max(50).default(20) });
+export const jobDetailsQuerySchema = z.strictObject({ jobId: id, section: z.enum(['details', 'report']).default('details') });
+export const jobUsageQuerySchema = jobDetailsQuerySchema.omit({ section: true }).extend({ offset: z.coerce.number().int().nonnegative().max(1000000).default(0), limit: z.coerce.number().int().min(1).max(50).default(20) });

package/lib/skills.js

@@ -3,10 +3,13 @@ import { fileURLToPath } from 'node:url';
 import { checkAbort, required } from "./util.js";
 /** Packaged, invocation-neutral skills; no copies in the operator's user directory. */
 export function skillProvider() {
-    const provider = 'libing-knowledge-base', names = ['libing-knowledge-base', 'libing-kb-build', 'libing-kb-search'];
+    const provider = 'libing-knowledge-base';
+    const names = ['libing-knowledge-base', 'libing-kb-build', 'libing-kb-search'];
     const candidates = names.map(name => {
-        const directory = fileURLToPath(new URL(`../skills/${name}/`, import.meta.url)), path = fileURLToPath(new URL(`../skills/${name}/SKILL.md`, import.meta.url));
-        const raw = readFileSync(path, 'utf8'), header = required(/^---\n([\s\S]*?)\n---\n/u.exec(raw), `skill frontmatter: ${name}`);
+        const directory = fileURLToPath(new URL(`../skills/${name}/`, import.meta.url));
+        const path = fileURLToPath(new URL(`../skills/${name}/SKILL.md`, import.meta.url));
+        const raw = readFileSync(path, 'utf8');
+        const header = required(/^---\n([\s\S]*?)\n---\n/u.exec(raw), `skill frontmatter: ${name}`);
         const description = required(/^description:\s*(.+)$/mu.exec(required(header[1]))?.[1], `skill description: ${name}`);
         return { name, description, source: 'bundled', provider, rank: 600, path, resourceBase: { kind: 'directory', path: directory }, invocation: { modelInvocable: true, userInvocable: true }, locator: path };
     });

package/lib/store.d.ts

@@ -1,9 +1,11 @@
+import { RevisionCache } from './revision-cache.ts';
 import type { Settings } from './config.ts';
 import { z } from 'zod';
 import { registrySchema } from './data.ts';
 import type { Library, Manifest, Snapshot, Chunk, PublishedDocument, BuildDocument, Overlay } from './data.ts';
 export declare const DEFAULT_SCHEMA = "# \u77E5\u8BC6\u5E93\u6CBB\u7406\u7EA6\u5B9A\n\n\u4FDD\u7559\u539F\u6587\u4E2D\u7684\u578B\u53F7\u3001\u7BA1\u811A\u3001\u5355\u4F4D\u3001\u6570\u503C\u3001\u6781\u6027\u548C\u9002\u7528\u6761\u4EF6\u3002\u56FE\u7247\u63CF\u8FF0\u4E0E\u539F\u6587\u5206\u522B\u6807\u6CE8\uFF1B\u4E0D\u786E\u5B9A\u7684\u4FE1\u606F\u4FDD\u7559\u5F85\u590D\u6838\u3002\u6458\u8981\u7528\u4E8E\u5BFC\u822A\uFF0C\u56DE\u7B54\u4F9D\u636E\u539F\u6587\u548C\u53EF\u6838\u9A8C\u56FE\u50CF\u3002\u5F15\u7528\u5305\u542B\u6587\u6863\u7248\u672C\u3001\u7AE0\u8282\u3001\u7247\u6BB5\u548C\u56FE\u8868\u7F16\u53F7\u3002\n";
 export declare class Store {
+    readonly revisionCache: RevisionCache;
     readonly config: Settings;
     readonly root: string;
     private registryTail;
@@ -103,16 +105,88 @@ export declare class Store {
             coverageIncomplete: boolean;
         };
     }>;
-    location(kbId: string, revision?: string): Promise<{
+    private inspectKnown;
+    overview(): Promise<{
+        kbs: ({
+            location: {
+                kbPath: string;
+                revision: null;
+                wikiPath: null;
+                indexPath: null;
+            };
+            summary: {
+                revision: null;
+                documentCount: number;
+                chunkCount: number;
+                coverageIncomplete: boolean;
+            };
+            kbId: string;
+            name: string;
+            createdAt: string;
+            deletedAt?: string | undefined;
+            purge?: {
+                startedAt: string;
+                jobIds: string[];
+                error?: string | undefined;
+            } | undefined;
+        } | {
+            location: {
+                kbPath: string;
+                revision: string;
+                wikiPath: string;
+                indexPath: string;
+            };
+            summary: {
+                revision: string;
+                documentCount: number;
+                chunkCount: number;
+                coverageIncomplete: boolean;
+            };
+            kbId: string;
+            name: string;
+            createdAt: string;
+            deletedAt?: string | undefined;
+            purge?: {
+                startedAt: string;
+                jobIds: string[];
+                error?: string | undefined;
+            } | undefined;
+        })[];
+        deletedKbs: {
+            kbId: string;
+            name: string;
+            createdAt: string;
+            deletedAt?: string | undefined;
+            purge?: {
+                startedAt: string;
+                jobIds: string[];
+                error?: string | undefined;
+            } | undefined;
+        }[];
+        activities: {
+            eventId: string;
+            at: string;
+            action: "purge" | "create" | "trash" | "restore";
+            kbId: string;
+            name: string;
+        }[];
+    }>;
+    snapshotLocation(kbId: string, snapshot: Snapshot): Promise<{
         kbPath: string;
-        revision: null;
-        wikiPath: null;
-        indexPath: null;
-    } | {
+        revision: string;
+        wikiPath: string;
+        indexPath: string;
+    }>;
+    location(kbId: string, revision?: string): Promise<{
         kbPath: string;
         revision: string;
         wikiPath: string;
         indexPath: string;
+    } | {
+        kbPath: string;
+        revision: null;
+        wikiPath: null;
+        indexPath: null;
     }>;
     schema(kbId: string): Promise<string>;
     setSchema(kbId: string, content: string, expectedHash: string): Promise<{
@@ -138,7 +212,22 @@ export declare class Store {
         buildKey: string;
         coverageIncomplete: boolean;
     } | null>;
+    open(selector: string, requested?: string): Promise<{
+        kb: {
+            kbId: string;
+            name: string;
+            createdAt: string;
+            deletedAt?: string | undefined;
+            purge?: {
+                startedAt: string;
+                jobIds: string[];
+                error?: string | undefined;
+            } | undefined;
+        };
+        snapshot: Snapshot;
+    }>;
     revision(kbId: string, requested?: string): Promise<Snapshot>;
+    private revisionKnown;
     readChunk(kbId: string, revision: string | undefined, chunkId: string): Promise<{
         chunk: {
             chunkId: string;
@@ -187,6 +276,10 @@ export declare class Store {
         manifest: Manifest;
     }>;
     chunkContent(snapshot: Snapshot, chunk: Chunk): Promise<string>;
+    chunkView(snapshot: Snapshot, chunk: Chunk, fresh?: boolean): Promise<{
+        content: string;
+        lower: string;
+    }>;
     asset(kbId: string, revision: string | undefined, docId: string, assetId: string): Promise<{
         asset: {
             assetId: string;
@@ -197,6 +290,7 @@ export declare class Store {
             source?: import("./data.ts").Source | undefined;
         };
         file: string;
+        data: Buffer<ArrayBufferLike>;
         doc: {
             docId: string;
             title: string;
@@ -404,6 +498,8 @@ export declare class Store {
     }): Promise<string>;
     overlays(kbId: string): Promise<Record<string, Overlay>>;
     setOverlay(kbId: string, key: string, value: Overlay | null, expectedHash: string): Promise<Overlay | undefined>;
+    /** Cleanup runs with the sole owner before accepting uploads or starting jobs. Inputs are independent copies. */
+    cleanUploads(at?: number): Promise<void>;
     jobDirectories(): Promise<string[]>;
     acquireOwner(): Promise<() => Promise<void>>;
 }