@autorag/librarian 2.13.7 → 2.13.9

package/dist/minsync/channel-union.d.ts

@@ -0,0 +1,23 @@
+import type { RetrievalResult } from "../retrieval/types.js";
+/** Ranked results of one MinSync query mode (`vector` or `sparse`), best first. */
+export interface MinSyncChannelResults {
+    readonly channel: string;
+    readonly results: readonly RetrievalResult[];
+}
+export interface UnionChannelOptions {
+    /** Keep at most this many chunks after interleaving. Unset keeps the whole union. */
+    readonly limit?: number;
+}
+/**
+ * Union of independently ranked MinSync channels, built for a reranker that decides the final order.
+ *
+ * Channels are interleaved by rank (rank 1 of each channel, then rank 2, ...) so a limit never cuts one
+ * channel's head to keep the other's tail, and a chunk found by several channels appears once, at its
+ * best interleaved position. Scores are left as the first channel reported them: dense and SPLADE scores
+ * are not comparable and nothing here ranks across them. Each chunk records which channels found it and
+ * at what 1-based rank (`minsyncChannels`, `minsyncChannelRanks`).
+ *
+ * Identity is `source` + `id`, the same key the cross-method merger uses, so two chunks of one document
+ * stay distinct while the same chunk reached by two channels collapses.
+ */
+export declare function unionChannelResults(channels: readonly MinSyncChannelResults[], options?: UnionChannelOptions): RetrievalResult[];

package/dist/minsync/method.d.ts

@@ -1,3 +1,4 @@
+import { type RecordCut } from "../retrieval/record-cut.js";
 import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../retrieval/types.js";
 import type { MinSyncQueryMode } from "./client.js";
 import type { EnsureMinSyncBinaryOptions } from "./installer.js";
@@ -16,6 +17,11 @@ export interface MinSyncVectorMethodOptions {
     readonly defaultTopK?: number;
     /** Fetch cap applied when a scope narrows the query. Default 100. */
     readonly scopedTopK?: number;
+    /**
+     * Fuse deeper and cut the hits by document, so one long document cannot take every one of `topK` slots
+     * (see {@link RecordCut}). Unset asks MinSync for `topK` and cuts by chunk.
+     */
+    readonly recordCut?: RecordCut;
 }
 export type MinSyncHybridMethodOptions = Omit<MinSyncVectorMethodOptions, "mode">;
 export declare class MinSyncVectorMethod implements RetrievalMethod {
@@ -29,6 +35,7 @@ export declare class MinSyncVectorMethod implements RetrievalMethod {
     private readonly mode;
     private readonly defaultTopK;
     private readonly scopedTopK;
+    private readonly recordCut;
     constructor(options: MinSyncVectorMethodOptions);
     describe(): RetrievalMethodDescriptor;
     sync(force?: boolean, signal?: AbortSignal, onProgress?: (progress: MinSyncSyncProgress) => void): Promise<MinSyncSyncResult>;

package/dist/mirror/sync.d.ts

@@ -28,6 +28,15 @@ export interface ParsedMirrorSyncOptions {
     readonly maxSourceBytes?: number;
     /** Absolute source paths omitted from parsed mirrors (for example exact duplicate copies). */
     readonly excludeSourcePaths?: ReadonlySet<string>;
+    /**
+     * Read-only freshness checks only: omit the sources the last refresh already recorded as
+     * `duplicate-excluded` instead of requiring a fresh duplicate scan. Duplicate selection needs
+     * a content scan of every root, which is the dominant cost of a status or retrieve call.
+     * A recorded copy is only omitted while its mtime and size still match the record, so an
+     * edited copy is still reported stale. Copies that became duplicates after the last refresh
+     * are not known here; see `AutoRAGAgent.scanMirrorStaleness`.
+     */
+    readonly reuseRecordedDuplicateExclusions?: boolean;
     /** Absolute source paths or directories omitted by the user. */
     readonly userExcludedSourcePaths?: ReadonlySet<string>;
     /**