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

package/src/test/unit/types/identityCodec.test.ts

@@ -1,266 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import '@fgv/ts-utils-jest';
-import {
-  Convert,
-  EntityId,
-  KnowledgeIdentityCodec,
-  LtmIdentityCodec,
-  MemoryScopeKey,
-  MtmIdentityCodec,
-  assertPortableFilenameStem
-} from '../../../packlets/types';
-
-describe('assertPortableFilenameStem', () => {
-  test('accepts a POSIX portable filename stem', () => {
-    expect(assertPortableFilenameStem('intro-to-rust.v2')).toSucceedWith('intro-to-rust.v2');
-  });
-
-  test('rejects an empty stem', () => {
-    expect(assertPortableFilenameStem('')).toFailWith(/must be a non-empty string/i);
-  });
-
-  test('rejects a leading dot', () => {
-    expect(assertPortableFilenameStem('.hidden')).toFailWith(/may not begin with '\.'/i);
-  });
-
-  test('rejects a trailing dot (Windows strips trailing dots)', () => {
-    expect(assertPortableFilenameStem('topic.')).toFailWith(/may not end with '\.'/i);
-  });
-
-  test('rejects characters outside the portable set', () => {
-    expect(assertPortableFilenameStem('has/slash')).toFailWith(/POSIX portable filename set/i);
-    expect(assertPortableFilenameStem('has space')).toFailWith(/POSIX portable filename set/i);
-  });
-
-  test('rejects a reserved Windows device basename (case-insensitive, with extension)', () => {
-    expect(assertPortableFilenameStem('CON')).toFailWith(/reserved Windows device name/i);
-    expect(assertPortableFilenameStem('con.md')).toFailWith(/reserved Windows device name/i);
-    expect(assertPortableFilenameStem('COM1')).toFailWith(/reserved Windows device name/i);
-    expect(assertPortableFilenameStem('lpt0.txt')).toFailWith(/reserved Windows device name/i);
-  });
-
-  test('rejects the 0-suffixed device variants (Windows 11 / Server 2022)', () => {
-    expect(assertPortableFilenameStem('COM0')).toFailWith(/reserved Windows device name/i);
-    expect(assertPortableFilenameStem('LPT0')).toFailWith(/reserved Windows device name/i);
-    expect(assertPortableFilenameStem('COM9')).toFailWith(/reserved Windows device name/i);
-  });
-});
-
-describe('KnowledgeIdentityCodec', () => {
-  const codec: KnowledgeIdentityCodec = new KnowledgeIdentityCodec();
-  const knowledgeScope: MemoryScopeKey = KnowledgeIdentityCodec.scope;
-
-  describe('encode', () => {
-    test('maps a docId to the flat knowledge scope, passthrough stem, non-versioned', () => {
-      expect(codec.encode('intro-to-rust' as EntityId)).toSucceedWith({
-        scope: knowledgeScope,
-        idStem: 'intro-to-rust',
-        isVersioned: false
-      });
-    });
-
-    test('fails when the docId is not filename-safe', () => {
-      expect(codec.encode('bad/id' as EntityId)).toFailWith(/POSIX portable filename set/i);
-    });
-  });
-
-  describe('decode', () => {
-    test('recovers the EntityId from a valid address', () => {
-      expect(codec.decode(knowledgeScope, 'intro-to-rust')).toSucceedWith('intro-to-rust' as EntityId);
-    });
-
-    test('fails when the scope is not the knowledge scope', () => {
-      expect(codec.decode('conversations' as MemoryScopeKey, 'intro-to-rust')).toFailWith(
-        /does not match expected scope 'knowledge'/i
-      );
-    });
-
-    test('fails when the stem is not filename-safe', () => {
-      expect(codec.decode(knowledgeScope, 'bad stem')).toFailWith(/POSIX portable filename set/i);
-    });
-  });
-
-  describe('verifyRoundTrip', () => {
-    test('succeeds for a stem that decodes and re-encodes cleanly', () => {
-      expect(codec.verifyRoundTrip(knowledgeScope, 'intro-to-rust')).toSucceedWith(true);
-    });
-
-    test('fails when the stem cannot be decoded', () => {
-      expect(codec.verifyRoundTrip(knowledgeScope, 'bad stem')).toFailWith(/POSIX portable filename set/i);
-    });
-
-    test('fails when the scope does not match', () => {
-      expect(codec.verifyRoundTrip('conversations' as MemoryScopeKey, 'intro-to-rust')).toFailWith(
-        /does not match expected scope/i
-      );
-    });
-  });
-
-  test('the fixed knowledge scope is a valid MemoryScopeKey', () => {
-    expect(Convert.scopeKey.convert(KnowledgeIdentityCodec.scope)).toSucceedWith(knowledgeScope as never);
-  });
-});
-
-describe('LtmIdentityCodec', () => {
-  const codec: LtmIdentityCodec = new LtmIdentityCodec();
-  const conversationsScope: MemoryScopeKey = LtmIdentityCodec.scope;
-
-  describe('encode', () => {
-    test('maps a conversationId to the flat conversations scope, passthrough stem, non-versioned', () => {
-      expect(codec.encode('conv-42' as EntityId)).toSucceedWith({
-        scope: conversationsScope,
-        idStem: 'conv-42',
-        isVersioned: false
-      });
-    });
-
-    test('fails when the conversationId is not filename-safe', () => {
-      expect(codec.encode('conv/42' as EntityId)).toFailWith(/POSIX portable filename set/i);
-    });
-  });
-
-  describe('decode', () => {
-    test('recovers the EntityId from a valid address', () => {
-      expect(codec.decode(conversationsScope, 'conv-42')).toSucceedWith('conv-42' as EntityId);
-    });
-
-    test('fails when the scope is not the conversations scope', () => {
-      expect(codec.decode('knowledge' as MemoryScopeKey, 'conv-42')).toFailWith(
-        /does not match expected scope 'conversations'/i
-      );
-    });
-
-    test('fails when the stem is not filename-safe', () => {
-      expect(codec.decode(conversationsScope, 'bad stem')).toFailWith(/POSIX portable filename set/i);
-    });
-  });
-
-  describe('verifyRoundTrip', () => {
-    test('succeeds for a stem that decodes and re-encodes cleanly', () => {
-      expect(codec.verifyRoundTrip(conversationsScope, 'conv-42')).toSucceedWith(true);
-    });
-
-    test('fails when the scope does not match', () => {
-      expect(codec.verifyRoundTrip('knowledge' as MemoryScopeKey, 'conv-42')).toFailWith(
-        /does not match expected scope/i
-      );
-    });
-  });
-
-  test('the fixed conversations scope is a valid MemoryScopeKey', () => {
-    expect(Convert.scopeKey.convert(LtmIdentityCodec.scope)).toSucceedWith(conversationsScope as never);
-  });
-});
-
-describe('MtmIdentityCodec', () => {
-  const codec: MtmIdentityCodec = new MtmIdentityCodec();
-
-  describe('encode', () => {
-    test('maps a <conversationId>:<turnIndex> composite to a per-conversation subtree', () => {
-      expect(codec.encode('conv-1:5' as EntityId)).toSucceedWith({
-        scope: 'conversations/conv-1' as MemoryScopeKey,
-        idStem: 'turn-5',
-        isVersioned: false
-      });
-    });
-
-    test('preserves the turn index verbatim (turn 0)', () => {
-      expect(codec.encode('conv-1:0' as EntityId)).toSucceedWith({
-        scope: 'conversations/conv-1' as MemoryScopeKey,
-        idStem: 'turn-0',
-        isVersioned: false
-      });
-    });
-
-    test('fails when the entity id is not a colon composite', () => {
-      expect(codec.encode('conv-1' as EntityId)).toFailWith(/must be a '<conversationId>:<turnIndex>'/i);
-    });
-
-    test('fails when the entity id has more than two segments', () => {
-      expect(codec.encode('conv-1:5:extra' as EntityId)).toFailWith(
-        /must be a '<conversationId>:<turnIndex>'/i
-      );
-    });
-
-    test('fails when the conversationId is not filename-safe', () => {
-      expect(codec.encode('bad id:5' as EntityId)).toFailWith(/conversationId.*POSIX portable filename set/i);
-    });
-
-    test('fails when the turn index is not a non-negative integer', () => {
-      expect(codec.encode('conv-1:x' as EntityId)).toFailWith(
-        /turnIndex 'x' must be a non-negative integer/i
-      );
-      expect(codec.encode('conv-1:-1' as EntityId)).toFailWith(/must be a non-negative integer/i);
-      expect(codec.encode('conv-1:1.5' as EntityId)).toFailWith(/must be a non-negative integer/i);
-    });
-  });
-
-  describe('decode', () => {
-    test('reverses the scope + stem to the composite entity id', () => {
-      expect(codec.decode('conversations/conv-1' as MemoryScopeKey, 'turn-5')).toSucceedWith(
-        'conv-1:5' as EntityId
-      );
-    });
-
-    test('fails when the scope is a single segment', () => {
-      expect(codec.decode('conversations' as MemoryScopeKey, 'turn-5')).toFailWith(
-        /must be 'conversations\/<conversationId>'/i
-      );
-    });
-
-    test('fails when the scope root segment is wrong', () => {
-      expect(codec.decode('knowledge/conv-1' as MemoryScopeKey, 'turn-5')).toFailWith(
-        /must be 'conversations\/<conversationId>'/i
-      );
-    });
-
-    test('fails when the scope has too many segments', () => {
-      expect(codec.decode('conversations/conv-1/extra' as MemoryScopeKey, 'turn-5')).toFailWith(
-        /must be 'conversations\/<conversationId>'/i
-      );
-    });
-
-    test('fails when the conversationId in the scope is not filename-safe', () => {
-      expect(codec.decode('conversations/bad id' as MemoryScopeKey, 'turn-5')).toFailWith(
-        /conversationId.*POSIX portable filename set/i
-      );
-    });
-
-    test('fails when the stem does not have the turn- prefix', () => {
-      expect(codec.decode('conversations/conv-1' as MemoryScopeKey, 'message-5')).toFailWith(
-        /must begin with 'turn-'/i
-      );
-    });
-
-    test('fails when the stem turn index is not an integer', () => {
-      expect(codec.decode('conversations/conv-1' as MemoryScopeKey, 'turn-x')).toFailWith(
-        /must be a non-negative integer/i
-      );
-    });
-  });
-
-  describe('verifyRoundTrip', () => {
-    test('succeeds for a composite key under a conversations/<id> scope', () => {
-      expect(codec.verifyRoundTrip('conversations/conv-1' as MemoryScopeKey, 'turn-5')).toSucceedWith(true);
-    });
-
-    test('fails when the scope is malformed', () => {
-      expect(codec.verifyRoundTrip('conversations' as MemoryScopeKey, 'turn-5')).toFailWith(
-        /must be 'conversations\/<conversationId>'/i
-      );
-    });
-  });
-
-  test('encode/decode round-trips the composite key and the conversations/<id> scope', () => {
-    const entityId: EntityId = 'conv-9:17' as EntityId;
-    expect(codec.encode(entityId)).toSucceedAndSatisfy((addr) => {
-      expect(addr.scope).toBe('conversations/conv-9');
-      expect(addr.idStem).toBe('turn-17');
-      expect(codec.decode(addr.scope, addr.idStem)).toSucceedWith(entityId);
-    });
-  });
-});

