@oscharko-dev/keiko-local-knowledge 0.2.0

package/dist/discovery/extract-progressive.js

@@ -0,0 +1,522 @@
+// Progressive large-document extraction wiring (Epic #1160, Issue #1286).
+//
+// Routes a preflight-classified large document through the page-windowed ProgressiveExtractor and
+// persists each window in its own transaction so the JS working set never holds the whole document
+// text and an interrupted job leaves durable, resumable progress. Extracted text is stored as
+// bounded per-window rows (document_text_windows) instead of a single document_texts column; the
+// orchestrator's bounded chunk/embed pass reads it back through readDocumentTextSpan.
+//
+// Extraction resumes from the durable page/text-window checkpoint when the source, parser, policy,
+// chunking, and embedding fingerprint remain compatible. Chunking/embedding resume still happens
+// downstream through chunk/vector coverage reconciliation.
+import { checkpointCompatibility, LARGE_DOCUMENT_DIAGNOSTIC_CODES, largeDocumentPolicyFingerprint, } from "@oscharko-dev/keiko-contracts";
+import { getCapsule } from "../capsule-lifecycle.js";
+import { runProgressiveExtraction, } from "../parsers/index.js";
+import { selectExtractionCheckpoint, upsertExtractionCheckpoint, } from "../indexing/checkpoint-persist.js";
+import { basenameOf, extensionOf, mediaTypeFor } from "./media-type.js";
+import { deleteDependentRows, insertDiagnosticRow, insertDocumentRow, insertDocumentTextWindowRow, insertPageRow, insertParsedUnitRow, updateDocumentStatusRow, } from "./persist.js";
+import { documentIdFor } from "./types.js";
+import { redactDiagnosticMessage } from "../privacy/diagnostic-redactor.js";
+export function selectProgressiveExtractor(context, extension, mediaType) {
+    return context.extractors.find((e) => e.matches({ extension, mediaType }));
+}
+function checkpointFor(deps, state, phase, coverage, diagnostics) {
+    const at = deps.now();
+    upsertExtractionCheckpoint(deps.store._internal.db, {
+        capsuleId: deps.capsuleId,
+        documentId: deps.documentId,
+        jobId: deps.jobId,
+        strategy: deps.strategy,
+        phase,
+        pageCursor: state.pageCursor,
+        sectionCursor: 0,
+        objectCursor: state.objectCursor,
+        extractedTextBytes: state.extractedTextBytes,
+        chunkCursor: 0,
+        embeddedChunkCursor: 0,
+        retryCount: deps.retryCount,
+        coverage,
+        fingerprint: deps.fingerprint,
+        terminalDiagnostics: diagnostics,
+        createdAt: deps.createdAt,
+        updatedAt: at,
+    });
+}
+// Persists one window in its own transaction: pages + parsed units + the bounded text window, then
+// advances the checkpoint. Never retains more than this window's text.
+function persistWindow(deps, state, window) {
+    const db = deps.store._internal.db;
+    db.exec("BEGIN");
+    try {
+        for (const page of window.pages)
+            insertPageRow(db, deps.capsuleId, page);
+        for (const unit of window.units) {
+            insertParsedUnitRow(db, deps.store._internal.contentCipher, deps.capsuleId, `${String(deps.documentId)}#u${String(state.unitIndex)}`, unit);
+            state.unitIndex += 1;
+        }
+        insertDocumentTextWindowRow(db, deps.store._internal.contentCipher, {
+            capsuleId: deps.capsuleId,
+            documentId: deps.documentId,
+            windowIndex: state.windowIndex,
+            characterStart: window.characterStart,
+            characterEnd: window.characterStart + window.text.length,
+            normalizedText: window.text,
+        });
+        state.windowIndex += 1;
+        state.pageCursor = window.lastPageNumber;
+        state.objectCursor = window.objectCursor;
+        state.characterCursor = window.characterStart + window.text.length;
+        state.extractedTextBytes += Buffer.byteLength(window.text, "utf8");
+        checkpointFor(deps, state, "extracting", "partial", []);
+        db.exec("COMMIT");
+    }
+    catch (cause) {
+        db.exec("ROLLBACK");
+        throw cause;
+    }
+}
+function persistDiagnostics(deps, diagnostics) {
+    const db = deps.store._internal.db;
+    diagnostics.forEach((diagnostic, index) => {
+        insertDiagnosticRow(db, {
+            id: `${String(deps.documentId)}#d${String(index)}`,
+            capsuleId: deps.capsuleId,
+            diagnostic: { ...diagnostic, documentId: deps.documentId },
+            createdAt: deps.now(),
+        });
+    });
+}
+function documentStatusFor(summary) {
+    if (summary.stopReason === "cancelled")
+        return "pending";
+    return summary.pageCount > 0 ? "extracted" : "unsupported";
+}
+function finalizePhaseFor(summary) {
+    if (summary.stopReason === "cancelled")
+        return "cancelled";
+    return "extracted";
+}
+// Finalizes a progressive extraction: updates the document status, persists redacted diagnostics,
+// and writes the terminal extraction checkpoint with the measured coverage.
+function finalize(deps, state, summary, diagnostics) {
+    const db = deps.store._internal.db;
+    const status = documentStatusFor(summary);
+    db.exec("BEGIN");
+    try {
+        updateDocumentStatusRow(db, deps.capsuleId, deps.documentId, status);
+        persistDiagnostics(deps, diagnostics);
+        checkpointFor(deps, state, finalizePhaseFor(summary), summary.coverage, diagnostics);
+        db.exec("COMMIT");
+    }
+    catch (cause) {
+        db.exec("ROLLBACK");
+        throw cause;
+    }
+    return status;
+}
+function buildFingerprint(context, extractor, contentHash, embeddingIdentity) {
+    return {
+        sourceContentHash: contentHash,
+        parserVersion: `${extractor.strategyId}@${extractor.parserVersion}`,
+        policyFingerprint: largeDocumentPolicyFingerprint(context.policy),
+        chunkingStrategyVersion: context.chunkingStrategyVersion,
+        embeddingIdentity,
+    };
+}
+function parserDiagnostic(code, message, documentId, severity = "warning") {
+    return { code, message, severity, documentId };
+}
+function redactionPrefixFor(params) {
+    const { scope } = params.source;
+    if (scope.kind === "folder")
+        return scope.rootPath;
+    if (scope.kind === "repository")
+        return scope.repositoryRoot;
+    return scope.rootPath;
+}
+function redactDiagnostic(diagnostic, params) {
+    return {
+        ...diagnostic,
+        message: redactDiagnosticMessage(diagnostic.message, redactionPrefixFor(params)),
+    };
+}
+function redactDiagnostics(diagnostics, params) {
+    return diagnostics.map((diagnostic) => redactDiagnostic(diagnostic, params));
+}
+function checkpointIncompatibleDiagnostic(documentId, reasons) {
+    return parserDiagnostic(LARGE_DOCUMENT_DIAGNOSTIC_CODES.CHECKPOINT_INCOMPATIBLE, `resume refused and restarted; changed: ${reasons.join(", ")}`, documentId, "warning");
+}
+function retryLimitDiagnostic(documentId) {
+    return parserDiagnostic(LARGE_DOCUMENT_DIAGNOSTIC_CODES.RESOURCE_POLICY_EXCEEDED, "large-document retry count exceeded the configured resource policy", documentId, "error");
+}
+function parserFailureDiagnostic(documentId) {
+    return parserDiagnostic("MALFORMED_INPUT", "progressive parser rejected malformed or unsupported document", documentId, "error");
+}
+function multimodalCapabilityDiagnostic(documentId) {
+    return parserDiagnostic(LARGE_DOCUMENT_DIAGNOSTIC_CODES.MULTIMODAL_CAPABILITY_UNAVAILABLE, "page image and diagram semantics were not extracted because no multimodal capability is configured; indexed with text-only coverage", documentId, "warning");
+}
+function capabilityDiagnostics(context, params, documentId, summary) {
+    if (summary.pageCount === 0)
+        return [];
+    if (mediaTypeFor(extensionOf(params.file.relativePath)) !== "application/pdf")
+        return [];
+    if (context.capabilities.multimodal === "available")
+        return [];
+    return [multimodalCapabilityDiagnostic(documentId)];
+}
+function coverageWithDiagnostics(base, diagnostics) {
+    if (diagnostics.some((diagnostic) => diagnostic.code === LARGE_DOCUMENT_DIAGNOSTIC_CODES.PARTIAL_COVERAGE ||
+        diagnostic.code === LARGE_DOCUMENT_DIAGNOSTIC_CODES.OCR_CAPABILITY_UNAVAILABLE)) {
+        return base === "none" ? "none" : "partial";
+    }
+    if (base === "complete" &&
+        diagnostics.some((diagnostic) => diagnostic.code === LARGE_DOCUMENT_DIAGNOSTIC_CODES.MULTIMODAL_CAPABILITY_UNAVAILABLE)) {
+        return "text-only";
+    }
+    return base;
+}
+function countRows(store, table, capsuleId, documentId) {
+    const row = store._internal.db
+        .prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE capsule_id = :c AND document_id = :d`)
+        .get({ c: String(capsuleId), d: String(documentId) });
+    return row.n;
+}
+function maxWindowCharacterEnd(store, capsuleId, documentId) {
+    const row = store._internal.db
+        .prepare("SELECT COALESCE(MAX(character_end), 0) AS n FROM document_text_windows WHERE capsule_id = :c AND document_id = :d")
+        .get({ c: String(capsuleId), d: String(documentId) });
+    return row.n;
+}
+function progressiveDocumentRecord(params, documentId, extractor, contentHash, status, now) {
+    return {
+        id: documentId,
+        capsuleId: params.capsuleId,
+        sourceId: params.source.id,
+        documentPath: params.file.relativePath,
+        sizeBytes: params.file.sizeBytes,
+        mediaType: mediaTypeFor(extensionOf(params.file.relativePath)),
+        contentHash,
+        parser: extractor.dependencyVersions === undefined
+            ? { parserId: extractor.strategyId, parserVersion: extractor.parserVersion }
+            : {
+                parserId: extractor.strategyId,
+                parserVersion: extractor.parserVersion,
+                dependencyVersions: extractor.dependencyVersions,
+            },
+        lastExtractedAt: now,
+        status,
+        safeDisplayName: basenameOf(params.file.relativePath),
+    };
+}
+function progressiveResult(params, document, summary) {
+    if (summary.stopReason === "cancelled") {
+        return {
+            capsuleId: params.capsuleId,
+            sourceId: params.source.id,
+            relativePath: params.file.relativePath,
+            outcome: {
+                kind: "failed",
+                document,
+                error: {
+                    code: "CANCELLED",
+                    message: "progressive extraction cancelled with persisted partial progress",
+                    relativePath: params.file.relativePath,
+                },
+            },
+            diagnostics: summary.diagnostics,
+        };
+    }
+    return {
+        capsuleId: params.capsuleId,
+        sourceId: params.source.id,
+        relativePath: params.file.relativePath,
+        outcome: { kind: "persisted", document },
+        diagnostics: summary.diagnostics,
+    };
+}
+// Inserts the document row (pending) and clears prior dependents/windows before the first window so
+// the page/parsed-unit foreign keys resolve and a re-extract is idempotent.
+function insertPendingDocument(sinkDeps, params, extractor, contentHash, state) {
+    const db = sinkDeps.store._internal.db;
+    db.exec("BEGIN");
+    try {
+        insertDocumentRow(db, {
+            id: sinkDeps.documentId,
+            capsuleId: params.capsuleId,
+            sourceId: sinkDeps.sourceId,
+            documentPath: params.file.relativePath,
+            sizeBytes: params.file.sizeBytes,
+            mediaType: mediaTypeFor(extensionOf(params.file.relativePath)),
+            contentHash,
+            parserId: extractor.strategyId,
+            parserVersion: extractor.parserVersion,
+            lastExtractedAt: sinkDeps.now(),
+            status: "pending",
+            safeDisplayName: basenameOf(params.file.relativePath),
+        });
+        deleteDependentRows(db, params.capsuleId, sinkDeps.documentId);
+        checkpointFor(sinkDeps, state, "extracting", "none", []);
+        db.exec("COMMIT");
+    }
+    catch (cause) {
+        db.exec("ROLLBACK");
+        throw cause;
+    }
+}
+function persistStandaloneDiagnostic(deps, diagnostic, suffix) {
+    insertDiagnosticRow(deps.store._internal.db, {
+        id: `${String(deps.documentId)}#${suffix}`,
+        capsuleId: deps.capsuleId,
+        diagnostic,
+        createdAt: deps.now(),
+    });
+}
+function insertProgressiveFailureRows(deps, params, extractor, contentHash, state, diagnostic) {
+    const db = deps.store._internal.db;
+    const now = deps.now();
+    const redactedDiagnostic = redactDiagnostic(diagnostic, params);
+    db.exec("BEGIN");
+    try {
+        insertDocumentRow(db, {
+            id: deps.documentId,
+            capsuleId: params.capsuleId,
+            sourceId: deps.sourceId,
+            documentPath: params.file.relativePath,
+            sizeBytes: params.file.sizeBytes,
+            mediaType: mediaTypeFor(extensionOf(params.file.relativePath)),
+            contentHash,
+            parserId: extractor.strategyId,
+            parserVersion: extractor.parserVersion,
+            lastExtractedAt: now,
+            status: "failed",
+            safeDisplayName: basenameOf(params.file.relativePath),
+        });
+        insertDiagnosticRow(db, {
+            id: `${String(deps.documentId)}#progressive-failure`,
+            capsuleId: params.capsuleId,
+            diagnostic: redactedDiagnostic,
+            createdAt: now,
+        });
+        checkpointFor(deps, state, "failed", state.pageCursor > 0 ? "partial" : "none", [
+            redactedDiagnostic,
+        ]);
+        db.exec("COMMIT");
+    }
+    catch (cause) {
+        db.exec("ROLLBACK");
+        throw cause;
+    }
+    return redactedDiagnostic;
+}
+function progressiveFailureResult(deps, params, extractor, contentHash, diagnostic) {
+    const document = progressiveDocumentRecord(params, deps.documentId, extractor, contentHash, "failed", deps.now());
+    return {
+        capsuleId: params.capsuleId,
+        sourceId: params.source.id,
+        relativePath: params.file.relativePath,
+        outcome: {
+            kind: "failed",
+            document,
+            error: {
+                code: "PARSER_FAILED",
+                message: diagnostic.message,
+                relativePath: params.file.relativePath,
+            },
+        },
+        diagnostics: [diagnostic],
+    };
+}
+function persistProgressiveFailure(deps, params, extractor, contentHash, state, diagnostic) {
+    const redactedDiagnostic = insertProgressiveFailureRows(deps, params, extractor, contentHash, state, diagnostic);
+    return progressiveFailureResult(deps, params, extractor, contentHash, redactedDiagnostic);
+}
+function extractionOptionsFor(params, context, documentId, now, state, resume) {
+    const extension = extensionOf(params.file.relativePath);
+    return {
+        documentId,
+        extension,
+        mediaType: mediaTypeFor(extension),
+        policy: context.policy,
+        now,
+        ...(context.signal === undefined ? {} : { signal: context.signal }),
+        ...(resume
+            ? {
+                resumeFromPage: state.pageCursor,
+                resumeCharacterStart: state.characterCursor,
+                resumeWindowIndex: state.windowIndex,
+                resumeObjectCursor: state.objectCursor,
+                resumeExtractedTextBytes: state.extractedTextBytes,
+            }
+            : {}),
+    };
+}
+function buildSinkDeps(deps, params, context, extractor, documentId, contentHash, retryCount, createdAt) {
+    const capsule = getCapsule(deps.store, params.capsuleId);
+    if (capsule === undefined) {
+        throw new Error(`progressive extraction requires an existing capsule: ${String(params.capsuleId)}`);
+    }
+    return {
+        store: deps.store,
+        capsuleId: params.capsuleId,
+        sourceId: String(params.source.id),
+        documentId,
+        jobId: context.jobId,
+        strategy: extractor.strategyId,
+        fingerprint: buildFingerprint(context, extractor, contentHash, capsule.embeddingModelIdentity),
+        retryCount,
+        createdAt,
+        now: deps.store._internal.now,
+    };
+}
+function emptySinkState() {
+    return {
+        unitIndex: 0,
+        windowIndex: 0,
+        pageCursor: 0,
+        objectCursor: 0,
+        characterCursor: 0,
+        extractedTextBytes: 0,
+    };
+}
+function checkpointSinkState(store, params, documentId, checkpoint) {
+    return {
+        unitIndex: countRows(store, "parsed_units", params.capsuleId, documentId),
+        windowIndex: countRows(store, "document_text_windows", params.capsuleId, documentId),
+        pageCursor: checkpoint?.pageCursor ?? 0,
+        objectCursor: checkpoint?.objectCursor ?? 0,
+        characterCursor: maxWindowCharacterEnd(store, params.capsuleId, documentId),
+        extractedTextBytes: checkpoint?.extractedTextBytes ?? 0,
+    };
+}
+function planForMissingCheckpoint(createdAt) {
+    return {
+        state: emptySinkState(),
+        retryCount: 0,
+        createdAt,
+        resume: false,
+        startupDiagnostics: [],
+    };
+}
+function retryExceededPlan(deps, params, context, extractor, contentHash, provisional, existing, state, retryCount) {
+    const sinkDeps = buildSinkDeps(deps, params, context, extractor, provisional.documentId, contentHash, retryCount, existing.createdAt);
+    return {
+        state,
+        retryCount,
+        createdAt: existing.createdAt,
+        resume: false,
+        startupDiagnostics: [],
+        failure: persistProgressiveFailure(sinkDeps, params, extractor, contentHash, state, retryLimitDiagnostic(provisional.documentId)),
+    };
+}
+function planForExistingCheckpoint(deps, params, context, extractor, contentHash, provisional, existing) {
+    const compat = checkpointCompatibility(existing.fingerprint, provisional.fingerprint);
+    if (!compat.compatible) {
+        return {
+            ...planForMissingCheckpoint(provisional.createdAt),
+            startupDiagnostics: [
+                checkpointIncompatibleDiagnostic(provisional.documentId, compat.reasons),
+            ],
+        };
+    }
+    if ((existing.phase !== "extracting" && existing.phase !== "cancelled") ||
+        existing.pageCursor <= 0) {
+        return planForMissingCheckpoint(provisional.createdAt);
+    }
+    const retryCount = existing.retryCount + 1;
+    const state = checkpointSinkState(deps.store, params, provisional.documentId, existing);
+    if (retryCount > context.policy.maxRetryCount) {
+        return retryExceededPlan(deps, params, context, extractor, contentHash, provisional, existing, state, retryCount);
+    }
+    return { state, retryCount, createdAt: existing.createdAt, resume: true, startupDiagnostics: [] };
+}
+function persistProgressiveStartup(sinkDeps, params, extractor, contentHash, plan) {
+    if (plan.resume) {
+        checkpointFor(sinkDeps, plan.state, "extracting", "partial", plan.startupDiagnostics);
+        return;
+    }
+    insertPendingDocument(sinkDeps, params, extractor, contentHash, plan.state);
+    plan.startupDiagnostics.forEach((diagnostic, index) => {
+        persistStandaloneDiagnostic(sinkDeps, redactDiagnostic(diagnostic, params), `startup-d${String(index)}`);
+    });
+    if (plan.startupDiagnostics.length > 0) {
+        checkpointFor(sinkDeps, plan.state, "extracting", "none", redactDiagnostics(plan.startupDiagnostics, params));
+    }
+}
+async function tryRunProgressiveExtraction(extractor, source, options, sinkDeps, state) {
+    try {
+        return await runProgressiveExtraction(extractor, source, options, {
+            onWindow: (window) => {
+                persistWindow(sinkDeps, state, window);
+            },
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function summaryWithDiagnostics(context, params, documentId, summary, startupDiagnostics) {
+    const diagnostics = redactDiagnostics([
+        ...startupDiagnostics,
+        ...summary.diagnostics,
+        ...capabilityDiagnostics(context, params, documentId, summary),
+    ], params);
+    return {
+        ...summary,
+        diagnostics,
+        coverage: coverageWithDiagnostics(summary.coverage, diagnostics),
+    };
+}
+function progressiveDocumentId(params, context) {
+    return documentIdFor({
+        capsuleId: params.capsuleId,
+        sourceId: params.source.id,
+        relativePath: context.relativePath,
+    });
+}
+function planForCheckpoint(deps, params, context, extractor, contentHash, provisional) {
+    const existing = selectExtractionCheckpoint(deps.store._internal.db, params.capsuleId, provisional.documentId);
+    if (existing === undefined)
+        return planForMissingCheckpoint(provisional.createdAt);
+    return planForExistingCheckpoint(deps, params, context, extractor, contentHash, provisional, existing);
+}
+function buildProgressiveStart(deps, params, context, contentHash, extractor) {
+    const documentId = progressiveDocumentId(params, context);
+    const provisionalSinkDeps = buildSinkDeps(deps, params, context, extractor, documentId, contentHash, 0, deps.store._internal.now());
+    return {
+        documentId,
+        provisionalSinkDeps,
+        plan: planForCheckpoint(deps, params, context, extractor, contentHash, provisionalSinkDeps),
+    };
+}
+function sinkDepsForPlan(deps, params, context, extractor, contentHash, start) {
+    const { plan, provisionalSinkDeps } = start;
+    if (plan.retryCount === provisionalSinkDeps.retryCount &&
+        plan.createdAt === provisionalSinkDeps.createdAt) {
+        return provisionalSinkDeps;
+    }
+    return buildSinkDeps(deps, params, context, extractor, start.documentId, contentHash, plan.retryCount, plan.createdAt);
+}
+function finalizeProgressiveSuccess(sinkDeps, params, context, contentHash, extractor, plan, summary) {
+    const finalSummary = summaryWithDiagnostics(context, params, sinkDeps.documentId, summary, plan.startupDiagnostics);
+    const status = finalize(sinkDeps, plan.state, finalSummary, finalSummary.diagnostics);
+    const document = progressiveDocumentRecord(params, sinkDeps.documentId, extractor, contentHash, status, sinkDeps.now());
+    return progressiveResult(params, document, finalSummary);
+}
+async function runPlannedProgressiveExtraction(sinkDeps, params, context, source, contentHash, extractor, plan) {
+    persistProgressiveStartup(sinkDeps, params, extractor, contentHash, plan);
+    const summary = await tryRunProgressiveExtraction(extractor, source, extractionOptionsFor(params, context, sinkDeps.documentId, sinkDeps.now, plan.state, plan.resume), sinkDeps, plan.state);
+    if (summary === undefined) {
+        return persistProgressiveFailure(sinkDeps, params, extractor, contentHash, plan.state, parserFailureDiagnostic(sinkDeps.documentId));
+    }
+    return finalizeProgressiveSuccess(sinkDeps, params, context, contentHash, extractor, plan, summary);
+}
+// Runs the page-windowed progressive extraction for one large document and persists it bounded.
+// The caller supplies a bounded byte source and a hash computed through bounded reads; extracted
+// text, pages, and checkpoints are flushed per window so peak memory does not scale with the raw
+// document size.
+export async function extractDocumentProgressive(deps, params, context, source, contentHash, extractor) {
+    const start = buildProgressiveStart(deps, params, context, contentHash, extractor);
+    if (start.plan.failure !== undefined)
+        return start.plan.failure;
+    return await runPlannedProgressiveExtraction(sinkDepsForPlan(deps, params, context, extractor, contentHash, start), params, context, source, contentHash, extractor, start.plan);
+}

package/dist/discovery/extract.d.ts

@@ -0,0 +1,26 @@
+import type { ExtractionCapabilityAvailability, KnowledgeCapsuleId, KnowledgeSource, LargeDocumentResourcePolicy } from "@oscharko-dev/keiko-contracts";
+import type { WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+import type { ParserOptions, ParserRegistry, ProgressiveExtractor } from "../parsers/index.js";
+import type { KnowledgeStore } from "../store.js";
+import { type DiscoveredFile, type DiscoveryError, type ExtractionResult } from "./types.js";
+export interface ExtractDocumentParams {
+    readonly capsuleId: KnowledgeCapsuleId;
+    readonly source: KnowledgeSource;
+    readonly file: DiscoveredFile;
+    readonly parserOptions?: ParserOptions;
+}
+export interface ExtractDocumentDeps {
+    readonly fs: WorkspaceFs;
+    readonly store: KnowledgeStore;
+    readonly parserRegistry: ParserRegistry;
+    readonly largeDocumentPolicy?: LargeDocumentResourcePolicy;
+    readonly extractionCapabilities?: ExtractionCapabilityAvailability;
+    readonly progressiveExtractors?: readonly ProgressiveExtractor[];
+    readonly largeDocumentJobId?: string;
+    readonly chunkingStrategyVersion?: string;
+}
+export declare function extractDocument(deps: ExtractDocumentDeps, params: ExtractDocumentParams): Promise<ExtractionResult>;
+export declare function recordExtractionFailure(deps: ExtractDocumentDeps, params: ExtractDocumentParams & {
+    readonly error: DiscoveryError;
+}): ExtractionResult;
+//# sourceMappingURL=extract.d.ts.map

package/dist/discovery/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/discovery/extract.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAGV,gCAAgC,EAChC,kBAAkB,EAClB,eAAe,EAEf,2BAA2B,EAG5B,MAAM,+BAA+B,CAAC;AAMvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAGjE,OAAO,KAAK,EAGV,aAAa,EACb,cAAc,EAEd,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAmB7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAalD,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,cAAc,EAGnB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;CACxC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IAIxC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,2BAA2B,CAAC;IAC3D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,gCAAgC,CAAC;IAEnE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACjE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAC3C;AA8hCD,wBAAsB,eAAe,CACnC,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAqB3B;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,qBAAqB,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GACjE,gBAAgB,CAOlB"}