@graphorin/memory 0.5.0

package/dist/internal/storage-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-adapter.d.ts","names":[],"sources":["../../src/internal/storage-adapter.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/migration/embedder-migration.d.ts

@@ -0,0 +1,124 @@
+import { EmbeddingMetaRegistryLike } from "../internal/storage-adapter.js";
+import { EmbedderProvider } from "@graphorin/core";
+
+//#region src/migration/embedder-migration.d.ts
+
+/**
+ * Coexistence policy for embedder swaps.
+ *
+ *  - `'lock-on-first'` (default) — refuses to register a second active
+ *    embedder; surfaces an actionable error pointing at the planned
+ *    migration runner.
+ *  - `'multi-active'` — keeps both embedders alive (read union, write
+ *    to active); used while a long migration is in flight.
+ *  - `'auto-migrate'` — re-embeds existing rows in resumable batches
+ *    until the source embedder has zero rows, then retires it.
+ *
+ * @stable
+ */
+type EmbedderMigrationStrategy = 'lock-on-first' | 'multi-active' | 'auto-migrate';
+/**
+ * Per-iteration progress snapshot yielded by {@link migrateEmbedder}.
+ *
+ * @stable
+ */
+interface MigrationProgress {
+  /** `'fact'`, `'episode'`, or `'message'` — which entity is being migrated. */
+  readonly kind: 'fact' | 'episode' | 'message';
+  /** Number of records processed so far. */
+  readonly processed: number;
+  /** Total records expected for this entity (when known). */
+  readonly total: number;
+  /** Identifier of the source embedder (`'<adapter>:<model>@<dim>'`). */
+  readonly source: string;
+  /** Identifier of the target embedder. */
+  readonly target: string;
+  /**
+   * Identifier for this migration run. MST-12: this is an in-memory id for
+   * the current run — there is no persisted `migration_state` cursor today, so
+   * a migration does not resume across processes.
+   */
+  readonly migrationId: string;
+  /** Phase discriminator. */
+  readonly phase: 'planning' | 'running' | 'paused' | 'committed' | 'aborted';
+}
+/**
+ * Options accepted by {@link migrateEmbedder}.
+ *
+ * @stable
+ */
+interface MigrateEmbedderOptions {
+  /** Source embedder (currently active). */
+  readonly source: EmbedderProvider;
+  /** Target embedder (becomes active when migration commits). */
+  readonly target: EmbedderProvider;
+  /** Storage layer's embedder registry. */
+  readonly embeddings: EmbeddingMetaRegistryLike;
+  /** Strategy applied per `embedding_meta` row. Default `'lock-on-first'`. */
+  readonly strategy?: EmbedderMigrationStrategy;
+  /**
+   * Threshold for `auto-migrate`. The runner streams source rows in
+   * batches of `batchSize` (default `512`) and yields progress after
+   * each batch.
+   */
+  readonly batchSize?: number;
+  /** Optional cap on the number of rows to migrate per kind. */
+  readonly maxRecordsPerKind?: number;
+  /**
+   * Hook that returns the next batch of rows to re-embed for a given kind.
+   * MST-12: this is **caller-supplied** — there is no store-side helper that
+   * auto-wires it today, and `auto-migrate` throws without it. Pass a paging
+   * function over your source rows to drive the migration.
+   */
+  readonly nextBatch?: NextBatchHook;
+  /** Optional abort signal — aborting yields one final progress event. */
+  readonly signal?: AbortSignal;
+}
+/**
+ * Per-batch loader. Returns up to `batchSize` rows for the supplied
+ * `kind` whose `embedder_id` is the source embedder. Returning an
+ * empty array signals end-of-stream.
+ *
+ * @stable
+ */
+type NextBatchHook = (args: {
+  readonly kind: 'fact' | 'episode' | 'message';
+  readonly source: string;
+  readonly target: string;
+  readonly batchSize: number;
+  readonly cursor: string | null;
+}) => Promise<{
+  readonly rows: ReadonlyArray<MigrationRow>;
+  readonly nextCursor: string | null;
+}>;
+/**
+ * Single row exposed to the migration runner. The runner re-embeds
+ * `text` with the target embedder; the storage adapter is responsible
+ * for committing the new vector + updating `embedder_id`.
+ *
+ * @stable
+ */
+interface MigrationRow {
+  readonly id: string;
+  readonly text: string;
+  readonly write: (vector: Float32Array) => Promise<void>;
+}
+/**
+ * Stream embedder migrations as `AsyncIterable<MigrationProgress>`.
+ *
+ * The function is the universal entry point for every migration
+ * strategy:
+ *
+ *  - `'lock-on-first'`: surfaces the locked error eagerly so the
+ *    operator can act before any work happens.
+ *  - `'multi-active'`: registers the target alongside the source and
+ *    yields a single `'committed'` progress event.
+ *  - `'auto-migrate'`: streams batches until the source is fully
+ *    drained, then retires the source row.
+ *
+ * @stable
+ */
+declare function migrateEmbedder(options: MigrateEmbedderOptions): AsyncGenerator<MigrationProgress, void, unknown>;
+//#endregion
+export { EmbedderMigrationStrategy, MigrateEmbedderOptions, MigrationProgress, migrateEmbedder };
+//# sourceMappingURL=embedder-migration.d.ts.map

