@undefineds.co/xpod 0.3.74 → 0.4.0-rc.139

package/dist/api/service/RdfSearchIndexingService.d.ts

@@ -1,9 +1,10 @@
 import type { EmbeddingService } from '../../ai/service';
 import type { RdfEngineLike, RdfTextChunkInput, RdfTextSourceInput, RdfVectorSourceInput } from '../../storage/rdf/types';
 import type { StoreContext } from '../chatkit/store';
-export type RdfVectorIndexingSkippedReason = 'rdf_engine_unavailable' | 'vector_index_unavailable' | 'ai_config_unavailable' | 'embedding_model_unavailable' | 'embedding_provider_failed';
+import { type EmbeddingProviderFailureCategory } from '../../ai/service/EmbeddingProviderError';
+export type RdfVectorIndexingSkippedReason = 'rdf_engine_unavailable' | 'vector_index_unavailable' | 'ai_config_unavailable' | 'embedding_model_unavailable' | 'text_source_unavailable' | EmbeddingProviderFailureCategory;
 export interface RdfSearchIndexingServiceOptions {
-    rdfEngine?: Pick<RdfEngineLike, 'indexVectorSource' | 'deleteVectorSource'>;
+    rdfEngine?: Pick<RdfEngineLike, 'indexVectorSource' | 'deleteVectorSource' | 'listTextSourceChunks'>;
     store: {
         getAiConfig(context: StoreContext): Promise<RdfSearchAiConfig | undefined> | RdfSearchAiConfig | undefined;
     };
@@ -26,7 +27,8 @@ export interface RdfSearchAiConfig {
     credentialId: string;
 }
 export interface IndexRdfVectorSourceInput {
-    context: StoreContext;
+    context?: StoreContext;
+    embeddingConfig?: RdfSearchAiConfig;
     source: RdfTextSourceInput & RdfVectorSourceInput;
     text?: string;
     chunks?: RdfTextChunkInput[];
@@ -34,17 +36,44 @@ export interface IndexRdfVectorSourceInput {
 export interface DeleteRdfVectorSourceInput {
     source: string;
 }
+export interface RebuildRdfVectorSourceInput {
+    context?: StoreContext;
+    embeddingConfig?: RdfSearchAiConfig;
+    sourceKey: string;
+}
 export type RdfVectorIndexingResult = {
     status: 'indexed';
     source: string;
+    sourceHash?: string;
+    sourceVersion?: string;
+    providerId?: string;
     model?: string;
+    modelVersion?: string;
+    configFingerprint?: string;
     chunkCount: number;
     skippedInputs?: RdfSkippedEmbeddingInput[];
     summarizedInputs?: RdfSummarizedEmbeddingInput[];
 } | {
     status: 'skipped';
     source: string;
+    sourceHash?: string;
+    sourceVersion?: string;
     reason: RdfVectorIndexingSkippedReason;
+    providerId?: string;
+    model?: string;
+    modelVersion?: string;
+    configFingerprint?: string;
+    message?: string;
+} | {
+    status: 'retryable';
+    source: string;
+    sourceHash?: string;
+    sourceVersion?: string;
+    reason: EmbeddingProviderFailureCategory;
+    providerId: string;
+    model: string;
+    modelVersion?: string;
+    configFingerprint: string;
     message?: string;
 };
 export interface RdfVectorDeleteResult {
@@ -88,6 +117,9 @@ export interface RdfSummarizedEmbeddingInput {
     summaryChars: number;
     rounds: number;
 }
+export declare const DEFAULT_RDF_VECTOR_MODEL_VERSION = "unversioned";
+export declare const DEFAULT_RDF_VECTOR_PROJECTION_POLICY_VERSION = "rdf-vector-projection-v1";
+export declare function normalizeRdfVectorModelVersion(value: string | undefined): string;
 /**
  * Product-level bridge from Pod-owned AI credentials to the RDF vector index.
  *
@@ -98,6 +130,7 @@ export interface RdfSummarizedEmbeddingInput {
 export declare class RdfSearchIndexingService {
     private readonly options;
     constructor(options: RdfSearchIndexingServiceOptions);
+    rebuildVectorSource(input: RebuildRdfVectorSourceInput): Promise<RdfVectorIndexingResult>;
     indexVectorSource(input: IndexRdfVectorSourceInput): Promise<RdfVectorIndexingResult>;
     deleteVectorSource(input: DeleteRdfVectorSourceInput): Promise<RdfVectorDeleteResult>;
     private sourceWithHash;
@@ -110,4 +143,5 @@ export declare class RdfSearchIndexingService {
     private summarizeEmbeddingInput;
     private skippedEmbeddingInput;
     private indexedResult;
+    private skippedResult;
 }

package/dist/api/service/RdfSearchIndexingService.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RdfSearchIndexingService = void 0;
+exports.RdfSearchIndexingService = exports.DEFAULT_RDF_VECTOR_PROJECTION_POLICY_VERSION = exports.DEFAULT_RDF_VECTOR_MODEL_VERSION = void 0;
+exports.normalizeRdfVectorModelVersion = normalizeRdfVectorModelVersion;
 const node_crypto_1 = require("node:crypto");
 const RdfTextIndex_1 = require("../../storage/rdf/RdfTextIndex");
+const EmbeddingProviderError_1 = require("../../ai/service/EmbeddingProviderError");
 const DEFAULT_EMBEDDING_INPUT_KINDS = ['semantic'];
-const DEFAULT_PROJECTION_POLICY_VERSION = 'rdf-vector-projection-v1';
+exports.DEFAULT_RDF_VECTOR_MODEL_VERSION = 'unversioned';
+exports.DEFAULT_RDF_VECTOR_PROJECTION_POLICY_VERSION = 'rdf-vector-projection-v1';
 const DEFAULT_SUMMARY_PROMPT_VERSION = 'rdf-embedding-summary-v1';
+function normalizeRdfVectorModelVersion(value) {
+    return value?.trim() || exports.DEFAULT_RDF_VECTOR_MODEL_VERSION;
+}
 /**
  * Product-level bridge from Pod-owned AI credentials to the RDF vector index.
  *
@@ -17,6 +23,48 @@ class RdfSearchIndexingService {
     constructor(options) {
         this.options = options;
     }
+    async rebuildVectorSource(input) {
+        if (!this.options.rdfEngine) {
+            return { status: 'skipped', source: input.sourceKey, reason: 'rdf_engine_unavailable' };
+        }
+        if (!this.options.rdfEngine.listTextSourceChunks) {
+            return { status: 'skipped', source: input.sourceKey, reason: 'vector_index_unavailable' };
+        }
+        const chunks = await this.options.rdfEngine.listTextSourceChunks(input.sourceKey);
+        if (chunks.length === 0) {
+            if (this.options.rdfEngine.deleteVectorSource) {
+                await this.options.rdfEngine.deleteVectorSource(input.sourceKey);
+            }
+            return { status: 'skipped', source: input.sourceKey, reason: 'text_source_unavailable' };
+        }
+        const first = chunks[0];
+        return this.indexVectorSource({
+            context: input.context,
+            embeddingConfig: input.embeddingConfig,
+            source: {
+                sourceKey: first.sourceKey,
+                source: first.source,
+                workspace: first.workspace,
+                localPath: first.localPath,
+                contentType: first.contentType,
+                sourceVersion: first.sourceVersion,
+                sourceHash: first.sourceHash,
+            },
+            chunks: chunks.map((chunk) => ({
+                chunkKey: chunk.retrievalPointKey,
+                retrievalPointKey: chunk.retrievalPointKey,
+                retrievalKind: chunk.retrievalKind,
+                ordinal: chunk.ordinal,
+                level: chunk.level,
+                heading: chunk.heading,
+                path: chunk.path,
+                content: chunk.content,
+                startOffset: chunk.startOffset,
+                endOffset: chunk.endOffset,
+                entities: chunk.entities,
+            })),
+        });
+    }
     async indexVectorSource(input) {
         if (!this.options.rdfEngine) {
             return { status: 'skipped', source: input.source.source, reason: 'rdf_engine_unavailable' };
@@ -28,20 +76,22 @@ class RdfSearchIndexingService {
         const textChunks = this.textChunks(source, input);
         if (textChunks.length === 0) {
             await this.options.rdfEngine.indexVectorSource(source, []);
-            return { status: 'indexed', source: source.source, chunkCount: 0 };
+            return this.indexedResult(source, undefined, 0, [], []);
         }
         const { accepted: embeddingInputs, skipped: skippedInputs, summarized: summarizedInputs } = await this.resolveEmbeddingInputBudget(source, this.embeddingInputs(source, textChunks));
         if (embeddingInputs.length === 0) {
             await this.options.rdfEngine.indexVectorSource(source, []);
-            return this.indexedResult(source.source, undefined, 0, skippedInputs, summarizedInputs);
+            return this.indexedResult(source, undefined, 0, skippedInputs, summarizedInputs);
         }
-        const config = await this.options.store.getAiConfig(input.context);
+        const config = input.embeddingConfig ?? (input.context ? await this.options.store.getAiConfig(input.context) : undefined);
         if (!config?.apiKey) {
-            return { status: 'skipped', source: source.source, reason: 'ai_config_unavailable' };
+            return this.skippedResult(source, 'ai_config_unavailable');
         }
         if (!config.embeddingModel) {
-            return { status: 'skipped', source: source.source, reason: 'embedding_model_unavailable' };
+            return this.skippedResult(source, 'embedding_model_unavailable');
         }
+        const embeddingModel = config.embeddingModel;
+        const embeddingModelVersion = normalizeRdfVectorModelVersion(config.embeddingModelVersion);
         const contents = embeddingInputs.map((embeddingInput) => embeddingInput.content);
         let embeddings;
         try {
@@ -50,13 +100,42 @@ class RdfSearchIndexingService {
                 apiKey: config.apiKey,
                 baseUrl: config.baseUrl,
                 proxyUrl: config.proxyUrl,
-            }, config.embeddingModel);
+            }, embeddingModel);
         }
         catch (error) {
+            const failure = (0, EmbeddingProviderError_1.classifyEmbeddingProviderFailure)(error);
+            if (!failure.retryable) {
+                return {
+                    status: 'skipped',
+                    source: source.source,
+                    ...(source.sourceHash ? { sourceHash: source.sourceHash } : {}),
+                    ...(source.sourceVersion ? { sourceVersion: source.sourceVersion } : {}),
+                    reason: failure.category,
+                    providerId: config.providerId,
+                    model: embeddingModel,
+                    modelVersion: embeddingModelVersion,
+                    configFingerprint: embeddingConfigFingerprint({
+                        ...config,
+                        embeddingModel,
+                        embeddingModelVersion,
+                    }),
+                    message: error instanceof Error ? error.message : String(error),
+                };
+            }
             return {
-                status: 'skipped',
+                status: 'retryable',
                 source: source.source,
-                reason: 'embedding_provider_failed',
+                ...(source.sourceHash ? { sourceHash: source.sourceHash } : {}),
+                ...(source.sourceVersion ? { sourceVersion: source.sourceVersion } : {}),
+                reason: failure.category,
+                providerId: config.providerId,
+                model: embeddingModel,
+                modelVersion: embeddingModelVersion,
+                configFingerprint: embeddingConfigFingerprint({
+                    ...config,
+                    embeddingModel,
+                    embeddingModelVersion,
+                }),
                 message: error instanceof Error ? error.message : String(error),
             };
         }
@@ -70,8 +149,8 @@ class RdfSearchIndexingService {
             level: chunk.level,
             embedding: embeddings[index],
             provider: config.providerId,
-            model: config.embeddingModel,
-            modelVersion: config.embeddingModelVersion,
+            model: embeddingModel,
+            modelVersion: embeddingModelVersion,
             inputKind: kind,
             inputHash,
             projectionPolicyVersion,
@@ -82,7 +161,16 @@ class RdfSearchIndexingService {
             endOffset: chunk.endOffset,
             summaryMetadata,
         })));
-        return this.indexedResult(source.source, config.embeddingModel, embeddingInputs.length, skippedInputs, summarizedInputs);
+        return this.indexedResult(source, {
+            providerId: config.providerId,
+            model: embeddingModel,
+            modelVersion: embeddingModelVersion,
+            configFingerprint: embeddingConfigFingerprint({
+                ...config,
+                embeddingModel,
+                embeddingModelVersion,
+            }),
+        }, embeddingInputs.length, skippedInputs, summarizedInputs);
     }
     async deleteVectorSource(input) {
         if (!this.options.rdfEngine) {
@@ -114,7 +202,7 @@ class RdfSearchIndexingService {
         }
         return {
             ...source,
-            sourceHash: (0, node_crypto_1.createHash)('sha256').update(text).digest('hex'),
+            sourceHash: `sha256:${(0, node_crypto_1.createHash)('sha256').update(text).digest('hex')}`,
         };
     }
     textChunks(source, input) {
@@ -149,7 +237,7 @@ class RdfSearchIndexingService {
         return [...new Set(configured)];
     }
     projectionPolicyVersion() {
-        return this.options.projectionPolicyVersion ?? DEFAULT_PROJECTION_POLICY_VERSION;
+        return this.options.projectionPolicyVersion ?? exports.DEFAULT_RDF_VECTOR_PROJECTION_POLICY_VERSION;
     }
     embeddingInputContent(source, chunk, kind) {
         if (kind === 'semantic') {
@@ -257,16 +345,40 @@ class RdfSearchIndexingService {
             ...(message ? { message } : {}),
         };
     }
-    indexedResult(source, model, chunkCount, skippedInputs, summarizedInputs = []) {
+    indexedResult(source, profile, chunkCount, skippedInputs, summarizedInputs = []) {
         return {
             status: 'indexed',
-            source,
-            ...(model ? { model } : {}),
+            source: source.source,
+            ...(source.sourceHash ? { sourceHash: source.sourceHash } : {}),
+            ...(source.sourceVersion ? { sourceVersion: source.sourceVersion } : {}),
+            ...(profile?.providerId ? { providerId: profile.providerId } : {}),
+            ...(profile?.model ? { model: profile.model } : {}),
+            ...(profile?.modelVersion ? { modelVersion: profile.modelVersion } : {}),
+            ...(profile?.configFingerprint ? { configFingerprint: profile.configFingerprint } : {}),
             chunkCount,
             ...(skippedInputs.length > 0 ? { skippedInputs } : {}),
             ...(summarizedInputs.length > 0 ? { summarizedInputs } : {}),
         };
     }
+    skippedResult(source, reason) {
+        return {
+            status: 'skipped',
+            source: source.source,
+            ...(source.sourceHash ? { sourceHash: source.sourceHash } : {}),
+            ...(source.sourceVersion ? { sourceVersion: source.sourceVersion } : {}),
+            reason,
+        };
+    }
 }
 exports.RdfSearchIndexingService = RdfSearchIndexingService;
+function embeddingConfigFingerprint(input) {
+    return `sha256:${(0, node_crypto_1.createHash)('sha256')
+        .update([
+        input.providerId,
+        input.embeddingModel,
+        normalizeRdfVectorModelVersion(input.embeddingModelVersion),
+        input.credentialId,
+    ].join('\0'))
+        .digest('hex')}`;
+}
 //# sourceMappingURL=RdfSearchIndexingService.js.map

package/dist/api/service/RdfSearchIndexingSolidFsSyncer.d.ts

@@ -1,5 +1,6 @@
 import type { SolidFsChange, SolidFsManifest, SolidFsPrepareInput, SolidFsSyncer } from '../../solidfs';
 import type { RdfSearchIndexingService, RdfVectorDeleteResult, RdfVectorIndexingResult } from './RdfSearchIndexingService';
+import type { RdfSearchReconciliationRepository } from '../../search/RdfSearchReconciliationRepository';
 export interface RdfSearchIndexingSolidFsSyncerOptions {
     service: RdfSearchIndexingService;
     /**
@@ -9,6 +10,9 @@ export interface RdfSearchIndexingSolidFsSyncerOptions {
     failOnError?: boolean;
     onError?: (error: unknown, input: RdfSearchIndexingSolidFsSyncerErrorInput) => void;
     onResult?: (result: RdfVectorIndexingResult | RdfVectorDeleteResult) => void;
+    reconciliationRepository?: Pick<RdfSearchReconciliationRepository, 'upsertRetryable' | 'upsertBlockedConfig' | 'waitForConfig' | 'upsertApplied' | 'deleteSource'>;
+    now?: () => number;
+    retryDelayMs?: number;
 }
 export interface RdfSearchIndexingSolidFsSyncerErrorInput {
     change: SolidFsChange;
@@ -20,8 +24,12 @@ export declare class RdfSearchIndexingSolidFsSyncer implements SolidFsSyncer {
     private readonly failOnError;
     private readonly onError?;
     private readonly onResult?;
+    private readonly reconciliationRepository?;
+    private readonly now;
+    private readonly retryDelayMs;
     constructor(options: RdfSearchIndexingSolidFsSyncerOptions);
     shouldTrack(input: SolidFsPrepareInput): boolean;
     shouldTrackPath(relativePath: string): boolean;
     sync(change: SolidFsChange, workspace: SolidFsManifest, context?: unknown): Promise<void>;
+    private recordReconciliationResult;
 }

package/dist/api/service/RdfSearchIndexingSolidFsSyncer.js

@@ -1,19 +1,23 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RdfSearchIndexingSolidFsSyncer = void 0;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = __importDefault(require("node:path"));
 const solidfs_1 = require("../../solidfs");
 const RdfContentTypes_1 = require("../../storage/rdf/RdfContentTypes");
+const BLOCKED_CONFIG_FAILURES = new Set([
+    'embedding_authentication_failed',
+    'embedding_authorization_failed',
+    'embedding_model_invalid',
+    'embedding_request_invalid',
+]);
 class RdfSearchIndexingSolidFsSyncer {
     constructor(options) {
         this.service = options.service;
         this.failOnError = options.failOnError === true;
         this.onError = options.onError;
         this.onResult = options.onResult;
+        this.reconciliationRepository = options.reconciliationRepository;
+        this.now = options.now ?? Date.now;
+        this.retryDelayMs = options.retryDelayMs ?? 60_000;
     }
     shouldTrack(input) {
         try {
@@ -38,21 +42,15 @@ class RdfSearchIndexingSolidFsSyncer {
         try {
             if (change.type === 'deleted') {
                 const result = await this.service.deleteVectorSource({ source });
+                await this.reconciliationRepository?.deleteSource(source);
                 this.onResult?.(result);
                 return;
             }
-            const text = await (0, promises_1.readFile)(change.sourcePath, 'utf8');
-            const result = await this.service.indexVectorSource({
+            const result = await this.service.rebuildVectorSource({
                 context,
-                source: {
-                    source,
-                    workspace: workspace.workspace,
-                    localPath: change.path.split(node_path_1.default.sep).join('/'),
-                    contentType: change.contentType,
-                    sourceVersion: change.sourceVersion,
-                },
-                text,
+                sourceKey: source,
             });
+            await this.recordReconciliationResult(result, source, workspace.workspace);
             this.onResult?.(result);
         }
         catch (error) {
@@ -62,8 +60,97 @@ class RdfSearchIndexingSolidFsSyncer {
             }
         }
     }
+    async recordReconciliationResult(result, source, podRoot) {
+        const identity = {
+            sourceHash: result.sourceHash,
+            sourceVersion: result.sourceVersion,
+        };
+        if (result.status !== 'skipped') {
+            if (result.status !== 'retryable') {
+                if (hasAppliedEmbeddingProfile(result)) {
+                    await this.reconciliationRepository?.upsertApplied({
+                        sourceKey: source,
+                        sourceUri: source,
+                        podRoot,
+                        providerId: result.providerId,
+                        model: result.model,
+                        modelVersion: result.modelVersion,
+                        configFingerprint: result.configFingerprint,
+                        sourceHash: identity.sourceHash,
+                        sourceVersion: identity.sourceVersion,
+                        reason: 'source-indexed',
+                    });
+                }
+                else {
+                    await this.reconciliationRepository?.deleteSource(source);
+                }
+                return;
+            }
+            await this.reconciliationRepository?.upsertRetryable({
+                sourceKey: source,
+                sourceUri: source,
+                podRoot,
+                providerId: result.providerId,
+                model: result.model,
+                modelVersion: result.modelVersion,
+                configFingerprint: result.configFingerprint,
+                sourceHash: identity.sourceHash,
+                sourceVersion: identity.sourceVersion,
+                reason: result.reason,
+                failureCategory: result.reason,
+                nextAttemptAt: new Date(this.now() + this.retryDelayMs),
+            });
+            return;
+        }
+        if (result.reason === 'text_source_unavailable') {
+            await this.reconciliationRepository?.deleteSource(source);
+            return;
+        }
+        if (BLOCKED_CONFIG_FAILURES.has(result.reason)) {
+            if (!hasBlockedEmbeddingProfile(result)) {
+                return;
+            }
+            await this.reconciliationRepository?.upsertBlockedConfig({
+                sourceKey: source,
+                sourceUri: source,
+                podRoot,
+                providerId: result.providerId,
+                model: result.model,
+                modelVersion: result.modelVersion,
+                configFingerprint: result.configFingerprint,
+                sourceHash: identity.sourceHash,
+                sourceVersion: identity.sourceVersion,
+                reason: result.reason,
+                failureCategory: result.reason,
+            });
+            return;
+        }
+        if (result.reason !== 'ai_config_unavailable' && result.reason !== 'embedding_model_unavailable') {
+            return;
+        }
+        await this.reconciliationRepository?.waitForConfig({
+            sourceKey: source,
+            sourceUri: source,
+            podRoot,
+            sourceHash: identity.sourceHash,
+            sourceVersion: identity.sourceVersion,
+            reason: result.reason,
+            failureCategory: result.reason,
+        });
+    }
 }
 exports.RdfSearchIndexingSolidFsSyncer = RdfSearchIndexingSolidFsSyncer;
+function hasBlockedEmbeddingProfile(result) {
+    return typeof result.providerId === 'string'
+        && typeof result.model === 'string'
+        && typeof result.configFingerprint === 'string';
+}
+function hasAppliedEmbeddingProfile(result) {
+    return result.status === 'indexed'
+        && typeof result.providerId === 'string'
+        && typeof result.model === 'string'
+        && typeof result.configFingerprint === 'string';
+}
 function isSearchIndexableChange(change) {
     return (0, RdfContentTypes_1.isLineAddressableRdf)(change.contentType, change.path)
         || isTextContentType(change.contentType)

package/dist/api/service/RdfSearchReconciliationWorker.d.ts

@@ -0,0 +1,76 @@
+import type { RdfEngineLike } from '../../storage/rdf';
+import type { StoreContext } from '../chatkit/store';
+import type { RunAuthContextRegistry } from '../runs/RunAuthContextRegistry';
+import { type RdfSearchIndexingService } from './RdfSearchIndexingService';
+import type { RdfSearchReconciliationRepository } from '../../search/RdfSearchReconciliationRepository';
+export interface RdfSearchReconciliationWorkerOptions {
+    repository: RdfSearchReconciliationRepository;
+    indexingService?: RdfSearchIndexingService;
+    contextRegistry: RunAuthContextRegistry;
+    store?: {
+        getAiConfig(context: StoreContext): Promise<RdfSearchEmbeddingConfig | undefined> | RdfSearchEmbeddingConfig | undefined;
+    };
+    rdfEngine?: Pick<RdfEngineLike, 'listTextSources'>;
+    workerId?: string;
+    now?: () => number;
+    leaseDurationMs?: number;
+    maxBatchSize?: number;
+    intervalMs?: number;
+    reconcileIntervalMs?: number;
+    retryBaseDelayMs?: number;
+    retryMaxDelayMs?: number;
+    sourcePageSize?: number;
+    onError?: (error: unknown, input: RdfSearchReconciliationWorkerErrorInput) => void;
+}
+export interface RdfSearchEmbeddingConfig {
+    providerId: string;
+    baseUrl: string;
+    proxyUrl?: string;
+    defaultModel?: string;
+    embeddingModel?: string;
+    embeddingModelVersion?: string;
+    apiKey: string;
+    credentialId: string;
+}
+export interface RdfSearchReconciliationDrainResult {
+    processed: number;
+}
+export interface RdfSearchRememberedContextReconciliationResult {
+    contexts: number;
+    sources: number;
+}
+export interface RdfSearchReconciliationWorkerErrorInput {
+    phase: 'tick' | 'drain' | 'reconcile';
+    sourceKey?: string;
+    sourceUri?: string;
+}
+export declare class RdfSearchReconciliationWorker {
+    private readonly repository;
+    private readonly indexingService?;
+    private readonly contextRegistry;
+    private readonly store?;
+    private readonly rdfEngine?;
+    private readonly workerId;
+    private readonly now;
+    private readonly leaseDurationMs;
+    private readonly maxBatchSize;
+    private readonly intervalMs;
+    private readonly reconcileIntervalMs;
+    private readonly retryBaseDelayMs;
+    private readonly retryMaxDelayMs;
+    private readonly sourcePageSize;
+    private readonly onError?;
+    private timer;
+    private running;
+    constructor(options: RdfSearchReconciliationWorkerOptions);
+    start(): void;
+    stop(): void;
+    drain(): Promise<RdfSearchReconciliationDrainResult>;
+    reconcileRememberedContexts(): Promise<RdfSearchRememberedContextReconciliationResult>;
+    private process;
+    private recordResult;
+    private contextForSource;
+    private desiredProfile;
+    private nextAttemptAt;
+    private reportError;
+}