package/src/test/unit/types/ids.test.ts

@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import '@fgv/ts-utils-jest';
-import { Convert } from '../../../packlets/types';
-
-describe('branded id converters', () => {
-  describe('shared hygiene', () => {
-    test.each([
-      ['memoryId', Convert.memoryId],
-      ['entityId', Convert.entityId],
-      ['kind', Convert.kind],
-      ['tag', Convert.tag],
-      ['scopeKey', Convert.scopeKey],
-      ['linkType', Convert.linkType]
-    ] as const)('%s rejects an empty string', (__name, converter) => {
-      expect(converter.convert('')).toFailWith(/must be a non-empty string/i);
-    });
-
-    test.each([
-      ['memoryId', Convert.memoryId],
-      ['entityId', Convert.entityId],
-      ['kind', Convert.kind],
-      ['tag', Convert.tag],
-      ['scopeKey', Convert.scopeKey],
-      ['linkType', Convert.linkType]
-    ] as const)('%s rejects a value over the length cap', (__name, converter) => {
-      expect(converter.convert('a'.repeat(257))).toFailWith(/exceeds maximum length 256/i);
-    });
-
-    test.each([
-      ['memoryId', Convert.memoryId],
-      ['entityId', Convert.entityId],
-      ['kind', Convert.kind],
-      ['tag', Convert.tag],
-      ['scopeKey', Convert.scopeKey],
-      ['linkType', Convert.linkType]
-    ] as const)('%s rejects leading/trailing whitespace', (__name, converter) => {
-      expect(converter.convert(' value ')).toFailWith(/leading or trailing whitespace/i);
-    });
-
-    test.each([
-      ['memoryId', Convert.memoryId],
-      ['entityId', Convert.entityId],
-      ['kind', Convert.kind],
-      ['tag', Convert.tag],
-      ['scopeKey', Convert.scopeKey],
-      ['linkType', Convert.linkType]
-    ] as const)('%s rejects a non-string', (__name, converter) => {
-      expect(converter.convert(42)).toFail();
-    });
-
-    test.each([
-      ['memoryId', Convert.memoryId, 'doc-123'],
-      ['entityId', Convert.entityId, 'doc-123'],
-      ['kind', Convert.kind, 'knowledge'],
-      ['tag', Convert.tag, 'topic:rust'],
-      ['scopeKey', Convert.scopeKey, 'knowledge'],
-      ['linkType', Convert.linkType, 'mtm-ref']
-    ] as const)('%s accepts a valid value at the length cap boundary', (__name, converter, value) => {
-      expect(converter.convert(value)).toSucceedWith(value as never);
-      expect(converter.convert('a'.repeat(256))).toSucceedWith('a'.repeat(256) as never);
-    });
-  });
-
-  describe('relaxed-constraint brands', () => {
-    test('scopeKey accepts a multi-segment, slash-separated path', () => {
-      expect(Convert.scopeKey.convert('conversations/conv-1')).toSucceedWith('conversations/conv-1' as never);
-    });
-
-    test('entityId accepts a colon-separated composite key', () => {
-      expect(Convert.entityId.convert('conv-1:7')).toSucceedWith('conv-1:7' as never);
-    });
-  });
-
-  describe('memoryId filename-stem constraint', () => {
-    test('accepts a portable filename stem', () => {
-      expect(Convert.memoryId.convert('intro-to-rust.v2')).toSucceedWith('intro-to-rust.v2' as never);
-    });
-
-    test('rejects path-unsafe ids that the relaxed brands accept (id IS the filename stem)', () => {
-      expect(Convert.memoryId.convert('a/b')).toFailWith(/POSIX portable filename set/i);
-      expect(Convert.memoryId.convert('conv-1:7')).toFailWith(/POSIX portable filename set/i);
-      // sanity: EntityId stays relaxed for the same composite domain key
-      expect(Convert.entityId.convert('conv-1:7')).toSucceed();
-    });
-
-    test('still applies the shared hygiene before the stem check', () => {
-      expect(Convert.memoryId.convert('')).toFailWith(/must be a non-empty string/i);
-    });
-  });
-});

