@fgv/ts-agent-memory 5.1.0-39 → 5.1.0-41

package/src/test/unit/vector/inMemoryCosineIndex.test.ts

@@ -6,13 +6,21 @@
 import '@fgv/ts-utils-jest';
 import { Result, fail, succeed } from '@fgv/ts-utils';
 import {
+  IEdgeTarget,
   IMemoryRecord,
   IMemoryRecordSource,
+  IScopedMemoryRecord,
   IVectorQueryHit,
   InMemoryCosineIndex,
-  MemoryId
+  MemoryId,
+  MemoryScopeKey
 } from '../../../index';
 
+/** A scope-qualified target from a `(scope, id)` pair. */
+function target(scope: string, id: string): IEdgeTarget {
+  return { scope: scope as MemoryScopeKey, id: id as MemoryId };
+}
+
 /** A trivial record carrying just the id + a marker body, for rebuild tests. */
 function record(id: string, body: string = `body-${id}`): IMemoryRecord<unknown> {
   return {
@@ -22,30 +30,37 @@ function record(id: string, body: string = `body-${id}`): IMemoryRecord<unknown>
   };
 }
 
+/** A scope-qualified record entry for a rebuild source. */
+function scoped(scope: string, id: string, body?: string): IScopedMemoryRecord {
+  return { target: target(scope, id), record: record(id, body) };
+}
+
 /** A scripted record source for `rebuild`. */
 class FakeSource implements IMemoryRecordSource {
-  private readonly _result: Result<ReadonlyArray<IMemoryRecord<unknown>>>;
-  public constructor(result: Result<ReadonlyArray<IMemoryRecord<unknown>>>) {
+  private readonly _result: Result<ReadonlyArray<IScopedMemoryRecord>>;
+  public constructor(result: Result<ReadonlyArray<IScopedMemoryRecord>>) {
     this._result = result;
   }
-  public list(): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>> {
+  public list(): Promise<Result<ReadonlyArray<IScopedMemoryRecord>>> {
     return Promise.resolve(this._result);
   }
 }
 
 describe('InMemoryCosineIndex', () => {
   describe('add', () => {
-    test('returns the id as the embedding ref and tracks size', async () => {
+    test('returns the scoped-target key as the embedding ref and tracks size', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
       expect(index.size).toBe(0);
-      expect(await index.add('a' as MemoryId, Float32Array.from([1, 0]))).toSucceedWith('a');
+      const t = target('conv-a', 'turn-1');
+      expect(await index.add(t, Float32Array.from([1, 0]))).toSucceedWith(`conv-a\0turn-1`);
       expect(index.size).toBe(1);
     });
 
-    test('replaces the vector on a same-id add', async () => {
+    test('replaces the vector on a same-target add', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      expect(await index.add('a' as MemoryId, Float32Array.from([1, 0]))).toSucceed();
-      expect(await index.add('a' as MemoryId, Float32Array.from([0, 1]))).toSucceed();
+      const t = target('conv-a', 'turn-1');
+      expect(await index.add(t, Float32Array.from([1, 0]))).toSucceed();
+      expect(await index.add(t, Float32Array.from([0, 1]))).toSucceed();
       expect(index.size).toBe(1);
       // The query now matches the replacement vector ([0,1]) not the original.
       expect(await index.query(Float32Array.from([0, 1]), 1)).toSucceedAndSatisfy(
@@ -55,15 +70,37 @@ describe('InMemoryCosineIndex', () => {
       );
     });
 
+    test('same stem in different scopes are distinct entries — the second add does NOT clobber the first', async () => {
+      const index = InMemoryCosineIndex.create().orThrow();
+      const a = target('conv-a', 'turn-3');
+      const b = target('conv-b', 'turn-3');
+      // Two records with the identical stem, orthogonal embeddings.
+      expect(await index.add(a, Float32Array.from([1, 0]))).toSucceed();
+      expect(await index.add(b, Float32Array.from([0, 1]))).toSucceed();
+      // The bug: a bare-id index would have collapsed these to one entry.
+      expect(index.size).toBe(2);
+      // A query surfaces BOTH as distinct hits carrying distinct scoped targets.
+      expect(await index.query(Float32Array.from([1, 1]), 5)).toSucceedAndSatisfy(
+        (hits: ReadonlyArray<IVectorQueryHit>) => {
+          expect(hits).toHaveLength(2);
+          expect(hits.map((h) => h.target)).toEqual(expect.arrayContaining([a, b]));
+          // Each retains its OWN embedding: a matches [1,0], b matches [0,1].
+          const byScope = new Map(hits.map((h) => [h.target.scope, h.score]));
+          expect(byScope.get('conv-a' as MemoryScopeKey)).toBeCloseTo(1 / Math.sqrt(2));
+          expect(byScope.get('conv-b' as MemoryScopeKey)).toBeCloseTo(1 / Math.sqrt(2));
+        }
+      );
+    });
+
     test('fails loudly on an empty vector', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      expect(await index.add('a' as MemoryId, new Float32Array(0))).toFailWith(/empty vector/i);
+      expect(await index.add(target('conv-a', 'turn-1'), new Float32Array(0))).toFailWith(/empty vector/i);
     });
 
     test('stores a defensive copy — mutating the caller buffer after add does not corrupt the index', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
       const buffer = Float32Array.from([1, 0]);
-      (await index.add('a' as MemoryId, buffer)).orThrow();
+      (await index.add(target('conv-a', 'turn-1'), buffer)).orThrow();
       // Mutate the caller's buffer after the add; the stored vector must be unaffected.
       buffer[0] = 0;
       buffer[1] = 1;
@@ -77,8 +114,8 @@ describe('InMemoryCosineIndex', () => {
 
     test('fails loudly on a dimension mismatch against the established dimension', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      expect(await index.add('a' as MemoryId, Float32Array.from([1, 0]))).toSucceed();
-      expect(await index.add('b' as MemoryId, Float32Array.from([1, 0, 0]))).toFailWith(
+      expect(await index.add(target('conv-a', 'a'), Float32Array.from([1, 0]))).toSucceed();
+      expect(await index.add(target('conv-a', 'b'), Float32Array.from([1, 0, 0]))).toFailWith(
         /dimension 3 does not match index dimension 2/i
       );
     });
@@ -87,9 +124,9 @@ describe('InMemoryCosineIndex', () => {
   describe('query', () => {
     async function seeded(): Promise<InMemoryCosineIndex> {
       const index = InMemoryCosineIndex.create().orThrow();
-      (await index.add('a' as MemoryId, Float32Array.from([1, 0]))).orThrow();
-      (await index.add('b' as MemoryId, Float32Array.from([0, 1]))).orThrow();
-      (await index.add('c' as MemoryId, Float32Array.from([1, 1]))).orThrow();
+      (await index.add(target('s', 'a'), Float32Array.from([1, 0]))).orThrow();
+      (await index.add(target('s', 'b'), Float32Array.from([0, 1]))).orThrow();
+      (await index.add(target('s', 'c'), Float32Array.from([1, 1]))).orThrow();
       return index;
     }
 
@@ -97,7 +134,7 @@ describe('InMemoryCosineIndex', () => {
       const index = await seeded();
       expect(await index.query(Float32Array.from([1, 0]), 3)).toSucceedAndSatisfy(
         (hits: ReadonlyArray<IVectorQueryHit>) => {
-          expect(hits.map((h) => h.id)).toEqual(['a', 'c', 'b']);
+          expect(hits.map((h) => h.target.id)).toEqual(['a', 'c', 'b']);
           expect(hits[0].score).toBeCloseTo(1);
           expect(hits[1].score).toBeCloseTo(1 / Math.sqrt(2));
           expect(hits[2].score).toBeCloseTo(0);
@@ -109,7 +146,7 @@ describe('InMemoryCosineIndex', () => {
       const index = await seeded();
       expect(await index.query(Float32Array.from([1, 0]), 2)).toSucceedAndSatisfy(
         (hits: ReadonlyArray<IVectorQueryHit>) => {
-          expect(hits.map((h) => h.id)).toEqual(['a', 'c']);
+          expect(hits.map((h) => h.target.id)).toEqual(['a', 'c']);
         }
       );
     });
@@ -134,11 +171,11 @@ describe('InMemoryCosineIndex', () => {
 
     test('scores a degenerate (zero-magnitude) stored vector as 0 rather than NaN', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      (await index.add('zero' as MemoryId, Float32Array.from([0, 0]))).orThrow();
-      (await index.add('unit' as MemoryId, Float32Array.from([1, 0]))).orThrow();
+      (await index.add(target('s', 'zero'), Float32Array.from([0, 0]))).orThrow();
+      (await index.add(target('s', 'unit'), Float32Array.from([1, 0]))).orThrow();
       expect(await index.query(Float32Array.from([1, 0]), 2)).toSucceedAndSatisfy(
         (hits: ReadonlyArray<IVectorQueryHit>) => {
-          expect(hits.map((h) => h.id)).toEqual(['unit', 'zero']);
+          expect(hits.map((h) => h.target.id)).toEqual(['unit', 'zero']);
           expect(hits[1].score).toBe(0);
         }
       );
@@ -146,7 +183,7 @@ describe('InMemoryCosineIndex', () => {
 
     test('scores against a degenerate (zero-magnitude) query as 0 rather than NaN', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      (await index.add('unit' as MemoryId, Float32Array.from([1, 0]))).orThrow();
+      (await index.add(target('s', 'unit'), Float32Array.from([1, 0]))).orThrow();
       expect(await index.query(Float32Array.from([0, 0]), 1)).toSucceedAndSatisfy(
         (hits: ReadonlyArray<IVectorQueryHit>) => {
           expect(hits[0].score).toBe(0);
@@ -158,20 +195,41 @@ describe('InMemoryCosineIndex', () => {
   describe('remove', () => {
     test('removes a vector and is reflected in subsequent queries', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      (await index.add('a' as MemoryId, Float32Array.from([1, 0]))).orThrow();
-      (await index.add('b' as MemoryId, Float32Array.from([0, 1]))).orThrow();
-      expect(await index.remove('a' as MemoryId)).toSucceedWith('a' as MemoryId);
+      const a = target('s', 'a');
+      const b = target('s', 'b');
+      (await index.add(a, Float32Array.from([1, 0]))).orThrow();
+      (await index.add(b, Float32Array.from([0, 1]))).orThrow();
+      expect(await index.remove(a)).toSucceedWith(a);
       expect(index.size).toBe(1);
       expect(await index.query(Float32Array.from([1, 0]), 5)).toSucceedAndSatisfy(
         (hits: ReadonlyArray<IVectorQueryHit>) => {
-          expect(hits.map((h) => h.id)).toEqual(['b']);
+          expect(hits.map((h) => h.target.id)).toEqual(['b']);
         }
       );
     });
 
-    test('is idempotent — removing an absent id still succeeds', async () => {
+    test('removes only the scoped target — a same-stem record in another scope is left intact', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      expect(await index.remove('missing' as MemoryId)).toSucceedWith('missing' as MemoryId);
+      const a = target('conv-a', 'turn-3');
+      const b = target('conv-b', 'turn-3');
+      (await index.add(a, Float32Array.from([1, 0]))).orThrow();
+      (await index.add(b, Float32Array.from([0, 1]))).orThrow();
+      expect(await index.remove(a)).toSucceedWith(a);
+      expect(index.size).toBe(1);
+      // conv-b's embedding survives untouched.
+      expect(await index.query(Float32Array.from([0, 1]), 5)).toSucceedAndSatisfy(
+        (hits: ReadonlyArray<IVectorQueryHit>) => {
+          expect(hits).toHaveLength(1);
+          expect(hits[0].target).toEqual(b);
+          expect(hits[0].score).toBeCloseTo(1);
+        }
+      );
+    });
+
+    test('is idempotent — removing an absent target still succeeds', async () => {
+      const index = InMemoryCosineIndex.create().orThrow();
+      const t = target('s', 'missing');
+      expect(await index.remove(t)).toSucceedWith(t);
     });
   });
 
@@ -182,15 +240,30 @@ describe('InMemoryCosineIndex', () => {
       return Promise.resolve(succeed(Float32Array.from([code, 1])));
     };
 
-    test('re-embeds every record from the source and reports the count', async () => {
+    test('re-embeds every scoped record from the source and reports the count', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      const source = new FakeSource(succeed([record('a'), record('b'), record('c')]));
+      const source = new FakeSource(succeed([scoped('s', 'a'), scoped('s', 'b'), scoped('s', 'c')]));
       expect(await index.rebuild(source, embed)).toSucceedWith(3);
       expect(index.size).toBe(3);
       expect(await index.query(Float32Array.from([99, 1]), 1)).toSucceedAndSatisfy(
         (hits: ReadonlyArray<IVectorQueryHit>) => {
           // 'c' = char code 99, the closest to the query vector.
-          expect(hits[0].id).toBe('c');
+          expect(hits[0].target.id).toBe('c');
+        }
+      );
+    });
+
+    test('keeps same-stem records under different scopes distinct across a rebuild', async () => {
+      const index = InMemoryCosineIndex.create().orThrow();
+      const source = new FakeSource(succeed([scoped('conv-a', 'turn-3'), scoped('conv-b', 'turn-3')]));
+      // The embedder keys only off the (shared) id, so a bare-id rebuild would
+      // index just one entry; the scoped rebuild indexes both.
+      expect(await index.rebuild(source, embed)).toSucceedWith(2);
+      expect(index.size).toBe(2);
+      expect(await index.query(Float32Array.from([116, 1]), 5)).toSucceedAndSatisfy(
+        (hits: ReadonlyArray<IVectorQueryHit>) => {
+          expect(hits).toHaveLength(2);
+          expect(hits.map((h) => h.target.scope).sort()).toEqual(['conv-a', 'conv-b']);
         }
       );
     });
@@ -198,8 +271,8 @@ describe('InMemoryCosineIndex', () => {
     test('clears prior contents and re-establishes the dimension', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
       // Seed a 3-dim vector, then rebuild with a 2-dim embedder.
-      (await index.add('old' as MemoryId, Float32Array.from([1, 2, 3]))).orThrow();
-      const source = new FakeSource(succeed([record('a')]));
+      (await index.add(target('s', 'old'), Float32Array.from([1, 2, 3]))).orThrow();
+      const source = new FakeSource(succeed([scoped('s', 'a')]));
       expect(await index.rebuild(source, embed)).toSucceedWith(1);
       expect(index.size).toBe(1);
       // The 2-dim query now succeeds (dimension was reset by rebuild).
@@ -209,7 +282,7 @@ describe('InMemoryCosineIndex', () => {
     test('fails loudly when the source list fails', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
       // Seed an entry so the reset-before-list rollback is observable, not just "stayed empty".
-      (await index.add('seed' as MemoryId, Float32Array.from([1, 1]))).orThrow();
+      (await index.add(target('s', 'seed'), Float32Array.from([1, 1]))).orThrow();
       const source = new FakeSource(fail('disk gone'));
       expect(await index.rebuild(source, embed)).toFailWith(/failed to list records: disk gone/i);
       expect(index.size).toBe(0);
@@ -218,22 +291,25 @@ describe('InMemoryCosineIndex', () => {
     test('fails loudly and rolls back to empty when an embedding fails mid-rebuild', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
       // Seed an existing entry so the rollback (not merely "stayed empty") is observable.
-      (await index.add('seed' as MemoryId, Float32Array.from([1, 1]))).orThrow();
+      (await index.add(target('s', 'seed'), Float32Array.from([1, 1]))).orThrow();
       // First record embeds fine, the second fails — so a naive impl would leave
       // record 'a' indexed; the rollback must clear it.
       let calls: number = 0;
-      const flakyEmbed = (r: IMemoryRecord<unknown>): Promise<Result<Float32Array>> => {
+      const flakyEmbed = (): Promise<Result<Float32Array>> => {
         calls += 1;
         return Promise.resolve(calls === 1 ? succeed(Float32Array.from([1, 1])) : fail('no model'));
       };
-      const source = new FakeSource(succeed([record('a'), record('b')]));
-      expect(await index.rebuild(source, flakyEmbed)).toFailWith(/embedding 'b' failed: no model/i);
+      const source = new FakeSource(succeed([scoped('conv-a', 'turn-1'), scoped('conv-b', 'turn-1')]));
+      // The failing record's error names its scope-qualified key.
+      expect(await index.rebuild(source, flakyEmbed)).toFailWith(
+        /embedding 'conv-b\0turn-1' failed: no model/i
+      );
       expect(index.size).toBe(0);
     });
 
     test('fails loudly and rolls back to empty when adding an embedded vector fails', async () => {
       const index = InMemoryCosineIndex.create().orThrow();
-      const source = new FakeSource(succeed([record('a')]));
+      const source = new FakeSource(succeed([scoped('s', 'a')]));
       const emptyEmbed = (): Promise<Result<Float32Array>> => Promise.resolve(succeed(new Float32Array(0)));
       expect(await index.rebuild(source, emptyEmbed)).toFailWith(/empty vector/i);
       expect(index.size).toBe(0);

package/src/test/unit/vector/vectorIndex.test.ts

@@ -5,44 +5,60 @@
 
 import '@fgv/ts-utils-jest';
 import { Result, succeed } from '@fgv/ts-utils';
-import { IVectorIndex, IVectorQueryHit, MemoryId } from '../../../index';
+import {
+  IEdgeTarget,
+  IVectorIndex,
+  IVectorQueryHit,
+  MemoryId,
+  MemoryScopeKey,
+  edgeTargetKey
+} from '../../../index';
+
+function target(scope: string, id: string): IEdgeTarget {
+  return { scope: scope as MemoryScopeKey, id: id as MemoryId };
+}
 
 /**
  * A trivial conforming implementation, present to verify the {@link IVectorIndex}
- * seam is usable end-to-end (the in-package cosine impl is a post-v1 fast-follow).
+ * seam is usable end-to-end with scope-qualified targets.
  */
 class StubVectorIndex implements IVectorIndex {
-  private readonly _vectors: Map<MemoryId, Float32Array> = new Map();
+  private readonly _vectors: Map<string, IEdgeTarget> = new Map();
 
-  public add(id: MemoryId, vector: Float32Array): Promise<Result<string>> {
-    this._vectors.set(id, vector);
-    return Promise.resolve(succeed(`ref-${id}`));
+  public add(t: IEdgeTarget, vector: Float32Array): Promise<Result<string>> {
+    const key: string = edgeTargetKey(t);
+    this._vectors.set(key, t);
+    return Promise.resolve(succeed(`ref-${key}`));
   }
 
-  public remove(id: MemoryId): Promise<Result<MemoryId>> {
-    this._vectors.delete(id);
-    return Promise.resolve(succeed(id));
+  public remove(t: IEdgeTarget): Promise<Result<IEdgeTarget>> {
+    this._vectors.delete(edgeTargetKey(t));
+    return Promise.resolve(succeed(t));
   }
 
   public query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>> {
-    const hits: IVectorQueryHit[] = Array.from(this._vectors.keys())
-      .map((id) => ({ id, score: vector.length }))
+    const hits: IVectorQueryHit[] = Array.from(this._vectors.values())
+      .map((t) => ({ target: t, score: vector.length }))
       .slice(0, topK);
     return Promise.resolve(succeed(hits));
   }
 }
 
 describe('IVectorIndex seam', () => {
-  test('a conforming implementation supports add / query / remove', async () => {
+  test('a conforming implementation supports add / query / remove on scoped targets', async () => {
     const index = new StubVectorIndex();
-    expect(await index.add('a' as MemoryId, Float32Array.from([1, 2, 3]))).toSucceedWith('ref-a');
-    expect(await index.add('b' as MemoryId, Float32Array.from([4, 5, 6]))).toSucceedWith('ref-b');
-    expect(await index.query(Float32Array.from([0.1, 0.2]), 1)).toSucceedAndSatisfy(
+    const a = target('conv-a', 'turn-3');
+    const b = target('conv-b', 'turn-3');
+    expect(await index.add(a, Float32Array.from([1, 2, 3]))).toSucceedWith(`ref-${edgeTargetKey(a)}`);
+    expect(await index.add(b, Float32Array.from([4, 5, 6]))).toSucceedWith(`ref-${edgeTargetKey(b)}`);
+    expect(await index.query(Float32Array.from([0.1, 0.2]), 2)).toSucceedAndSatisfy(
       (hits: ReadonlyArray<IVectorQueryHit>) => {
-        expect(hits).toHaveLength(1);
+        // Both same-stem-different-scope targets are distinct entries.
+        expect(hits).toHaveLength(2);
+        expect(hits.map((h) => h.target)).toEqual(expect.arrayContaining([a, b]));
         expect(hits[0].score).toBe(2);
       }
     );
-    expect(await index.remove('a' as MemoryId)).toSucceedWith('a' as MemoryId);
+    expect(await index.remove(a)).toSucceedWith(a);
   });
 });

package/temp/build/lint/_eslint-5eVG3S6w.json

@@ -11,7 +11,7 @@
     ],
     [
       "packlets/types/envelope.ts",
-      "6b2ca3800b4abe70537b4ee72d24e5a391209dd692e7eaaaa84ed4bcfedd1e69_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "b577527722f9fbcf55aae9ab5c3dd58ec06e43567c327626a91aa7b8536f2876_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/types/identityCodec.ts",
@@ -35,7 +35,7 @@
     ],
     [
       "packlets/converters/envelopeConverter.ts",
-      "a39cb2d72541fb757ec2d6eff49d346b2ba1117509b520b476db55f58cb97b02_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "7904ff7ab8e4eb5a3a51bafc7ac540ae8e754441e3b8c31bfdf8cb11f51a7ae5_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/converters/index.ts",
@@ -43,7 +43,7 @@
     ],
     [
       "packlets/index/memoryIndex.ts",
-      "1fb0c0ebfc5d9df50f352a3509417e2a5fe56ac73651fbc8e85d61c6c495b170_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "66f10dda4070267a4d4fa00fd8907caa6c60a221fa3e487a4b2bd9a677e8a301_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/index/index.ts",
@@ -63,11 +63,11 @@
     ],
     [
       "packlets/vector/vectorIndex.ts",
-      "88b2f13d5e4bab4bec20fc37b04665a8fe238acc673aaa597f96c76fa6de6fc8_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "80f85adb4c3207cdb63231d5effe72b8004803399d2c438ca47f00b66d7f02ca_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/vector/inMemoryCosineIndex.ts",
-      "b4702bbe7d33bf72737f32a83454dc17ab0a52bd6b9f3f2c9eb32dd9f2462d72_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "a38638516326b44f98e6bd65e2bd1a9cd515d5ffbe3acbecfb9e255a8d22dbc9_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/vector/index.ts",
@@ -79,7 +79,7 @@
     ],
     [
       "packlets/store/fileTreeMemoryStore.ts",
-      "75746b65d0cde19462c3f6809a59fd60985864bf5fa1a66c7a59795115b49b8b_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "749eeff65789b45015b19993c41ff79fa124f314d34b3a9dd6f63edd77059e4c_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/store/index.ts",
@@ -87,35 +87,35 @@
     ],
     [
       "packlets/retrieve/retriever.ts",
-      "68efaa8d1690fbb0d372e72128443aba31de4192bf2a822c232e931b95f89990_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "f8bf85cf7e3fe260eebd79f87e1429acbea25d6dc53af31c8d16c76032afb199_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/recencyRetriever.ts",
-      "730ec08c1c3b66909d5405319e3f1e5f525b24b4497f50858aa1652e103aa88c_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "3feaaf34e69c0b507af7bf3a6a63d475013b57bed2d749a8aa03d5c8ed595fbb_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/linkTraversalRetriever.ts",
-      "ee874393402426e67b7cf3596fa82cdb3ec2fe1e37c3f9730d40334851eb3610_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "5a99e5cd1f5cbf3d1984bee2d08614f33801c24e8c3d3e9f501fe949f1c631f8_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/tagRetriever.ts",
-      "11518f70b70b25c353c8eec337753648c53f80ad5b7c5d00031209c8d77f9174_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "405161979ed404331933acef3c131ec1ae177d052037336ef62851a09b328865_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/structuredFilterRetriever.ts",
-      "519bbdc0c54349a3a4fd4c87f07fe7431cf01e0844fe8b4210a0a6195ce08a79_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "c1286d14929b84afddeaf6e03a6b19b466363ef2fd901df98a241b4415857311_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/semanticRetriever.ts",
-      "30b52f854d7ccf395e03278e3889f7512ea825a489d31966736cef9a143bf991_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "f272c8908bc0ad788d215443bd693edac99ccac8c108f03c44b6a01d7211cdaf_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/temporalRetrievers.ts",
-      "0131f13f335eca903bd94e2e8c793ca7af52e0cf60d63d83a6c12365ea530472_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "a46e192e8e1c697184c125f6869aa841ec28acfb6351416e901689a15c032ae2_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/hybridRetriever.ts",
-      "a3a6deccf2f8fff2a1863b31835780d8b1fa2a85af5db6639c38b2a5bc34a806_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "f8f855df0a352d6c938fd787a46cce299b3cadb47766966de053aa5def982551_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/index.ts",
@@ -123,7 +123,7 @@
     ],
     [
       "packlets/tools/memoryTools.ts",
-      "5593b178cee4f05bae54292130f5bc0bbb6858d7b10e5a4602ebbc22e29b8cbc_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "8dce5a256b1b33e342dee762a4b2ac2c08285d1faaafb1b3bd37105379a4f9da_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/tools/index.ts",
@@ -131,19 +131,19 @@
     ],
     [
       "packlets/ingest/model.ts",
-      "666b14530d8ffcd51cd1d13ad46d1616c87f75e4ce28fd0db8ebacc434714cfe_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "56eba4b5ec0a705af8df262b18955cce35acd8cf84cd81820edc7fcb80f4269b_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/ingest/hostStages.ts",
-      "2b848556ea7d94a9f9247a6780428585e56e5d281364e16ff9cefad465ff05e1_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "77545a186e3b50a34f7196e366e29c3215de787dec48420b80ae313a836de67b_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/ingest/cycleGuard.ts",
-      "c2c969319313740b5a861ffede25512e843cdc4a62d2ed81d6ada3bfea3c6bcf_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "bdb6bc770953cf562f68c4920c01524ac18b9f02766598bca443fc2c6d479ba6_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/ingest/orchestrator.ts",
-      "f821fe8bc363157124a991a4dff62a2c96c1fefe14db54993147a00f5b522e8b_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "c22f7ca57bbb5945fd82e0f1d85b34e6dc227b1d8d4bbd0bf2aa554eb99c948a_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/ingest/index.ts",
@@ -155,7 +155,7 @@
     ],
     [
       "test/unit/converters/antagonistRoundTrip.test.ts",
-      "716259d8068e73fd8444a306835881f9cff709e043dde61578bb2a061decdfb7_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "c797f3e6e3718d9d91dd407d14d1c229dbd847cc8c4940c9313d1ed1f6c39533_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/converters/bodyConverterRegistry.test.ts",
@@ -163,23 +163,23 @@
     ],
     [
       "test/unit/converters/envelopeConverter.test.ts",
-      "c9bb42bfaa1008e41eb5253a7705b757f6b44de4f7a66fbe9e2a1e932cc2ce92_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "e7b53bb59b48fee358e6a288dd3df326ee5f8b3116559f55d57b3112bd008517_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/index/memoryIndex.test.ts",
-      "a9f1894d8e8ab4430709fcd6addb003ecd6ff98baebf855ace88f39427e30593_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "0046e5ae00cbbf8f8163911a30f62603c8f93cafd47aceb44c2f4adf6b65ce10_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/ingest/antagonistCycleAndParity.test.ts",
-      "af7b769809b92543b0a9cd32ddcb1de8bcb4db102d7997b71be7a84d9b1fbb09_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "cc97c550aea40ba89678400d6a1274aaaf224eddb847d2a941b0f8346417f1a8_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/ingest/cycleGuard.test.ts",
-      "ffb8024c01a769482c7abcc057c2e4ad798ffc50f010081a9283f1cf1209d56e_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "f0096fa558b1ab01e2b291b826dc413086a83530e033828133e2e231f055d14c_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/ingest/orchestrator.test.ts",
-      "945eb0d45fa417bcb4a88eb7bfb5ee8b51fbd16099925b9dc1888c69fc02d236_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "8b1b204058d334502fd296c073b885d6c4dca00cd7902d41dc9e1139d1d63d00_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/observe/memoryObservationStore.test.ts",
@@ -187,11 +187,11 @@
     ],
     [
       "test/unit/retrieve/linkTraversalRetriever.test.ts",
-      "a9e88d9d4ebb8a69bad645c0f774b43668e02cfd10b79680200b5a91374264b7_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "18ea5e3a48853535bf102fa514049c15b1dbc87bc28dc7f09832b3f4cbd22e24_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/retrieve/retrievers.test.ts",
-      "e4a7ba604ec7c481d2a491358d1c42d9e1eecdb77fa3e3a804c10fe72e5506df_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "e22843463cb9f624506487522d6e6d8a6f17ad42b3a2c9ca9215c20ae6a168ba_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/retrieve/temporalRetrievers.test.ts",
@@ -203,16 +203,24 @@
     ],
     [
       "test/unit/store/embedOnWrite.test.ts",
-      "9bdab98d1e0cb73f16a5d18daf0bd7e4da02db28d05e82424d1c42e9fc0b2c45_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "3d23876462a4eeaa8679f1f3ed9700e380a63a37dd8ded7499b7097adc39a77f_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/store/fileTreeMemoryStore.test.ts",
       "06407be1a2dc1b914cecefe63766ea4a597c132cc04e87d8b2a373d582be435f_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
+    [
+      "test/unit/store/listScoped.test.ts",
+      "fca2cf52018d3b5fef0c9c0b438242b557fffa91526055b489942b23a4457e87_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
     [
       "test/unit/store/observations.test.ts",
       "538814a51e9a09b566e24e98824ed281562becf4d8f56d5ec88aa33f6c6b0e2f_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
+    [
+      "test/unit/store/rankAxis.test.ts",
+      "cf19c29a28f1ad6475a49bc0b3dc6decdeb3a7804887540e6e9e0d49a525860d_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
     [
       "test/unit/store/scopeEncoding.test.ts",
       "5ea0364489c7424bbfcae0b85f71a49aa069202e307282f808ea54449a927c3b_fnTnCS8rja7DE6jB0bKRna1pZAg="
@@ -223,7 +231,7 @@
     ],
     [
       "test/unit/tools/memoryTools.test.ts",
-      "ed1b29228843e28ce103a46705426eb63b5e8b4d0f76e66c63747b259c2cd8f0_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "87cca3dccfa48aa9c74c3c0fa39980e5d745997337e869e38291ff5d5a6a230a_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/types/identityCodec.test.ts",
@@ -243,16 +251,16 @@
     ],
     [
       "test/unit/types/writePolicy.test.ts",
-      "b1dce7dcab42c012d504d2d108626e62ce024463654f118b5bb78adb2faa7dac_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "f36d20bf300ab0ebe8921e5125be6dcfd1fd1a39d51bff1e7f301f1c60661c98_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/vector/inMemoryCosineIndex.test.ts",
-      "5ff0eb2d7ae3e24505f4ca337caaf4706c4345dad283a8faa51105465161f259_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "4433925d1ffd368928b8b09be5d58d26cbc9d805413572b492dc1d82c6a32ca8_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/vector/vectorIndex.test.ts",
-      "fb1b4366bcd6b06174b82a3604cd6ee09692cb89a6c38b90866281ba204efc90_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "ee46f9a64127b829fea5ce21e63481d2ad757cfc9d04b389bd27e146b6a0c136_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ]
   ],
-  "filesHash": "41qqBVkA2UlzsTYEJ5_czQ"
+  "filesHash": "PAS6a5eG6VsawhuG7UzMAQ"
 }