package/dist/migration/embedder-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder-migration.d.ts","names":[],"sources":["../../src/migration/embedder-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;AAOA;AA0BA;;;;;;;;AAmCA;AAM6C,KA1EjC,yBAAA,GA0EiC,eAAA,GAAA,cAAA,GAAA,cAAA;;;;AAS7C;AAqBA;AACW,UAlGM,iBAAA,CAkGN;EACO;EAAf,SAAA,IAAA,EAAA,MAAA,GAAA,SAAA,GAAA,SAAA;EAAc;;;;;;;;;;;;;;;;;;;;;;UAzEA,sBAAA;;mBAEE;;mBAEA;;uBAEI;;sBAED;;;;;;;;;;;;;;;uBAeC;;oBAEH;;;;;;;;;KAUR,aAAA;;;;;;MAMN;iBAAyB,cAAc;;;;;;;;;;UAS5B,YAAA;;;2BAGU,iBAAiB;;;;;;;;;;;;;;;;;iBAkBrB,eAAA,UACZ,yBACR,eAAe"}

package/dist/migration/embedder-migration.js

@@ -0,0 +1,109 @@
+import { EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError } from "../errors/index.js";
+import { bindEmbedder } from "../internal/embedder-binding.js";
+
+//#region src/migration/embedder-migration.ts
+/**
+* Stream embedder migrations as `AsyncIterable<MigrationProgress>`.
+*
+* The function is the universal entry point for every migration
+* strategy:
+*
+*  - `'lock-on-first'`: surfaces the locked error eagerly so the
+*    operator can act before any work happens.
+*  - `'multi-active'`: registers the target alongside the source and
+*    yields a single `'committed'` progress event.
+*  - `'auto-migrate'`: streams batches until the source is fully
+*    drained, then retires the source row.
+*
+* @stable
+*/
+async function* migrateEmbedder(options) {
+	const { source, target, embeddings } = options;
+	const strategy = options.strategy ?? "lock-on-first";
+	const sourceId = source.id();
+	const targetId = target.id();
+	const migrationId = `migration_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+	if (sourceId === targetId) throw new EmbedderMigrationStateError(`source and target embedders must differ; both resolved to '${sourceId}'.`);
+	if (embeddings.get(sourceId) === null) throw new EmbedderMigrationStateError(`source embedder '${sourceId}' is not registered. Run createMemory({ embedder: source }) first.`);
+	if (strategy === "lock-on-first") throw new EmbedderMigrationLockedError(sourceId, targetId);
+	bindEmbedder(target, embeddings);
+	if (strategy === "multi-active") {
+		yield {
+			kind: "fact",
+			processed: 0,
+			total: 0,
+			source: sourceId,
+			target: targetId,
+			migrationId,
+			phase: "committed"
+		};
+		return;
+	}
+	if (options.nextBatch === void 0) throw new EmbedderMigrationStateError("'auto-migrate' requires a `nextBatch` hook supplied by the storage adapter.");
+	const batchSize = options.batchSize ?? 512;
+	const cap = options.maxRecordsPerKind ?? Number.POSITIVE_INFINITY;
+	for (const kind of [
+		"fact",
+		"episode",
+		"message"
+	]) {
+		let cursor = null;
+		let processed = 0;
+		while (processed < cap) {
+			if (options.signal?.aborted === true) {
+				yield {
+					kind,
+					processed,
+					total: processed,
+					source: sourceId,
+					target: targetId,
+					migrationId,
+					phase: "aborted"
+				};
+				throw new EmbedderMigrationAbortedError(migrationId);
+			}
+			const batch = await options.nextBatch({
+				kind,
+				source: sourceId,
+				target: targetId,
+				batchSize,
+				cursor
+			});
+			if (batch.rows.length === 0) break;
+			const texts = batch.rows.map((r) => r.text);
+			const vectors = await target.embed(texts, { ...options.signal !== void 0 ? { signal: options.signal } : {} });
+			for (let i = 0; i < batch.rows.length; i++) {
+				const row = batch.rows[i];
+				const vector = vectors[i];
+				if (row === void 0 || vector === void 0) continue;
+				await row.write(vector);
+			}
+			processed += batch.rows.length;
+			cursor = batch.nextCursor;
+			yield {
+				kind,
+				processed,
+				total: processed,
+				source: sourceId,
+				target: targetId,
+				migrationId,
+				phase: "running"
+			};
+			if (cursor === null) break;
+		}
+	}
+	embeddings.retire(sourceId);
+	yield {
+		kind: "fact",
+		processed: 0,
+		total: 0,
+		source: sourceId,
+		target: targetId,
+		migrationId,
+		phase: "committed"
+	};
+}
+
+//#endregion
+export { migrateEmbedder };
+//# sourceMappingURL=embedder-migration.js.map

package/dist/migration/embedder-migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder-migration.js","names":["cursor: string | null"],"sources":["../../src/migration/embedder-migration.ts"],"sourcesContent":["import type { EmbedderProvider } from '@graphorin/core';\nimport {\n  EmbedderMigrationAbortedError,\n  EmbedderMigrationLockedError,\n  EmbedderMigrationStateError,\n} from '../errors/index.js';\nimport { bindEmbedder } from '../internal/embedder-binding.js';\nimport type { EmbeddingMetaRegistryLike } from '../internal/storage-adapter.js';\n\n/**\n * Coexistence policy for embedder swaps.\n *\n *  - `'lock-on-first'` (default) — refuses to register a second active\n *    embedder; surfaces an actionable error pointing at the planned\n *    migration runner.\n *  - `'multi-active'` — keeps both embedders alive (read union, write\n *    to active); used while a long migration is in flight.\n *  - `'auto-migrate'` — re-embeds existing rows in resumable batches\n *    until the source embedder has zero rows, then retires it.\n *\n * @stable\n */\nexport type EmbedderMigrationStrategy = 'lock-on-first' | 'multi-active' | 'auto-migrate';\n\n/**\n * Per-iteration progress snapshot yielded by {@link migrateEmbedder}.\n *\n * @stable\n */\nexport interface MigrationProgress {\n  /** `'fact'`, `'episode'`, or `'message'` — which entity is being migrated. */\n  readonly kind: 'fact' | 'episode' | 'message';\n  /** Number of records processed so far. */\n  readonly processed: number;\n  /** Total records expected for this entity (when known). */\n  readonly total: number;\n  /** Identifier of the source embedder (`'<adapter>:<model>@<dim>'`). */\n  readonly source: string;\n  /** Identifier of the target embedder. */\n  readonly target: string;\n  /**\n   * Identifier for this migration run. MST-12: this is an in-memory id for\n   * the current run — there is no persisted `migration_state` cursor today, so\n   * a migration does not resume across processes.\n   */\n  readonly migrationId: string;\n  /** Phase discriminator. */\n  readonly phase: 'planning' | 'running' | 'paused' | 'committed' | 'aborted';\n}\n\n/**\n * Options accepted by {@link migrateEmbedder}.\n *\n * @stable\n */\nexport interface MigrateEmbedderOptions {\n  /** Source embedder (currently active). */\n  readonly source: EmbedderProvider;\n  /** Target embedder (becomes active when migration commits). */\n  readonly target: EmbedderProvider;\n  /** Storage layer's embedder registry. */\n  readonly embeddings: EmbeddingMetaRegistryLike;\n  /** Strategy applied per `embedding_meta` row. Default `'lock-on-first'`. */\n  readonly strategy?: EmbedderMigrationStrategy;\n  /**\n   * Threshold for `auto-migrate`. The runner streams source rows in\n   * batches of `batchSize` (default `512`) and yields progress after\n   * each batch.\n   */\n  readonly batchSize?: number;\n  /** Optional cap on the number of rows to migrate per kind. */\n  readonly maxRecordsPerKind?: number;\n  /**\n   * Hook that returns the next batch of rows to re-embed for a given kind.\n   * MST-12: this is **caller-supplied** — there is no store-side helper that\n   * auto-wires it today, and `auto-migrate` throws without it. Pass a paging\n   * function over your source rows to drive the migration.\n   */\n  readonly nextBatch?: NextBatchHook;\n  /** Optional abort signal — aborting yields one final progress event. */\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Per-batch loader. Returns up to `batchSize` rows for the supplied\n * `kind` whose `embedder_id` is the source embedder. Returning an\n * empty array signals end-of-stream.\n *\n * @stable\n */\nexport type NextBatchHook = (args: {\n  readonly kind: 'fact' | 'episode' | 'message';\n  readonly source: string;\n  readonly target: string;\n  readonly batchSize: number;\n  readonly cursor: string | null;\n}) => Promise<{ readonly rows: ReadonlyArray<MigrationRow>; readonly nextCursor: string | null }>;\n\n/**\n * Single row exposed to the migration runner. The runner re-embeds\n * `text` with the target embedder; the storage adapter is responsible\n * for committing the new vector + updating `embedder_id`.\n *\n * @stable\n */\nexport interface MigrationRow {\n  readonly id: string;\n  readonly text: string;\n  readonly write: (vector: Float32Array) => Promise<void>;\n}\n\n/**\n * Stream embedder migrations as `AsyncIterable<MigrationProgress>`.\n *\n * The function is the universal entry point for every migration\n * strategy:\n *\n *  - `'lock-on-first'`: surfaces the locked error eagerly so the\n *    operator can act before any work happens.\n *  - `'multi-active'`: registers the target alongside the source and\n *    yields a single `'committed'` progress event.\n *  - `'auto-migrate'`: streams batches until the source is fully\n *    drained, then retires the source row.\n *\n * @stable\n */\nexport async function* migrateEmbedder(\n  options: MigrateEmbedderOptions,\n): AsyncGenerator<MigrationProgress, void, unknown> {\n  const { source, target, embeddings } = options;\n  const strategy = options.strategy ?? 'lock-on-first';\n  const sourceId = source.id();\n  const targetId = target.id();\n  const migrationId = `migration_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;\n\n  if (sourceId === targetId) {\n    throw new EmbedderMigrationStateError(\n      `source and target embedders must differ; both resolved to '${sourceId}'.`,\n    );\n  }\n\n  const sourceMeta = embeddings.get(sourceId);\n  if (sourceMeta === null) {\n    throw new EmbedderMigrationStateError(\n      `source embedder '${sourceId}' is not registered. Run createMemory({ embedder: source }) first.`,\n    );\n  }\n\n  if (strategy === 'lock-on-first') {\n    throw new EmbedderMigrationLockedError(sourceId, targetId);\n  }\n\n  bindEmbedder(target, embeddings);\n\n  if (strategy === 'multi-active') {\n    yield {\n      kind: 'fact',\n      processed: 0,\n      total: 0,\n      source: sourceId,\n      target: targetId,\n      migrationId,\n      phase: 'committed',\n    };\n    return;\n  }\n\n  // strategy === 'auto-migrate'\n  if (options.nextBatch === undefined) {\n    throw new EmbedderMigrationStateError(\n      \"'auto-migrate' requires a `nextBatch` hook supplied by the storage adapter.\",\n    );\n  }\n\n  const batchSize = options.batchSize ?? 512;\n  const cap = options.maxRecordsPerKind ?? Number.POSITIVE_INFINITY;\n\n  for (const kind of ['fact', 'episode', 'message'] as const) {\n    let cursor: string | null = null;\n    let processed = 0;\n    while (processed < cap) {\n      if (options.signal?.aborted === true) {\n        yield {\n          kind,\n          processed,\n          total: processed,\n          source: sourceId,\n          target: targetId,\n          migrationId,\n          phase: 'aborted',\n        };\n        throw new EmbedderMigrationAbortedError(migrationId);\n      }\n      const batch = await options.nextBatch({\n        kind,\n        source: sourceId,\n        target: targetId,\n        batchSize,\n        cursor,\n      });\n      if (batch.rows.length === 0) break;\n      const texts = batch.rows.map((r) => r.text);\n      const vectors = await target.embed(texts, {\n        ...(options.signal !== undefined ? { signal: options.signal } : {}),\n      });\n      for (let i = 0; i < batch.rows.length; i++) {\n        const row = batch.rows[i];\n        const vector = vectors[i];\n        if (row === undefined || vector === undefined) continue;\n        await row.write(vector);\n      }\n      processed += batch.rows.length;\n      cursor = batch.nextCursor;\n      yield {\n        kind,\n        processed,\n        total: processed,\n        source: sourceId,\n        target: targetId,\n        migrationId,\n        phase: 'running',\n      };\n      if (cursor === null) break;\n    }\n  }\n\n  embeddings.retire(sourceId);\n  yield {\n    kind: 'fact',\n    processed: 0,\n    total: 0,\n    source: sourceId,\n    target: targetId,\n    migrationId,\n    phase: 'committed',\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8HA,gBAAuB,gBACrB,SACkD;CAClD,MAAM,EAAE,QAAQ,QAAQ,eAAe;CACvC,MAAM,WAAW,QAAQ,YAAY;CACrC,MAAM,WAAW,OAAO,IAAI;CAC5B,MAAM,WAAW,OAAO,IAAI;CAC5B,MAAM,cAAc,aAAa,KAAK,KAAK,CAAC,SAAS,GAAG,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE;AAElG,KAAI,aAAa,SACf,OAAM,IAAI,4BACR,8DAA8D,SAAS,IACxE;AAIH,KADmB,WAAW,IAAI,SAAS,KACxB,KACjB,OAAM,IAAI,4BACR,oBAAoB,SAAS,oEAC9B;AAGH,KAAI,aAAa,gBACf,OAAM,IAAI,6BAA6B,UAAU,SAAS;AAG5D,cAAa,QAAQ,WAAW;AAEhC,KAAI,aAAa,gBAAgB;AAC/B,QAAM;GACJ,MAAM;GACN,WAAW;GACX,OAAO;GACP,QAAQ;GACR,QAAQ;GACR;GACA,OAAO;GACR;AACD;;AAIF,KAAI,QAAQ,cAAc,OACxB,OAAM,IAAI,4BACR,8EACD;CAGH,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,MAAM,QAAQ,qBAAqB,OAAO;AAEhD,MAAK,MAAM,QAAQ;EAAC;EAAQ;EAAW;EAAU,EAAW;EAC1D,IAAIA,SAAwB;EAC5B,IAAI,YAAY;AAChB,SAAO,YAAY,KAAK;AACtB,OAAI,QAAQ,QAAQ,YAAY,MAAM;AACpC,UAAM;KACJ;KACA;KACA,OAAO;KACP,QAAQ;KACR,QAAQ;KACR;KACA,OAAO;KACR;AACD,UAAM,IAAI,8BAA8B,YAAY;;GAEtD,MAAM,QAAQ,MAAM,QAAQ,UAAU;IACpC;IACA,QAAQ;IACR,QAAQ;IACR;IACA;IACD,CAAC;AACF,OAAI,MAAM,KAAK,WAAW,EAAG;GAC7B,MAAM,QAAQ,MAAM,KAAK,KAAK,MAAM,EAAE,KAAK;GAC3C,MAAM,UAAU,MAAM,OAAO,MAAM,OAAO,EACxC,GAAI,QAAQ,WAAW,SAAY,EAAE,QAAQ,QAAQ,QAAQ,GAAG,EAAE,EACnE,CAAC;AACF,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,KAAK,QAAQ,KAAK;IAC1C,MAAM,MAAM,MAAM,KAAK;IACvB,MAAM,SAAS,QAAQ;AACvB,QAAI,QAAQ,UAAa,WAAW,OAAW;AAC/C,UAAM,IAAI,MAAM,OAAO;;AAEzB,gBAAa,MAAM,KAAK;AACxB,YAAS,MAAM;AACf,SAAM;IACJ;IACA;IACA,OAAO;IACP,QAAQ;IACR,QAAQ;IACR;IACA,OAAO;IACR;AACD,OAAI,WAAW,KAAM;;;AAIzB,YAAW,OAAO,SAAS;AAC3B,OAAM;EACJ,MAAM;EACN,WAAW;EACX,OAAO;EACP,QAAQ;EACR,QAAQ;EACR;EACA,OAAO;EACR"}

package/dist/migration/index.d.ts

@@ -0,0 +1,2 @@
+import { EmbedderMigrationStrategy, MigrateEmbedderOptions, MigrationProgress, migrateEmbedder } from "./embedder-migration.js";
+export { type EmbedderMigrationStrategy, type MigrateEmbedderOptions, type MigrationProgress, migrateEmbedder };

package/dist/migration/index.js

@@ -0,0 +1,3 @@
+import { migrateEmbedder } from "./embedder-migration.js";
+
+export { migrateEmbedder };

package/dist/search/explain.d.ts

@@ -0,0 +1,74 @@
+import { MemoryHit, MemoryKind, MemoryRecord } from "@graphorin/core";
+
+//#region src/search/explain.d.ts
+
+/**
+ * Per-memory contribution breakdown for one recalled record: the
+ * decomposed signals the hybrid pipeline summed into the final score,
+ * plus the record's final rank. Surfaces *why* a single memory was
+ * recalled and how it ranked relative to its siblings.
+ *
+ * @stable
+ */
+interface RecalledMemoryExplanation {
+  /** Record id (fact / episode / insight / …). */
+  readonly id: string;
+  /** Memory kind of the recalled record. */
+  readonly kind: MemoryKind;
+  /** 1-based position in the final fused + decayed ranking. */
+  readonly rank: number;
+  /** Final score after fusion and (optional) decay. */
+  readonly score: number;
+  /**
+   * Raw per-signal scores contributing to `score`, exactly as the
+   * pipeline recorded them on the hit: FTS (`bm25`), vector similarity
+   * (`vector`), the fused reciprocal-rank terms (`rrf` + per-list
+   * `rrf.list_N`), and the decay multiplier (`decay`) when decay ran.
+   */
+  readonly signals: Readonly<Record<string, number>>;
+}
+/**
+ * Structured "why was this recalled?" explanation for one
+ * {@link SemanticMemory.search} call: the query, the reranker that
+ * fused the candidate lists, and the per-memory signal breakdown in
+ * final-rank order. Pure data — safe to attach to a span, log, or
+ * render. X-3.
+ *
+ * @stable
+ */
+interface RecallExplanation {
+  /** The query the recall ran for. */
+  readonly query: string;
+  /** Stable id of the reranker that fused the candidate lists. */
+  readonly rerankerId: string;
+  /** Number of recalled memories explained. */
+  readonly count: number;
+  /** Per-memory breakdown, in final-rank order (rank 1 first). */
+  readonly results: ReadonlyArray<RecalledMemoryExplanation>;
+}
+/**
+ * Build a {@link RecallExplanation} from a ranked hit list. Pure and
+ * deterministic: it surfaces whatever per-signal scores the hybrid
+ * pipeline left on each {@link MemoryHit.signals} (FTS, vector, RRF,
+ * decay, future graph-hop terms) without re-deriving them, so the
+ * explanation always matches what actually drove the ranking. Hits are
+ * assumed to be in final-rank order (as returned by `search`).
+ *
+ * @stable
+ */
+declare function explainRecall<TRecord extends MemoryRecord>(hits: ReadonlyArray<MemoryHit<TRecord>>, opts: {
+  readonly query: string;
+  readonly rerankerId: string;
+}): RecallExplanation;
+/**
+ * Render a {@link RecallExplanation} as a compact ASCII block — a
+ * header line plus one line per recalled memory with its signal
+ * breakdown. Pure (returns a string, no I/O); used by operator tooling
+ * and trace inspectors.
+ *
+ * @stable
+ */
+declare function formatRecallExplanation(explanation: RecallExplanation): string;
+//#endregion
+export { RecallExplanation, RecalledMemoryExplanation, explainRecall, formatRecallExplanation };
+//# sourceMappingURL=explain.d.ts.map

package/dist/search/explain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain.d.ts","names":[],"sources":["../../src/search/explain.ts"],"sourcesContent":[],"mappings":";;;;AAwGA;;;;;;;;UA9EiB,yBAAA;;;;iBAIA;;;;;;;;;;;oBAWG,SAAS;;;;;;;;;;;UAYZ,iBAAA;;;;;;;;oBAQG,cAAc;;;;;;;;;;;;iBAalB,8BAA8B,oBACtC,cAAc,UAAU;;;IAE7B;;;;;;;;;iBA2Ba,uBAAA,cAAqC"}

package/dist/search/explain.js

@@ -0,0 +1,50 @@
+//#region src/search/explain.ts
+/**
+* Build a {@link RecallExplanation} from a ranked hit list. Pure and
+* deterministic: it surfaces whatever per-signal scores the hybrid
+* pipeline left on each {@link MemoryHit.signals} (FTS, vector, RRF,
+* decay, future graph-hop terms) without re-deriving them, so the
+* explanation always matches what actually drove the ranking. Hits are
+* assumed to be in final-rank order (as returned by `search`).
+*
+* @stable
+*/
+function explainRecall(hits, opts) {
+	const results = hits.map((hit, idx) => Object.freeze({
+		id: hit.record.id,
+		kind: hit.record.kind,
+		rank: idx + 1,
+		score: hit.score,
+		signals: Object.freeze({ ...hit.signals ?? {} })
+	}));
+	return Object.freeze({
+		query: opts.query,
+		rerankerId: opts.rerankerId,
+		count: results.length,
+		results: Object.freeze(results)
+	});
+}
+/**
+* Render a {@link RecallExplanation} as a compact ASCII block — a
+* header line plus one line per recalled memory with its signal
+* breakdown. Pure (returns a string, no I/O); used by operator tooling
+* and trace inspectors.
+*
+* @stable
+*/
+function formatRecallExplanation(explanation) {
+	const header = `recall ${JSON.stringify(explanation.query)} via ${explanation.rerankerId} -> ${explanation.count} result(s)`;
+	if (explanation.results.length === 0) return header;
+	return [header, ...explanation.results.map((r) => {
+		const signals = Object.entries(r.signals).map(([key, value]) => `${key}=${formatScore(value)}`).join(" ");
+		const suffix = signals === "" ? "" : ` (${signals})`;
+		return `  #${r.rank} ${r.id} [${r.kind}] score=${formatScore(r.score)}${suffix}`;
+	})].join("\n");
+}
+function formatScore(value) {
+	return Number.isFinite(value) ? value.toFixed(4) : String(value);
+}
+
+//#endregion
+export { explainRecall, formatRecallExplanation };
+//# sourceMappingURL=explain.js.map

package/dist/search/explain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain.js","names":[],"sources":["../../src/search/explain.ts"],"sourcesContent":["/**\n * Recall explainability for `@graphorin/memory` — \"why was this\n * recalled?\" (X-3). Turns the per-signal scores the hybrid pipeline\n * already records on each {@link MemoryHit} (FTS `bm25`, vector\n * similarity, the fused reciprocal-rank term, the decay multiplier,\n * future graph-hop terms) into a structured, renderable explanation.\n *\n * Pure data: the builder re-uses whatever {@link MemoryHit.signals} the\n * pipeline left behind rather than re-deriving them, so the explanation\n * always matches the ranking that actually happened. The renderer\n * returns a string and performs no I/O, so the explanation can be\n * attached to a span, logged, or surfaced by operator tooling.\n *\n * @packageDocumentation\n */\n\nimport type { MemoryHit, MemoryKind, MemoryRecord } from '@graphorin/core';\n\n/**\n * Per-memory contribution breakdown for one recalled record: the\n * decomposed signals the hybrid pipeline summed into the final score,\n * plus the record's final rank. Surfaces *why* a single memory was\n * recalled and how it ranked relative to its siblings.\n *\n * @stable\n */\nexport interface RecalledMemoryExplanation {\n  /** Record id (fact / episode / insight / …). */\n  readonly id: string;\n  /** Memory kind of the recalled record. */\n  readonly kind: MemoryKind;\n  /** 1-based position in the final fused + decayed ranking. */\n  readonly rank: number;\n  /** Final score after fusion and (optional) decay. */\n  readonly score: number;\n  /**\n   * Raw per-signal scores contributing to `score`, exactly as the\n   * pipeline recorded them on the hit: FTS (`bm25`), vector similarity\n   * (`vector`), the fused reciprocal-rank terms (`rrf` + per-list\n   * `rrf.list_N`), and the decay multiplier (`decay`) when decay ran.\n   */\n  readonly signals: Readonly<Record<string, number>>;\n}\n\n/**\n * Structured \"why was this recalled?\" explanation for one\n * {@link SemanticMemory.search} call: the query, the reranker that\n * fused the candidate lists, and the per-memory signal breakdown in\n * final-rank order. Pure data — safe to attach to a span, log, or\n * render. X-3.\n *\n * @stable\n */\nexport interface RecallExplanation {\n  /** The query the recall ran for. */\n  readonly query: string;\n  /** Stable id of the reranker that fused the candidate lists. */\n  readonly rerankerId: string;\n  /** Number of recalled memories explained. */\n  readonly count: number;\n  /** Per-memory breakdown, in final-rank order (rank 1 first). */\n  readonly results: ReadonlyArray<RecalledMemoryExplanation>;\n}\n\n/**\n * Build a {@link RecallExplanation} from a ranked hit list. Pure and\n * deterministic: it surfaces whatever per-signal scores the hybrid\n * pipeline left on each {@link MemoryHit.signals} (FTS, vector, RRF,\n * decay, future graph-hop terms) without re-deriving them, so the\n * explanation always matches what actually drove the ranking. Hits are\n * assumed to be in final-rank order (as returned by `search`).\n *\n * @stable\n */\nexport function explainRecall<TRecord extends MemoryRecord>(\n  hits: ReadonlyArray<MemoryHit<TRecord>>,\n  opts: { readonly query: string; readonly rerankerId: string },\n): RecallExplanation {\n  const results = hits.map(\n    (hit, idx): RecalledMemoryExplanation =>\n      Object.freeze({\n        id: hit.record.id,\n        kind: hit.record.kind,\n        rank: idx + 1,\n        score: hit.score,\n        signals: Object.freeze({ ...(hit.signals ?? {}) }),\n      }),\n  );\n  return Object.freeze({\n    query: opts.query,\n    rerankerId: opts.rerankerId,\n    count: results.length,\n    results: Object.freeze(results),\n  });\n}\n\n/**\n * Render a {@link RecallExplanation} as a compact ASCII block — a\n * header line plus one line per recalled memory with its signal\n * breakdown. Pure (returns a string, no I/O); used by operator tooling\n * and trace inspectors.\n *\n * @stable\n */\nexport function formatRecallExplanation(explanation: RecallExplanation): string {\n  const header = `recall ${JSON.stringify(explanation.query)} via ${explanation.rerankerId} -> ${explanation.count} result(s)`;\n  if (explanation.results.length === 0) return header;\n  const lines = explanation.results.map((r) => {\n    const signals = Object.entries(r.signals)\n      .map(([key, value]) => `${key}=${formatScore(value)}`)\n      .join(' ');\n    const suffix = signals === '' ? '' : ` (${signals})`;\n    return `  #${r.rank} ${r.id} [${r.kind}] score=${formatScore(r.score)}${suffix}`;\n  });\n  return [header, ...lines].join('\\n');\n}\n\nfunction formatScore(value: number): string {\n  return Number.isFinite(value) ? value.toFixed(4) : String(value);\n}\n"],"mappings":";;;;;;;;;;;AA0EA,SAAgB,cACd,MACA,MACmB;CACnB,MAAM,UAAU,KAAK,KAClB,KAAK,QACJ,OAAO,OAAO;EACZ,IAAI,IAAI,OAAO;EACf,MAAM,IAAI,OAAO;EACjB,MAAM,MAAM;EACZ,OAAO,IAAI;EACX,SAAS,OAAO,OAAO,EAAE,GAAI,IAAI,WAAW,EAAE,EAAG,CAAC;EACnD,CAAC,CACL;AACD,QAAO,OAAO,OAAO;EACnB,OAAO,KAAK;EACZ,YAAY,KAAK;EACjB,OAAO,QAAQ;EACf,SAAS,OAAO,OAAO,QAAQ;EAChC,CAAC;;;;;;;;;;AAWJ,SAAgB,wBAAwB,aAAwC;CAC9E,MAAM,SAAS,UAAU,KAAK,UAAU,YAAY,MAAM,CAAC,OAAO,YAAY,WAAW,MAAM,YAAY,MAAM;AACjH,KAAI,YAAY,QAAQ,WAAW,EAAG,QAAO;AAQ7C,QAAO,CAAC,QAAQ,GAPF,YAAY,QAAQ,KAAK,MAAM;EAC3C,MAAM,UAAU,OAAO,QAAQ,EAAE,QAAQ,CACtC,KAAK,CAAC,KAAK,WAAW,GAAG,IAAI,GAAG,YAAY,MAAM,GAAG,CACrD,KAAK,IAAI;EACZ,MAAM,SAAS,YAAY,KAAK,KAAK,KAAK,QAAQ;AAClD,SAAO,MAAM,EAAE,KAAK,GAAG,EAAE,GAAG,IAAI,EAAE,KAAK,UAAU,YAAY,EAAE,MAAM,GAAG;GACxE,CACuB,CAAC,KAAK,KAAK;;AAGtC,SAAS,YAAY,OAAuB;AAC1C,QAAO,OAAO,SAAS,MAAM,GAAG,MAAM,QAAQ,EAAE,GAAG,OAAO,MAAM"}

package/dist/search/index.d.ts

@@ -0,0 +1,6 @@
+import { DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_MAX_ITERATIONS, DifficultyAssessment, DifficultyGateOptions, IterativeRetrievalDeps, IterativeRetrievalOptions, IterativeRetrievalResult, MAX_ITERATIONS_CEILING, RETRIEVAL_GRADE_SYSTEM_PROMPT, RetrievalGrade, RetrievalGradeOptions, RetrievalGrader, assessQueryDifficulty, buildGradeRequest, createProviderRetrievalGrader, parseGrade, runIterativeRetrieval } from "./iterative.js";
+import { DEFAULT_MAX_QUERY_VARIANTS, HYDE_SYSTEM_PROMPT, QUERY_EXPANSION_SYSTEM_PROMPT, QueryTransformOptions, QueryTransformer, buildExpansionRequest, buildHydeRequest, createProviderQueryTransformer, parseHypothetical, parseQueryVariants } from "./query-transform.js";
+import { ReRankOptions, ReRanker } from "./types.js";
+import { RecallExplanation, RecalledMemoryExplanation, explainRecall, formatRecallExplanation } from "./explain.js";
+import { RRFReranker, RRF_DEFAULT_K, WeightedRRFReranker, fuseRrf, fuseWeighted } from "./rrf.js";
+export { DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_MAX_ITERATIONS, DEFAULT_MAX_QUERY_VARIANTS, type DifficultyAssessment, type DifficultyGateOptions, HYDE_SYSTEM_PROMPT, type IterativeRetrievalDeps, type IterativeRetrievalOptions, type IterativeRetrievalResult, MAX_ITERATIONS_CEILING, QUERY_EXPANSION_SYSTEM_PROMPT, type QueryTransformOptions, type QueryTransformer, RETRIEVAL_GRADE_SYSTEM_PROMPT, RRFReranker, RRF_DEFAULT_K, type ReRankOptions, type ReRanker, type RecallExplanation, type RecalledMemoryExplanation, type RetrievalGrade, type RetrievalGradeOptions, type RetrievalGrader, WeightedRRFReranker, assessQueryDifficulty, buildExpansionRequest, buildGradeRequest, buildHydeRequest, createProviderQueryTransformer, createProviderRetrievalGrader, explainRecall, formatRecallExplanation, fuseRrf, fuseWeighted, parseGrade, parseHypothetical, parseQueryVariants, runIterativeRetrieval };

package/dist/search/index.js

@@ -0,0 +1,6 @@
+import { DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_MAX_ITERATIONS, MAX_ITERATIONS_CEILING, RETRIEVAL_GRADE_SYSTEM_PROMPT, assessQueryDifficulty, buildGradeRequest, createProviderRetrievalGrader, parseGrade, runIterativeRetrieval } from "./iterative.js";
+import { DEFAULT_MAX_QUERY_VARIANTS, HYDE_SYSTEM_PROMPT, QUERY_EXPANSION_SYSTEM_PROMPT, buildExpansionRequest, buildHydeRequest, createProviderQueryTransformer, parseHypothetical, parseQueryVariants } from "./query-transform.js";
+import { RRFReranker, RRF_DEFAULT_K, WeightedRRFReranker, fuseRrf, fuseWeighted } from "./rrf.js";
+import { explainRecall, formatRecallExplanation } from "./explain.js";
+
+export { DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_MAX_ITERATIONS, DEFAULT_MAX_QUERY_VARIANTS, HYDE_SYSTEM_PROMPT, MAX_ITERATIONS_CEILING, QUERY_EXPANSION_SYSTEM_PROMPT, RETRIEVAL_GRADE_SYSTEM_PROMPT, RRFReranker, RRF_DEFAULT_K, WeightedRRFReranker, assessQueryDifficulty, buildExpansionRequest, buildGradeRequest, buildHydeRequest, createProviderQueryTransformer, createProviderRetrievalGrader, explainRecall, formatRecallExplanation, fuseRrf, fuseWeighted, parseGrade, parseHypothetical, parseQueryVariants, runIterativeRetrieval };