@fgv/ts-agent-memory 5.1.0-47 → 5.1.0-49

package/src/packlets/observe/index.ts

@@ -1,7 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-export * from './observer';
-export * from './memoryObservationStore';

package/src/packlets/observe/memoryObservationStore.ts

@@ -1,153 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import { Collections, Result, fail, succeed } from '@fgv/ts-utils';
-import { IMemoryObservationQuery, IMemoryObservationRecord, IMemoryObserver } from './observer';
-
-/**
- * Construction options for {@link MemoryObservationStore.create}.
- * @public
- */
-export interface IMemoryObservationStoreCreateParams {
-  /**
-   * Maximum number of observation records retained before the oldest is
-   * overwritten. Defaults to `1000`. Must be a positive integer if supplied.
-   */
-  readonly maxRecords?: number;
-}
-
-/**
- * The default in-memory observation store: an {@link IMemoryObserver} that
- * retains the records it observes in a bounded ring and answers schema-aware
- * {@link MemoryObservationStore.query | queries} over them.
- *
- * @remarks
- * **Privacy posture — this store is most-permissive by design.** It retains
- * every field of every record verbatim, including any `provenance` and
- * `querySnapshot`. The library bakes in **no** redaction, retention, or
- * field-stripping policy — that is deployment policy, not library policy. A
- * deployment that must redact wraps this store with its own
- * {@link IMemoryObserver} that transforms records before forwarding, or
- * substitutes a different observer entirely. Size is the only bounded
- * dimension, via `maxRecords`.
- *
- * The store composes `RetainingRingBuffer` from `@fgv/ts-utils` (it does not
- * hand-roll a ring) and implements {@link IMemoryObserver} directly — `observe`
- * (the hook) and `query` (the read surface) live on the same class. Wire it via
- * {@link IFileTreeMemoryStoreCreateParams.observers}. `seq` and `timestamp` are
- * assigned by the firing authority (the store) before `observe`, so this store
- * never mints them.
- * @public
- */
-export class MemoryObservationStore implements IMemoryObserver {
-  /**
-   * The bounded ring of observed records. The firing authority assigns each
-   * record's `seq`, so the ring's monotonic-`seq` cursor contract is satisfied
-   * by that authority's per-instance counter.
-   * @internal
-   */
-  private readonly _buffer: Collections.RetainingRingBuffer<IMemoryObservationRecord>;
-
-  /**
-   * @param buffer - The pre-constructed backing ring buffer.
-   * @internal
-   */
-  private constructor(buffer: Collections.RetainingRingBuffer<IMemoryObservationRecord>) {
-    this._buffer = buffer;
-  }
-
-  /**
-   * The highest `seq` observed so far. Hold this value and pass it as
-   * `sinceSeq` to {@link MemoryObservationStore.query | query} to page only
-   * records observed afterward. Stable across ring eviction and
-   * {@link MemoryObservationStore.clear | clear}.
-   */
-  public get lastSeq(): number {
-    return this._buffer.lastSeq;
-  }
-
-  /**
-   * The number of records currently retained.
-   */
-  public get size(): number {
-    return this._buffer.size;
-  }
-
-  /**
-   * Family-convention factory.
-   * @param params - {@link IMemoryObservationStoreCreateParams | Construction options}.
-   * @returns On success, a new store. Fails if `maxRecords` is supplied and is
-   * not a positive integer.
-   */
-  public static create(params?: IMemoryObservationStoreCreateParams): Result<MemoryObservationStore> {
-    const maxRecords: number | undefined = params?.maxRecords;
-    if (maxRecords !== undefined && (!Number.isInteger(maxRecords) || maxRecords < 1)) {
-      return fail(`MemoryObservationStore: maxRecords must be a positive integer (got ${maxRecords})`);
-    }
-    return succeed(
-      new MemoryObservationStore(
-        new Collections.RetainingRingBuffer<IMemoryObservationRecord>({ maxRecords })
-      )
-    );
-  }
-
-  /**
-   * {@inheritDoc IMemoryObserver.observe}
-   */
-  public observe(record: IMemoryObservationRecord): Promise<Result<unknown>> {
-    this._buffer.push(record);
-    return Promise.resolve(succeed(record));
-  }
-
-  /**
-   * Returns retained records, oldest-first, narrowed by the supplied criteria.
-   * @param criteria - {@link IMemoryObservationQuery | AND-combined filter criteria}.
-   * @returns The matching records, oldest-first.
-   */
-  public query(criteria?: IMemoryObservationQuery): ReadonlyArray<IMemoryObservationRecord> {
-    return this._buffer.query({
-      sinceSeq: criteria?.sinceSeq,
-      limit: criteria?.limit,
-      filter:
-        criteria === undefined ? undefined : (record) => MemoryObservationStore._matches(record, criteria)
-    });
-  }
-
-  /**
-   * Clears all retained records. Does NOT reset
-   * {@link MemoryObservationStore.lastSeq | lastSeq}, so a held `sinceSeq`
-   * cursor never re-sees a sequence number.
-   */
-  public clear(): void {
-    this._buffer.clear();
-  }
-
-  /**
-   * Tests a record against the non-`seq`/`limit` criteria (those are applied by
-   * the ring buffer itself).
-   * @internal
-   */
-  private static _matches(record: IMemoryObservationRecord, criteria: IMemoryObservationQuery): boolean {
-    if (criteria.since !== undefined && record.timestamp < criteria.since) {
-      return false;
-    }
-    if (criteria.until !== undefined && record.timestamp > criteria.until) {
-      return false;
-    }
-    if (criteria.scope !== undefined && record.scope !== criteria.scope) {
-      return false;
-    }
-    if (criteria.kind !== undefined && record.kind !== criteria.kind) {
-      return false;
-    }
-    if (criteria.phase !== undefined && record.phase !== criteria.phase) {
-      return false;
-    }
-    if (criteria.outcome !== undefined && record.outcome !== criteria.outcome) {
-      return false;
-    }
-    return true;
-  }
-}