package/src/test/unit/types/temporalCodec.test.ts

@@ -1,259 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- * SPDX-License-Identifier: MIT
- */
-
-import '@fgv/ts-utils-jest';
-import {
-  EntityId,
-  IIdentityCodec,
-  IMemoryRecord,
-  KnowledgeIdentityCodec,
-  MemoryScopeKey,
-  TemporalIdentityCodec,
-  isTemporalIdentityCodec,
-  isTemporalRecord,
-  isVersionCurrent,
-  isVersionValidAt,
-  selectCurrentVersion,
-  selectVersionAsOf
-} from '../../../packlets/types';
-import { envelopeConverter } from '../../../packlets/converters';
-
-const codec: TemporalIdentityCodec = TemporalIdentityCodec.create('facts').orThrow();
-
-describe('TemporalIdentityCodec', () => {
-  describe('create', () => {
-    test('rejects a non-portable base scope', () => {
-      expect(TemporalIdentityCodec.create('has/slash')).toFailWith(/baseScope/i);
-    });
-  });
-
-  describe('encode', () => {
-    test('maps an entityId to the entity subtree, versioned', () => {
-      expect(codec.encode('fact-1' as EntityId)).toSucceedWith({
-        scope: 'facts/entities/fact-1' as MemoryScopeKey,
-        idStem: 'fact-1',
-        isVersioned: true
-      });
-    });
-
-    test('rejects a non-portable entityId', () => {
-      expect(codec.encode('bad/id' as EntityId)).toFailWith(/entityId/i);
-    });
-  });
-
-  describe('encodeVersion', () => {
-    test('forms the <entityId>-v<seq> stem', () => {
-      expect(codec.encodeVersion('fact-1' as EntityId, 7)).toSucceedWith('fact-1-v7');
-    });
-
-    test('rejects a negative or non-integer seq', () => {
-      expect(codec.encodeVersion('fact-1' as EntityId, -1)).toFailWith(/non-negative integer/i);
-      expect(codec.encodeVersion('fact-1' as EntityId, 1.5)).toFailWith(/non-negative integer/i);
-    });
-
-    test('rejects a non-portable entityId', () => {
-      expect(codec.encodeVersion('bad/id' as EntityId, 1)).toFailWith(/entityId/i);
-    });
-  });
-
-  describe('decode / decodeVersion', () => {
-    test('recovers the entityId and seq from a (scope, version stem)', () => {
-      expect(codec.decodeVersion('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-v3')).toSucceedWith({
-        entityId: 'fact-1' as EntityId,
-        seq: 3
-      });
-      expect(codec.decode('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-v3')).toSucceedWith(
-        'fact-1' as EntityId
-      );
-    });
-
-    test('disambiguates an entityId that itself ends in -v<digits> via the scope', () => {
-      // The subtree scope is authoritative for the entityId, so a stem whose
-      // entityId is `rev-v2` parses correctly.
-      expect(codec.decodeVersion('facts/entities/rev-v2' as MemoryScopeKey, 'rev-v2-v5')).toSucceedWith({
-        entityId: 'rev-v2' as EntityId,
-        seq: 5
-      });
-    });
-
-    test('rejects a scope that is not <base>/entities/<entityId>', () => {
-      expect(codec.decodeVersion('facts/fact-1' as MemoryScopeKey, 'fact-1-v0')).toFailWith(
-        /must be 'facts\/entities\/<entityId>'/i
-      );
-      expect(codec.decodeVersion('other/entities/fact-1' as MemoryScopeKey, 'fact-1-v0')).toFailWith(
-        /must be 'facts\/entities\/<entityId>'/i
-      );
-    });
-
-    test('rejects a non-portable entityId embedded in the scope', () => {
-      expect(codec.decodeVersion('facts/entities/ ' as MemoryScopeKey, ' -v0')).toFailWith(/entityId/i);
-    });
-
-    test('rejects a stem that does not carry the entity prefix', () => {
-      expect(codec.decodeVersion('facts/entities/fact-1' as MemoryScopeKey, 'other-v0')).toFailWith(
-        /must begin with 'fact-1-v'/i
-      );
-    });
-
-    test('rejects a stem with a non-integer version suffix', () => {
-      expect(codec.decodeVersion('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-vX')).toFailWith(
-        /non-integer version suffix/i
-      );
-    });
-
-    test('rejects a version suffix outside the safe integer range (corruption/tamper guard)', () => {
-      // A very long digit run passes the regex but overflows Number.MAX_SAFE_INTEGER;
-      // parseInt would silently lose precision, so decode must fail rather than corrupt seq.
-      expect(
-        codec.decodeVersion('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-v99999999999999999999')
-      ).toFailWith(/outside the safe integer range/i);
-    });
-  });
-
-  describe('verifyRoundTrip', () => {
-    test('succeeds for a well-formed (scope, version stem)', () => {
-      expect(codec.verifyRoundTrip('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-v9')).toSucceedWith(
-        true
-      );
-    });
-
-    test('fails when the stem cannot be decoded', () => {
-      expect(codec.verifyRoundTrip('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-vZ')).toFailWith(
-        /non-integer version suffix/i
-      );
-    });
-
-    test('fails on a non-canonical (zero-padded) seq stem', () => {
-      // `-v007` decodes to seq 7 but re-encodes to `-v7`, so it is not canonical.
-      expect(codec.verifyRoundTrip('facts/entities/fact-1' as MemoryScopeKey, 'fact-1-v007')).toFailWith(
-        /round-trip mismatch/i
-      );
-    });
-  });
-});
-
-describe('isTemporalIdentityCodec', () => {
-  test('is true for a temporal codec', () => {
-    expect(isTemporalIdentityCodec(codec)).toBe(true);
-  });
-
-  test('is false for a flat codec', () => {
-    const flat: IIdentityCodec = new KnowledgeIdentityCodec();
-    expect(isTemporalIdentityCodec(flat)).toBe(false);
-  });
-});
-
-/** Build a temporal version record for the selection-helper tests. */
-// eslint-disable-next-line @rushstack/no-new-null -- invalid_at null is the meaningful still-valid sentinel
-function versionRecord(seq: number, validAt: number, invalidAt?: number | null): IMemoryRecord<unknown> {
-  const temporal: Record<string, unknown> = { valid_at: validAt };
-  if (invalidAt !== undefined) {
-    temporal.invalid_at = invalidAt;
-  }
-  return {
-    envelope: envelopeConverter
-      .convert({
-        id: `fact-1-v${seq}`,
-        entityId: 'fact-1',
-        kind: 'fact',
-        tags: [],
-        links: [],
-        created: validAt,
-        updated: validAt,
-        seq,
-        contentHash: `h${seq}`,
-        provenance: { source: 'agent' },
-        temporal
-      })
-      .orThrow(),
-    body: `body v${seq}`
-  };
-}
-
-describe('temporal selection helpers', () => {
-  const v1 = versionRecord(1, 100, 200);
-  const v2 = versionRecord(2, 200);
-  const atemporal: IMemoryRecord<unknown> = {
-    envelope: envelopeConverter
-      .convert({
-        id: 'doc',
-        entityId: 'doc',
-        kind: 'knowledge',
-        tags: [],
-        links: [],
-        created: 0,
-        updated: 0,
-        seq: 0,
-        contentHash: 'h',
-        provenance: { source: 'agent' }
-      })
-      .orThrow(),
-    body: 'flat'
-  };
-
-  test('isTemporalRecord keys off the temporal block', () => {
-    expect(isTemporalRecord(v1)).toBe(true);
-    expect(isTemporalRecord(atemporal)).toBe(false);
-  });
-
-  test('isVersionCurrent is true only for a null/absent invalid_at', () => {
-    expect(isVersionCurrent(v1)).toBe(false);
-    expect(isVersionCurrent(v2)).toBe(true);
-    expect(isVersionCurrent(versionRecord(3, 300, null))).toBe(true);
-    expect(isVersionCurrent(atemporal)).toBe(false);
-  });
-
-  test('isVersionValidAt bounds by valid_at and invalid_at', () => {
-    expect(isVersionValidAt(v1, 50)).toBe(false); // before valid_at
-    expect(isVersionValidAt(v1, 150)).toBe(true); // within [100, 200)
-    expect(isVersionValidAt(v1, 200)).toBe(false); // at invalid_at (exclusive)
-    expect(isVersionValidAt(v2, 500)).toBe(true); // still valid
-    expect(isVersionValidAt(atemporal, 500)).toBe(false);
-  });
-
-  test('isVersionValidAt defaults valid_at to created when absent', () => {
-    const noValidAt: IMemoryRecord<unknown> = {
-      envelope: envelopeConverter
-        .convert({
-          id: 'fact-1-v4',
-          entityId: 'fact-1',
-          kind: 'fact',
-          tags: [],
-          links: [],
-          created: 400,
-          updated: 400,
-          seq: 4,
-          contentHash: 'h4',
-          provenance: { source: 'agent' },
-          temporal: {}
-        })
-        .orThrow(),
-      body: 'v4'
-    };
-    expect(isVersionValidAt(noValidAt, 399)).toBe(false);
-    expect(isVersionValidAt(noValidAt, 400)).toBe(true);
-  });
-
-  test('selectCurrentVersion returns the highest-seq current version', () => {
-    expect(selectCurrentVersion([v1, v2])?.envelope.id).toBe('fact-1-v2');
-    // A fully-invalidated entity has no current version.
-    expect(selectCurrentVersion([v1])).toBeUndefined();
-    expect(selectCurrentVersion([])).toBeUndefined();
-  });
-
-  test('selectCurrentVersion is order-independent (highest seq wins on an unsorted input)', () => {
-    const v3 = versionRecord(3, 300);
-    // Descending input: the first candidate is already the max, so a later
-    // candidate must NOT displace it.
-    expect(selectCurrentVersion([v3, v2])?.envelope.id).toBe('fact-1-v3');
-    expect(selectCurrentVersion([v2, v3])?.envelope.id).toBe('fact-1-v3');
-  });
-
-  test('selectVersionAsOf returns the highest-seq version valid at the instant', () => {
-    expect(selectVersionAsOf([v1, v2], 150)?.envelope.id).toBe('fact-1-v1');
-    expect(selectVersionAsOf([v1, v2], 250)?.envelope.id).toBe('fact-1-v2');
-    expect(selectVersionAsOf([v1, v2], 50)).toBeUndefined();
-  });
-});