@dsh-libing/knowledge-base 0.1.0

package/lib/settings.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const settingsSchema: z.ZodObject<{
+    dataRoot: z.ZodString;
+    chunkTargetChars: z.ZodDefault<z.ZodNumber>;
+    evidenceMaxChars: z.ZodDefault<z.ZodNumber>;
+    catalogMaxChars: z.ZodDefault<z.ZodNumber>;
+    candidateLimit: z.ZodDefault<z.ZodNumber>;
+    maxInputBytes: z.ZodDefault<z.ZodNumber>;
+    maxUncompressedBytes: z.ZodDefault<z.ZodNumber>;
+    maxArchiveEntries: z.ZodDefault<z.ZodNumber>;
+    modelTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    modelAttempts: z.ZodDefault<z.ZodNumber>;
+    visionConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxModelCalls: z.ZodDefault<z.ZodNumber>;
+    maxModelTokens: z.ZodDefault<z.ZodNumber>;
+    visionMaxEdge: z.ZodDefault<z.ZodNumber>;
+    visionTileSize: z.ZodDefault<z.ZodNumber>;
+    visionMaxTiles: z.ZodDefault<z.ZodNumber>;
+    modelMaxOutputTokens: z.ZodDefault<z.ZodNumber>;
+    summaryMaxChars: z.ZodDefault<z.ZodNumber>;
+    figureMaxChars: z.ZodDefault<z.ZodNumber>;
+    pdfMaxPages: z.ZodDefault<z.ZodNumber>;
+    pdfMaxPagePixels: z.ZodDefault<z.ZodNumber>;
+    pdfPageTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    libreOfficePath: z.ZodDefault<z.ZodString>;
+    visionProvider: z.ZodDefault<z.ZodString>;
+    visionModel: z.ZodDefault<z.ZodString>;
+    summaryProvider: z.ZodDefault<z.ZodString>;
+    summaryModel: z.ZodDefault<z.ZodString>;
+    skipImages: z.ZodDefault<z.ZodBoolean>;
+    acceptPartial: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Settings = z.output<typeof settingsSchema>;

package/lib/settings.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+const positive = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+export const settingsSchema = z.strictObject({
+    dataRoot: z.string().min(1),
+    chunkTargetChars: positive.min(256).max(60000).default(6000), evidenceMaxChars: positive.min(512).default(12000),
+    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),
+    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) => {
+    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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const API = "/api/libing-knowledge-base";
+export declare const buildSchema: z.ZodObject<{
+    kbId: z.ZodString;
+    createKb: z.ZodOptional<z.ZodBoolean>;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    receiptId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    sourceVersion: z.ZodOptional<z.ZodString>;
+    docId: z.ZodOptional<z.ZodString>;
+    chunkTargetChars: z.ZodOptional<z.ZodNumber>;
+    pageStart: z.ZodOptional<z.ZodNumber>;
+    pageEnd: z.ZodOptional<z.ZodNumber>;
+    confirmRangeChange: z.ZodOptional<z.ZodBoolean>;
+    visionProvider: z.ZodOptional<z.ZodString>;
+    visionModel: z.ZodOptional<z.ZodString>;
+    summaryProvider: z.ZodOptional<z.ZodString>;
+    summaryModel: z.ZodOptional<z.ZodString>;
+    skipImages: z.ZodOptional<z.ZodBoolean>;
+    acceptPartial: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const browserBuildSchema: z.ZodObject<{
+    chunkTargetChars: z.ZodOptional<z.ZodNumber>;
+    visionProvider: z.ZodOptional<z.ZodString>;
+    visionModel: z.ZodOptional<z.ZodString>;
+    summaryProvider: z.ZodOptional<z.ZodString>;
+    summaryModel: z.ZodOptional<z.ZodString>;
+    skipImages: z.ZodOptional<z.ZodBoolean>;
+    acceptPartial: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    docId: z.ZodOptional<z.ZodString>;
+    sourceVersion: z.ZodOptional<z.ZodString>;
+    kbId: z.ZodString;
+    pageStart: z.ZodOptional<z.ZodNumber>;
+    pageEnd: z.ZodOptional<z.ZodNumber>;
+    confirmRangeChange: z.ZodOptional<z.ZodBoolean>;
+    receiptId: z.ZodString;
+}, z.core.$strict>;
+export type BuildArgs = z.infer<typeof buildSchema> & {
+    sourceFilename?: string | undefined;
+    figureRefresh?: {
+        occurrenceId: string;
+        token: string;
+    } | undefined;
+};
+export declare const jobActionSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    action: z.ZodDefault<z.ZodEnum<{
+        status: "status";
+        retry: "retry";
+        cancel: "cancel";
+    }>>;
+    acceptPartial: z.ZodOptional<z.ZodBoolean>;
+    maxModelCalls: z.ZodOptional<z.ZodNumber>;
+    maxModelTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type JobOptions = Pick<z.infer<typeof jobActionSchema>, 'acceptPartial' | 'maxModelCalls' | 'maxModelTokens'>;
+export declare const catalogQuerySchema: z.ZodObject<{
+    kbId: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodString>;
+    docId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type CatalogArgs = z.infer<typeof catalogQuerySchema>;
+export declare const keywordsSchema: z.ZodArray<z.ZodString>;
+export declare const searchSchema: z.ZodObject<{
+    kbId: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
+    docId: z.ZodOptional<z.ZodString>;
+    query: z.ZodString;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SearchArgs = z.infer<typeof searchSchema>;
+export declare const readQuerySchema: z.ZodObject<{
+    kbId: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
+    chunkId: z.ZodString;
+    query: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segmentIndex: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type ReadArgs = z.infer<typeof readQuerySchema>;
+export declare const assetQuerySchema: z.ZodObject<{
+    kbId: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
+    docId: z.ZodString;
+    assetId: z.ZodString;
+}, z.core.$strict>;
+export declare const revisionQuerySchema: z.ZodObject<{
+    kbId: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/lib/shared.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const API = '/api/libing-knowledge-base';
+const id = z.string().regex(/^[a-z0-9][a-z0-9-]{0,95}$/u);
+const selector = z.string().trim().min(1).max(120);
+const positive = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+export const buildSchema = z.strictObject({ kbId: selector, createKb: z.boolean().optional(), sourcePath: z.string().min(1).max(4000).optional(), receiptId: id.optional(),
+    title: z.string().trim().min(1).max(300).optional(), sourceVersion: z.string().trim().min(1).max(120).optional(), docId: id.max(80).optional(), chunkTargetChars: positive.min(256).max(60000).optional(),
+    pageStart: positive.optional(), pageEnd: positive.optional(), confirmRangeChange: z.boolean().optional(), visionProvider: z.string().optional(), visionModel: z.string().optional(),
+    summaryProvider: z.string().optional(), summaryModel: z.string().optional(), skipImages: z.boolean().optional(), acceptPartial: z.boolean().optional() });
+export const browserBuildSchema = buildSchema.omit({ sourcePath: true, createKb: true }).extend({ receiptId: id });
+export const jobActionSchema = z.strictObject({ jobId: id, action: z.enum(['status', 'retry', 'cancel']).default('status'), acceptPartial: z.boolean().optional(), maxModelCalls: positive.optional(), maxModelTokens: positive.optional() });
+export const catalogQuerySchema = z.strictObject({ kbId: selector.optional(), revision: id.optional(), docId: id.optional(), nodeId: id.optional(), page: z.coerce.number().int().nonnegative().optional() });
+export const keywordsSchema = z.array(z.string().max(100)).max(32);
+export const searchSchema = z.strictObject({ kbId: selector, revision: id.optional(), docId: id.optional(), query: z.string().trim().min(1).max(2000), keywords: keywordsSchema.optional(), limit: positive.max(30).optional() });
+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() });

package/lib/skills.d.ts

@@ -0,0 +1,3 @@
+import type { SkillProvider } from '@deepseek-ai/dsh-skill';
+/** Packaged, invocation-neutral skills; no copies in the operator's user directory. */
+export declare function skillProvider(): SkillProvider;

package/lib/skills.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+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 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 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 };
+    });
+    return { name: provider, list: async (options) => { checkAbort(options.signal); return candidates; }, get: async (candidate, options) => {
+            checkAbort(options.signal);
+            const owned = candidates.find(value => value.name === candidate.name && value.locator === candidate.locator);
+            if (!owned || typeof owned.locator !== 'string')
+                return undefined;
+            const { rank: _rank, locator: _locator, ...summary } = owned;
+            return { ...summary, content: readFileSync(owned.locator, 'utf8').replace(/^---\n[\s\S]*?\n---\n/u, '').trim() };
+        } };
+}

package/lib/store.d.ts

@@ -0,0 +1,409 @@
+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 config: Settings;
+    readonly root: string;
+    private registryTail;
+    constructor(config: Settings);
+    init(): Promise<void>;
+    serialized<T>(fn: () => Promise<T>): Promise<T>;
+    list(includeDeleted?: boolean): Promise<Library[]>;
+    deleted(): Promise<{
+        kbId: string;
+        name: string;
+        createdAt: string;
+        deletedAt?: string | undefined;
+        purge?: {
+            startedAt: string;
+            jobIds: string[];
+            error?: string | undefined;
+        } | undefined;
+    }[]>;
+    activities(): Promise<{
+        eventId: string;
+        at: string;
+        action: "purge" | "create" | "trash" | "restore";
+        kbId: string;
+        name: string;
+    }[]>;
+    record(registry: z.infer<typeof registrySchema>, action: 'create' | 'trash' | 'restore' | 'purge', kb: Library): void;
+    trash(kbId: string, expectedName: string): Promise<{
+        kbId: string;
+        name: string;
+        createdAt: string;
+        deletedAt?: string | undefined;
+        purge?: {
+            startedAt: string;
+            jobIds: string[];
+            error?: string | undefined;
+        } | undefined;
+    }>;
+    restore(kbId: string): Promise<{
+        kbId: string;
+        name: string;
+        createdAt: string;
+        deletedAt?: string | undefined;
+        purge?: {
+            startedAt: string;
+            jobIds: string[];
+            error?: string | undefined;
+        } | undefined;
+    }>;
+    purgeTarget(group: 'kbs' | 'jobs', key: string): Promise<string>;
+    removePurgeTree(path: string): Promise<void>;
+    purge(kbId: string, expectedName: string, confirmed: boolean, jobIds?: string[]): Promise<{
+        kbId: string;
+        name: string;
+        purged: boolean;
+    }>;
+    kb(selector: string): Promise<{
+        kbId: string;
+        name: string;
+        createdAt: string;
+        deletedAt?: string | undefined;
+        purge?: {
+            startedAt: string;
+            jobIds: string[];
+            error?: string | undefined;
+        } | undefined;
+    }>;
+    create(name: string): Promise<{
+        kbId: string;
+        name: string;
+        createdAt: string;
+    }>;
+    kbRoot(kbId: string): string;
+    inspect(kbId: string, revision?: string): Promise<{
+        location: {
+            kbPath: string;
+            revision: null;
+            wikiPath: null;
+            indexPath: null;
+        };
+        summary: {
+            revision: null;
+            documentCount: number;
+            chunkCount: number;
+            coverageIncomplete: boolean;
+        };
+    } | {
+        location: {
+            kbPath: string;
+            revision: string;
+            wikiPath: string;
+            indexPath: string;
+        };
+        summary: {
+            revision: string;
+            documentCount: number;
+            chunkCount: number;
+            coverageIncomplete: boolean;
+        };
+    }>;
+    location(kbId: string, revision?: string): Promise<{
+        kbPath: string;
+        revision: null;
+        wikiPath: null;
+        indexPath: null;
+    } | {
+        kbPath: string;
+        revision: string;
+        wikiPath: string;
+        indexPath: string;
+    }>;
+    schema(kbId: string): Promise<string>;
+    setSchema(kbId: string, content: string, expectedHash: string): Promise<{
+        content: string;
+        hash: string;
+    }>;
+    upload(data: Buffer, filename: string): Promise<{
+        receiptId: string;
+        filename: string;
+        bytes: number;
+    }>;
+    uploaded(receiptId: string): Promise<{
+        data: Buffer<ArrayBufferLike>;
+        receiptId: string;
+        filename: string;
+        createdAt: string;
+        bytes: number;
+        hash: string;
+    }>;
+    current(kbId: string): Promise<{
+        revision: string;
+        publishedAt: string;
+        buildKey: string;
+        coverageIncomplete: boolean;
+    } | null>;
+    revision(kbId: string, requested?: string): Promise<Snapshot>;
+    readChunk(kbId: string, revision: string | undefined, chunkId: string): Promise<{
+        chunk: {
+            chunkId: string;
+            docId: string;
+            sourceHash: string;
+            sourceVersion: string;
+            title: string;
+            nodeId: string;
+            headingPath: string[];
+            blockRange: [string, string];
+            assetRefs: string[];
+            tableRefs: string[];
+            relatedChunks: string[];
+            reviewStatus: "source" | "generated" | "needs-review";
+            path: string;
+            segments: {
+                text: string;
+                blockIds: string[];
+                type: "code" | "caption" | "table" | "heading" | "paragraph" | "figure" | "list" | "note" | "formula";
+                sourceLocations?: import("./data.ts").Source[] | undefined;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+            }[];
+            anchors: string[];
+            fullChars: number;
+            bodyChars: number;
+            contentHash: string;
+            summary: string;
+            keywords: string[];
+            sourceFormat?: "docx" | "pdf" | undefined;
+            sourceLocations?: import("./data.ts").Source[] | undefined;
+            pageRange?: [number, number] | undefined;
+            selectedPages?: {
+                start: number;
+                end: number;
+                count: number;
+                total: number;
+                partial: boolean;
+            } | undefined;
+            oversizedReason?: string | undefined;
+            summaryFallback?: boolean | undefined;
+        };
+        content: string;
+        root: string;
+        revision: string;
+        manifest: Manifest;
+    }>;
+    chunkContent(snapshot: Snapshot, chunk: Chunk): Promise<string>;
+    asset(kbId: string, revision: string | undefined, docId: string, assetId: string): Promise<{
+        asset: {
+            assetId: string;
+            mime: string;
+            path: string;
+            bytes: number;
+            origin: string;
+            source?: import("./data.ts").Source | undefined;
+        };
+        file: string;
+        doc: {
+            docId: string;
+            title: string;
+            filename: string;
+            sourceHash: string;
+            sourceVersion: string;
+            nodes: {
+                nodeId: string;
+                title: string;
+                level: number;
+                parentId: string | null;
+                headingPath: string[];
+                children: string[];
+                anchor?: string | null | undefined;
+                indexPath?: string | undefined;
+            }[];
+            chunks: {
+                chunkId: string;
+                docId: string;
+                sourceHash: string;
+                sourceVersion: string;
+                title: string;
+                nodeId: string;
+                headingPath: string[];
+                blockRange: [string, string];
+                assetRefs: string[];
+                tableRefs: string[];
+                relatedChunks: string[];
+                reviewStatus: "source" | "generated" | "needs-review";
+                path: string;
+                segments: {
+                    text: string;
+                    blockIds: string[];
+                    type: "code" | "caption" | "table" | "heading" | "paragraph" | "figure" | "list" | "note" | "formula";
+                    sourceLocations?: import("./data.ts").Source[] | undefined;
+                    startLine?: number | undefined;
+                    endLine?: number | undefined;
+                }[];
+                anchors: string[];
+                fullChars: number;
+                bodyChars: number;
+                contentHash: string;
+                summary: string;
+                keywords: string[];
+                sourceFormat?: "docx" | "pdf" | undefined;
+                sourceLocations?: import("./data.ts").Source[] | undefined;
+                pageRange?: [number, number] | undefined;
+                selectedPages?: {
+                    start: number;
+                    end: number;
+                    count: number;
+                    total: number;
+                    partial: boolean;
+                } | undefined;
+                oversizedReason?: string | undefined;
+                summaryFallback?: boolean | undefined;
+            }[];
+            assets: {
+                assetId: string;
+                mime: string;
+                path: string;
+                bytes: number;
+                origin: string;
+                source?: import("./data.ts").Source | undefined;
+            }[];
+            figures: {
+                status: "decoration" | "generated" | "failed" | "skipped" | "ignored" | "reviewed";
+                assetId: string;
+                occurrenceId: string;
+                caption: string;
+                cacheKey: string;
+                overlayKey: string;
+                overlayHash: string;
+                humanReviewed: boolean;
+                needsReview: boolean;
+                types?: ("architecture" | "pinout" | "schematic" | "timing" | "flowchart" | "table" | "curve" | "other" | "decoration")[] | undefined;
+                visibleLabels?: string[] | undefined;
+                description?: string | undefined;
+                relations?: {
+                    from: string;
+                    to: string;
+                    label: string;
+                }[] | undefined;
+                uncertainties?: string[] | undefined;
+                contextNotes?: string | undefined;
+                pins?: z.core.util.JSONType[] | undefined;
+                timingConstraints?: z.core.util.JSONType[] | undefined;
+                tableRows?: z.core.util.JSONType[] | undefined;
+                error?: string | undefined;
+                classification?: {
+                    types: ("architecture" | "pinout" | "schematic" | "timing" | "flowchart" | "table" | "curve" | "other" | "decoration")[];
+                    reason: string;
+                } | undefined;
+                width?: number | undefined;
+                height?: number | undefined;
+                model?: {
+                    provider: string;
+                    model: string;
+                } | undefined;
+                promptVersion?: string | undefined;
+                context?: {
+                    headingPath: string[];
+                    nearby: string[];
+                    caption?: string | undefined;
+                } | undefined;
+                source?: import("./data.ts").Source | undefined;
+                nativeLabels?: string[] | undefined;
+                refreshToken?: string | undefined;
+                ignore?: boolean | undefined;
+                skip?: boolean | undefined;
+                previous?: Overlay | null | undefined;
+                updatedAt?: string | undefined;
+            }[];
+            sourceFormat?: "docx" | "pdf" | undefined;
+            pageCount?: number | undefined;
+            selectedPages?: {
+                start: number;
+                end: number;
+                count: number;
+                total: number;
+                partial: boolean;
+            } | undefined;
+            parserVersion?: string | undefined;
+            audit?: {
+                pages: {
+                    page: number;
+                    status: "failed" | "needs-review" | "navigation" | "parsed";
+                    ocr: boolean;
+                    tables: number;
+                    figures: number;
+                    headings: {
+                        text: string;
+                        level: number;
+                        basis?: string | undefined;
+                    }[];
+                    width?: number | undefined;
+                    height?: number | undefined;
+                    pageLabel?: string | null | undefined;
+                    spanCount?: number | undefined;
+                    artifactCount?: number | undefined;
+                    excluded?: {
+                        kind: string;
+                        bbox: [number, number, number, number] | null;
+                        text?: string | undefined;
+                    }[] | undefined;
+                    previewAssetId?: string | null | undefined;
+                    error?: string | undefined;
+                }[];
+                outlineCount: number;
+                matchedBookmarks: number;
+                convertedFigures: number;
+                convertedTables: number;
+                warnings?: {
+                    code: string;
+                    message: string;
+                    blocking: boolean;
+                    page?: number | undefined;
+                    kind?: string | undefined;
+                    snippet?: string | undefined;
+                    reason?: string | undefined;
+                }[] | undefined;
+                styleLevels?: Record<string, number> | undefined;
+                headingLevels?: Record<string, number> | undefined;
+                outlineLevels?: Record<string, number> | undefined;
+                expectedFigures?: number | undefined;
+                expectedTables?: number | undefined;
+                expectedHeadings?: string[] | undefined;
+                textBoxes?: number | undefined;
+                footnoteRefs?: number | undefined;
+                anchors?: string[] | undefined;
+                rawMediaCount?: number | undefined;
+            } | undefined;
+            chunkTargetChars?: number | undefined;
+            coverageIncomplete?: boolean | undefined;
+            warnings?: {
+                code: string;
+                message: string;
+                blocking: boolean;
+                page?: number | undefined;
+                kind?: string | undefined;
+                snippet?: string | undefined;
+                reason?: string | undefined;
+            }[] | undefined;
+        };
+        root: string;
+        revision: string;
+        manifest: Manifest;
+    }>;
+    rawSnapshot(kbId: string, docId: string, sourceHash: string, data: Buffer, info: {
+        sourceFormat: string;
+        [key: string]: unknown;
+    }): Promise<{
+        root: string;
+        file: string;
+    }>;
+    rawSource(kbId: string, doc: PublishedDocument): Promise<{
+        file: string;
+        data: Buffer<ArrayBufferLike>;
+    }>;
+    carryPrevious(kbId: string, destination: string, replaceDocId: string): Promise<BuildDocument[]>;
+    publish(kbId: string, revision: string, stage: string, manifest: Manifest, operation: {
+        jobId: string;
+        kind: string;
+        docId: string;
+    }): Promise<string>;
+    overlays(kbId: string): Promise<Record<string, Overlay>>;
+    setOverlay(kbId: string, key: string, value: Overlay | null, expectedHash: string): Promise<Overlay | undefined>;
+    jobDirectories(): Promise<string[]>;
+    acquireOwner(): Promise<() => Promise<void>>;
+}