package/src/packlets/observe/observer.ts

@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import { Result } from '@fgv/ts-utils';
-import { IProvenance, Kind, MemoryId, MemoryScopeKey } from '../types';
-
-/**
- * The store/retriever operation an observation record describes.
- *
- * @remarks
- * `'read'` / `'write'` / `'delete'` are fired post-op by
- * {@link FileTreeMemoryStore} (on `get` / `put` / `delete` respectively) when
- * observers are wired. `'retrieve'` is reserved for retriever-fired
- * observations; no B2 retriever fires one (a single seq authority per
- * observation store is the supported topology), so it never appears in B2 but
- * is part of the vocabulary so a future retriever-firing hook is additive.
- * @public
- */
-export type MemoryObservationPhase = 'read' | 'write' | 'delete' | 'retrieve';
-
-/**
- * The outcome of the observed operation.
- * @public
- */
-export type MemoryObservationOutcome = 'success' | 'failure';
-
-/**
- * A single audit record produced by an observed store (or retriever) operation.
- *
- * @remarks
- * `seq` and `timestamp` are assigned by the firing authority (the store) before
- * fan-out, so the same record carries the same `seq` across every observer it
- * lands in. `seq` is strictly increasing per authority, satisfying the
- * `RetainingRingBuffer` cursor contract that {@link MemoryObservationStore}
- * relies on.
- * @public
- */
-export interface IMemoryObservationRecord {
-  /**
-   * Monotonic 1-based sequence number assigned by the firing authority, stable
-   * across a store's ring eviction. The ordering / paging key.
-   */
-  readonly seq: number;
-  /** Milliseconds since epoch when the firing authority produced the record. */
-  readonly timestamp: number;
-  /** Which operation this record describes. */
-  readonly phase: MemoryObservationPhase;
-  /** The scope the operation touched, when resolvable. */
-  readonly scope?: MemoryScopeKey;
-  /** The record id the operation touched, when resolvable. */
-  readonly id?: MemoryId;
-  /** The kind the operation targeted, when known. */
-  readonly kind?: Kind;
-  /** Whether the operation succeeded. */
-  readonly outcome: MemoryObservationOutcome;
-  /** Present on failure: the failure `Result`'s message. */
-  readonly error?: string;
-  /** Structured provenance of the write, when the operation carried one. */
-  readonly provenance?: IProvenance;
-  /**
-   * For `'retrieve'` observations: an opaque snapshot of the query that drove
-   * the retrieval. Carried verbatim; never interpreted by the store.
-   */
-  readonly querySnapshot?: Readonly<Record<string, unknown>>;
-}
-
-/**
- * Single-method async observer hook. The store fires `observe` once per public
- * `get` / `put` / `delete` call when observers are wired.
- *
- * @remarks
- * Observer errors never affect the store operation — the store swallows a
- * failed `Result` or a thrown / rejected `observe`, logging it to the injected
- * diagnostic logger at `warn`.
- * @public
- */
-export interface IMemoryObserver {
-  /**
-   * When `true`, the store dispatches `observe` without awaiting it, so a slow
-   * remote observer (SIEM, network sink) does not extend the store operation's
-   * latency. Defaults to `false` (awaited), which is correct for the cheap
-   * in-memory default {@link MemoryObservationStore}. Errors are swallowed
-   * either way.
-   */
-  readonly fireAndForget?: boolean;
-  /**
-   * Receives a fully-formed observation record.
-   * @param record - The observation record.
-   * @returns A `Result` whose failure is swallowed (logged to the store's
-   * diagnostic logger). A rejected promise is likewise swallowed.
-   */
-  observe(record: IMemoryObservationRecord): Promise<Result<unknown>>;
-}
-
-/**
- * Query criteria for {@link MemoryObservationStore.query}. All supplied criteria
- * are AND-combined.
- * @public
- */
-export interface IMemoryObservationQuery {
-  /** Only records with `seq > sinceSeq` (incremental paging cursor). */
-  readonly sinceSeq?: number;
-  /** Return at most this many records — the most-recent N, still oldest-first. */
-  readonly limit?: number;
-  /** Only records with `timestamp >= since`. */
-  readonly since?: number;
-  /** Only records with `timestamp <= until`. */
-  readonly until?: number;
-  /** Only records that touched this scope. */
-  readonly scope?: MemoryScopeKey;
-  /** Only records that targeted this kind. */
-  readonly kind?: Kind;
-  /** Only records of this phase. */
-  readonly phase?: MemoryObservationPhase;
-  /** Only records with this outcome. */
-  readonly outcome?: MemoryObservationOutcome;
-}

package/src/packlets/retrieve/fragmentSemanticRetriever.ts

@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import { Result, fail, succeed } from '@fgv/ts-utils';
-import { IFragmentVectorIndex, IVectorQueryHit } from '../vector';
-import { QueryEmbedder } from './semanticRetriever';
-
-/**
- * The loud-degradation message a {@link FragmentSemanticRetriever} returns when a
- * fragment query is issued but no {@link IFragmentSemanticBackend | backend} is
- * wired — the discovery surface NEVER answers a fragment query with a silent empty.
- * @public
- */
-export const FRAGMENT_SEMANTIC_UNWIRED_MESSAGE: string =
-  'fragment recall: no fragment index is wired; wire an IFragmentSemanticBackend to enable sub-document search';
-
-/**
- * The fragment backend wired into a {@link FragmentSemanticRetriever}: the fragment
- * index to query and the embedder that turns the query text into a vector. Both are
- * required together — a fragment index is useless without a way to embed the query.
- * @public
- */
-export interface IFragmentSemanticBackend {
-  /** The fragment-granular vector index to query. */
-  readonly fragmentIndex: IFragmentVectorIndex;
-  /** Turns the query text into a vector. */
-  readonly embedQuery: QueryEmbedder;
-}
-
-/**
- * A sub-document semantic-search request: the natural-language `semantic` text to
- * match, an optional `topK` result cap (default 10), and an optional
- * `maxPerRecord` cap that keeps one long document from monopolizing the result.
- * @public
- */
-export interface IFragmentQuery {
-  /** The natural-language text to embed and match against stored fragments. */
-  readonly semantic: string;
-  /** Maximum number of fragment hits to return. Defaults to 10. */
-  readonly topK?: number;
-  /**
-   * Maximum number of fragments any single record may contribute to the result.
-   * Applied during selection (before the `topK` cut). Omit for uncapped.
-   */
-  readonly maxPerRecord?: number;
-}
-
-/**
- * What a {@link FragmentSemanticRetriever} can do given its wiring.
- * @public
- */
-export interface IFragmentRetrieverCapabilities {
-  /** `true` when a fragment backend is wired and fragment recall is operational. */
-  readonly supportsFragmentRecall: boolean;
-}
-
-/**
- * The sub-document semantic-search retriever — the "discovery" half of a
- * search-then-read contract. It embeds a fragment query, queries the
- * {@link IFragmentVectorIndex}, and returns the raw per-fragment
- * {@link IVectorQueryHit | hits} (each carrying a record `target` AND whichever of
- * `locator` / `fragmentId` the stored fragment was indexed with), NOT resolved
- * records: the consumer re-reads each record and resolves the fragment on its own
- * read side. Note the `locator` span is advisory — see {@link IFragmentLocator}; it
- * is not a slice guaranteed to reproduce the fragment's text.
- *
- * @remarks
- * Deliberately NOT an {@link IMemoryRetriever}: memory recall is record-granular and
- * returns records; fragment discovery is fragment-granular and returns fragment
- * identities. Keeping it a distinct surface matches the consumer contract (memory
- * stays record-granular; sub-document knowledge uses a separate fragment index) and
- * avoids overloading the record retriever's return type with identity fields that
- * only make sense here.
- *
- * When no backend is wired, `supportsFragmentRecall` is `false` and any fragment
- * query degrades loudly ({@link FRAGMENT_SEMANTIC_UNWIRED_MESSAGE}) — it NEVER
- * returns a silent empty. A consumer-supplied backend that rejects (throws) is
- * normalized into a `Failure`.
- * @public
- */
-export class FragmentSemanticRetriever {
-  private readonly _backend: IFragmentSemanticBackend | undefined;
-
-  private constructor(backend: IFragmentSemanticBackend | undefined) {
-    this._backend = backend;
-  }
-
-  /** What this retriever can do given its wiring. */
-  public get capabilities(): IFragmentRetrieverCapabilities {
-    return { supportsFragmentRecall: this._backend !== undefined };
-  }
-
-  /** Family-convention factory. */
-  public static create(params: {
-    readonly backend?: IFragmentSemanticBackend;
-  }): Result<FragmentSemanticRetriever> {
-    return succeed(new FragmentSemanticRetriever(params.backend));
-  }
-
-  /**
-   * Embed `query.semantic`, query the fragment index, and return the per-fragment
-   * hits in descending score order. Fails loudly when no backend is wired.
-   */
-  public async retrieve(query: IFragmentQuery): Promise<Result<ReadonlyArray<IVectorQueryHit>>> {
-    if (this._backend === undefined) {
-      return fail(FRAGMENT_SEMANTIC_UNWIRED_MESSAGE);
-    }
-    const backend: IFragmentSemanticBackend = this._backend;
-    // Consumer-supplied hooks may throw; normalize both a returned `fail` and a
-    // rejection into a single `fragment recall: <label> failed` Failure so
-    // `retrieve` always honors its `Promise<Result<...>>` contract.
-    const embedded: Result<Float32Array> = await FragmentSemanticRetriever._callBackend(
-      'query embedding',
-      () => backend.embedQuery(query.semantic)
-    );
-    if (embedded.isFailure()) {
-      return fail(embedded.message);
-    }
-    return FragmentSemanticRetriever._callBackend('fragment query', () =>
-      backend.fragmentIndex.query(embedded.value, query.topK ?? 10, query.maxPerRecord)
-    );
-  }
-
-  /**
-   * Invoke a consumer-supplied backend hook, normalizing both a returned `fail`
-   * and a thrown/rejected promise into a single `fragment recall: <label> failed`
-   * `Failure`.
-   */
-  private static async _callBackend<T>(label: string, op: () => Promise<Result<T>>): Promise<Result<T>> {
-    try {
-      return (await op()).withErrorFormat((msg) => `fragment recall: ${label} failed: ${msg}`);
-    } catch (err) {
-      return fail(`fragment recall: ${label} failed: ${String(err)}`);
-    }
-  }
-}

package/src/packlets/retrieve/hybridRetriever.ts

@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import { Result, fail, mapResults, succeed } from '@fgv/ts-utils';
-import { IMemoryRecord, MemoryId } from '../types';
-import {
-  IMemoryQuery,
-  IMemoryRetriever,
-  IMemoryRetrieverCapabilities,
-  guardRetrieverCapabilities,
-  limitRecords,
-  rankCompare,
-  recencyCompare
-} from './retriever';
-
-/**
- * Strategy for combining the result sets of the retrievers a
- * {@link HybridRetriever} composes. Injectable so a consumer can weight,
- * re-rank, or intersect instead of the default union.
- * @public
- */
-export interface IMergeStrategy {
-  /**
-   * Merge the per-retriever result sets into a single ordered result.
-   * @param resultSets - One entry per composed retriever, in composition order.
-   */
-  merge(
-    resultSets: ReadonlyArray<ReadonlyArray<IMemoryRecord<unknown>>>
-  ): Result<ReadonlyArray<IMemoryRecord<unknown>>>;
-}
-
-/**
- * The reference {@link IMergeStrategy}: a score-union. Every record is scored by
- * the number of composed result sets it appears in (deduplicated by
- * {@link IMemoryEnvelope.id | id}); the merged result is ordered by descending
- * score, then by recency. Records surfaced by more retrievers rank higher.
- *
- * @remarks
- * Dedup is by `id` alone, which is unambiguous for the flat (one-file-per-entity)
- * kinds B2 ships. Phase-C versioned kinds that reuse a stem across scopes will
- * extend the dedup key — additive, no API change.
- * @public
- */
-export class ScoreUnionMergeStrategy implements IMergeStrategy {
-  private constructor() {}
-
-  /** Family-convention factory. */
-  public static create(): Result<ScoreUnionMergeStrategy> {
-    return succeed(new ScoreUnionMergeStrategy());
-  }
-
-  /** {@inheritDoc IMergeStrategy.merge} */
-  public merge(
-    resultSets: ReadonlyArray<ReadonlyArray<IMemoryRecord<unknown>>>
-  ): Result<ReadonlyArray<IMemoryRecord<unknown>>> {
-    const scored: Map<MemoryId, { readonly record: IMemoryRecord<unknown>; score: number }> = new Map();
-    for (const set of resultSets) {
-      // Count each id at most once per result set, so the score is "how many
-      // retrievers surfaced this record" rather than "how many copies total".
-      const seenInSet: Set<MemoryId> = new Set<MemoryId>();
-      for (const record of set) {
-        const id: MemoryId = record.envelope.id;
-        if (seenInSet.has(id)) {
-          continue;
-        }
-        seenInSet.add(id);
-        const existing = scored.get(id);
-        if (existing === undefined) {
-          scored.set(id, { record, score: 1 });
-        } else {
-          existing.score += 1;
-        }
-      }
-    }
-    const merged: IMemoryRecord<unknown>[] = Array.from(scored.values())
-      .sort((a, b) => (b.score !== a.score ? b.score - a.score : recencyCompare(a.record, b.record)))
-      .map((entry) => entry.record);
-    return succeed(merged);
-  }
-}
-
-/**
- * Composes several retrievers, dispatches a query to each, and merges their
- * results via an injectable {@link IMergeStrategy}. Its capabilities are the
- * union of the composed retrievers' capabilities.
- *
- * @remarks
- * The hybrid enforces the loud-degradation contract against its OWN (union)
- * capabilities, then projects the query for each child: a child that does not
- * support the `semantic` (or `asOf`) axis is handed a query with that axis
- * stripped, so it returns its normal results instead of loud-failing on a field
- * a sibling handles. A child that genuinely fails (e.g. a wired semantic backend
- * erroring) propagates — the hybrid never silently drops a failure.
- * @public
- */
-export class HybridRetriever implements IMemoryRetriever {
-  private readonly _retrievers: ReadonlyArray<IMemoryRetriever>;
-  private readonly _mergeStrategy: IMergeStrategy;
-  private readonly _capabilities: IMemoryRetrieverCapabilities;
-
-  private constructor(
-    retrievers: ReadonlyArray<IMemoryRetriever>,
-    mergeStrategy: IMergeStrategy,
-    capabilities: IMemoryRetrieverCapabilities
-  ) {
-    this._retrievers = retrievers;
-    this._mergeStrategy = mergeStrategy;
-    this._capabilities = capabilities;
-  }
-
-  /** {@inheritDoc IMemoryRetriever.capabilities} */
-  public get capabilities(): IMemoryRetrieverCapabilities {
-    return this._capabilities;
-  }
-
-  /**
-   * Family-convention factory.
-   * @param retrievers - The retrievers to compose (at least one).
-   * @param mergeStrategy - How to combine their results.
-   */
-  public static create(
-    retrievers: ReadonlyArray<IMemoryRetriever>,
-    mergeStrategy: IMergeStrategy
-  ): Result<HybridRetriever> {
-    if (retrievers.length === 0) {
-      return fail('HybridRetriever: at least one retriever is required');
-    }
-    // Snapshot the caller's array so a later mutation cannot make `retrieve()`
-    // and the cached `capabilities` disagree.
-    const stableRetrievers: ReadonlyArray<IMemoryRetriever> = [...retrievers];
-    const capabilities: IMemoryRetrieverCapabilities = {
-      supportsSemanticRecall: stableRetrievers.some((r) => r.capabilities.supportsSemanticRecall),
-      supportsTemporalQuery: stableRetrievers.some((r) => r.capabilities.supportsTemporalQuery),
-      supportsLinkTraversal: stableRetrievers.some((r) => r.capabilities.supportsLinkTraversal)
-    };
-    return succeed(new HybridRetriever(stableRetrievers, mergeStrategy, capabilities));
-  }
-
-  /** {@inheritDoc IMemoryRetriever.retrieve} */
-  public async retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>> {
-    return guardRetrieverCapabilities(query, this._capabilities).thenOnSuccess(async () => {
-      const perRetriever: Result<ReadonlyArray<IMemoryRecord<unknown>>>[] = await Promise.all(
-        this._retrievers.map((retriever) => retriever.retrieve(this._projectQuery(query, retriever)))
-      );
-      return mapResults(perRetriever)
-        .onSuccess((resultSets) => this._mergeStrategy.merge(resultSets))
-        .onSuccess((merged) => {
-          // `orderBy: 'rank'` re-orders the merged set by rank (descending, absent
-          // last) before the page window, so a rank-ordered hybrid query yields a
-          // rank-ordered page. Absent / `'recency'` preserves the merge strategy's
-          // own ordering (byte-identical to the pre-`orderBy` behavior).
-          const ordered: ReadonlyArray<IMemoryRecord<unknown>> =
-            query.orderBy === 'rank' ? [...merged].sort(rankCompare) : merged;
-          return succeed(limitRecords(ordered, query.limit, query.offset));
-        });
-    });
-  }
-
-  /**
-   * Project the query for one child retriever. Two adjustments:
-   *
-   * - Strip axes the child does not support (`semantic` / `topK` for a
-   *   non-semantic child, `asOf` for a non-temporal child, the link axes for a
-   *   non-link child) so it returns its normal results rather than loud-failing
-   *   on a field a sibling handles.
-   * - Strip `limit` unconditionally: limit is a post-merge concern. A child that
-   *   pre-truncated its result set would starve the merge strategy of candidates
-   *   it needs to score correctly (a record both children would surface must
-   *   reach the merge to score 2). The hybrid applies `limit` once, after merge.
-   */
-  private _projectQuery(query: IMemoryQuery, retriever: IMemoryRetriever): IMemoryQuery {
-    const projected: { -readonly [K in keyof IMemoryQuery]: IMemoryQuery[K] } = { ...query };
-    delete projected.limit;
-    // Offset, like limit, is a post-merge concern: a child that pre-skipped its
-    // own ordered set would drop candidates the merge needs to score correctly.
-    // The hybrid applies the `{ offset, limit }` window once, after merge.
-    delete projected.offset;
-    if (!retriever.capabilities.supportsSemanticRecall) {
-      delete projected.semantic;
-      delete projected.topK;
-    }
-    if (!retriever.capabilities.supportsTemporalQuery) {
-      delete projected.asOf;
-    }
-    if (!retriever.capabilities.supportsLinkTraversal) {
-      delete projected.linkedFrom;
-      delete projected.linkedTo;
-      delete projected.hops;
-    }
-    return projected;
-  }
-}

package/src/packlets/retrieve/index.ts

@@ -1,14 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-export * from './retriever';
-export * from './recencyRetriever';
-export * from './linkTraversalRetriever';
-export * from './tagRetriever';
-export * from './structuredFilterRetriever';
-export * from './semanticRetriever';
-export * from './fragmentSemanticRetriever';
-export * from './temporalRetrievers';
-export * from './hybridRetriever';