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

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

@@ -0,0 +1,259 @@
+/*
+ * 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();
+  });
+});

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

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2026 Erik Fortune
+ * SPDX-License-Identifier: MIT
+ */
+
+import '@fgv/ts-utils-jest';
+import {
+  EntityId,
+  IMemoryEnvelope,
+  IMemoryRecord,
+  IProvenance,
+  Kind,
+  MemoryId,
+  Tag,
+  TemporalVersionedPolicy
+} from '../../../packlets/types';
+
+function makeRecord(overrides?: Partial<IMemoryEnvelope>, body?: unknown): IMemoryRecord<unknown> {
+  const envelope: IMemoryEnvelope = {
+    id: 'fact-1-v1' as MemoryId,
+    entityId: 'fact-1' as EntityId,
+    kind: 'fact' as Kind,
+    tags: ['sky'] as Tag[],
+    links: [],
+    created: 1000,
+    updated: 1000,
+    seq: 1,
+    contentHash: 'hash-1',
+    provenance: { source: 'agent' } as IProvenance,
+    temporal: { valid_at: 1000 },
+    ...overrides
+  };
+  return { envelope, body: body ?? 'the sky is blue' };
+}
+
+describe('TemporalVersionedPolicy', () => {
+  let policy: TemporalVersionedPolicy;
+
+  beforeEach(() => {
+    policy = TemporalVersionedPolicy.create().orThrow();
+  });
+
+  test('exposes the temporal mutable surface and entity dedup', () => {
+    expect(policy.mutableFields).toEqual(['body', 'tags', 'links', 'provenance', 'embeddingRef']);
+    expect(policy.dedupScope).toBe('entity');
+  });
+
+  describe('admit', () => {
+    test("always accepts (invalidate-don't-delete: never culls)", () => {
+      expect(policy.admit(makeRecord(), [])).toSucceedWith({ decision: 'accept' });
+      expect(policy.admit(makeRecord(), [makeRecord(), makeRecord()])).toSucceedWith({
+        decision: 'accept'
+      });
+    });
+  });
+
+  describe('applyUpdate (forms the new version content)', () => {
+    test('replaces a string body wholesale', () => {
+      const existing = makeRecord(undefined, 'the sky is blue');
+      expect(policy.applyUpdate(existing, { body: 'the sky is grey' })).toSucceedAndSatisfy((updated) => {
+        expect(updated.body).toBe('the sky is grey');
+      });
+    });
+
+    test('merges tags / provenance and preserves untouched envelope metadata', () => {
+      const existing = makeRecord({ provenance: { source: 'agent', by: 'curator' } as IProvenance });
+      expect(
+        policy.applyUpdate(existing, { tags: ['sky', 'weather'], provenance: { model: 'gpt' } })
+      ).toSucceedAndSatisfy((updated) => {
+        expect(updated.envelope.tags).toEqual(['sky', 'weather']);
+        expect(updated.envelope.provenance).toEqual({ source: 'agent', by: 'curator', model: 'gpt' });
+        // Identity/transaction-time fields are carried verbatim (the store restamps them).
+        expect(updated.envelope.entityId).toBe('fact-1');
+      });
+    });
+
+    test('rejects a patch that deletes a required field', () => {
+      expect(policy.applyUpdate(makeRecord(), { body: null })).toFailWith(/may not delete required field/i);
+    });
+
+    test('restores embeddingRef as absent when a null patch drops it (hash-stable)', () => {
+      const existing = makeRecord({ embeddingRef: 'vec-1' });
+      expect(policy.applyUpdate(existing, { embeddingRef: null })).toSucceedAndSatisfy((updated) => {
+        expect(updated.envelope.embeddingRef).toBeUndefined();
+      });
+    });
+
+    test('carries an untouched embeddingRef through a body-only patch', () => {
+      const existing = makeRecord({ embeddingRef: 'vec-1' }, 'the sky is blue');
+      expect(policy.applyUpdate(existing, { body: 'the sky is grey' })).toSucceedAndSatisfy((updated) => {
+        expect(updated.body).toBe('the sky is grey');
+        expect(updated.envelope.embeddingRef).toBe('vec-1');
+      });
+    });
+  });
+});

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

@@ -1,5 +1,5 @@
 {
-  "cacheVersion": "9.39.4_v22.22.0",
+  "cacheVersion": "9.39.5_v24.15.0",
   "fileVersions": [
     [
       "packlets/types/filenameSafety.ts",
@@ -15,15 +15,19 @@
     ],
     [
       "packlets/types/identityCodec.ts",
-      "280d27a02a8ac914fa8fdfbcc0624a913a145178edca6ecd5c5d90e318fdb10b_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "dfd6399be63cb55f38a37e1bee02d33458496d8fc16d879ce6f64386fb665f3e_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/types/temporal.ts",
+      "c466e8c492ea8770d3c6045edf9fafb6df0e4be7ef94b6fa37f1825904289f65_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/types/writePolicy.ts",
-      "511e86a9b7112468ad162597e555da7e009c8bcc415408c73b9e028ee4ccfaf4_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "0b914ac826cd126c34f73156a8b98efbbab44ef86dc476342a5d1c0afba485e6_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/types/index.ts",
-      "e74d947932429f3cfbb08cc84668da6ddac280ee2d984bb9aa59570b88a7a1e9_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "21552730a5f27a53d1cdee798c4a22860f23b3d4290c3acdde08dcd7734adab2_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/converters/bodyConverterRegistry.ts",
@@ -75,7 +79,7 @@
     ],
     [
       "packlets/store/fileTreeMemoryStore.ts",
-      "a7e4c896fd306508b97933c108d7ae006e4393ee921717a7e3ac0bfd38a0ff98_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "75746b65d0cde19462c3f6809a59fd60985864bf5fa1a66c7a59795115b49b8b_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/store/index.ts",
@@ -105,17 +109,53 @@
       "packlets/retrieve/semanticRetriever.ts",
       "30b52f854d7ccf395e03278e3889f7512ea825a489d31966736cef9a143bf991_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
+    [
+      "packlets/retrieve/temporalRetrievers.ts",
+      "0131f13f335eca903bd94e2e8c793ca7af52e0cf60d63d83a6c12365ea530472_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
     [
       "packlets/retrieve/hybridRetriever.ts",
       "a3a6deccf2f8fff2a1863b31835780d8b1fa2a85af5db6639c38b2a5bc34a806_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "packlets/retrieve/index.ts",
-      "39e1c225410ab3441a15326f90de9cc078fc3f72fdb8b58bde4a5047a5e65d6d_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "69aedb66b96e404cb8a20b1762605bb3646620e8d69ce520052a0d28715c7b54_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/tools/memoryTools.ts",
+      "5593b178cee4f05bae54292130f5bc0bbb6858d7b10e5a4602ebbc22e29b8cbc_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/tools/index.ts",
+      "450d52ceb27041fdace7ece7e49b747187deecbc5a3f5fafc6049a5809e576a2_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/ingest/model.ts",
+      "666b14530d8ffcd51cd1d13ad46d1616c87f75e4ce28fd0db8ebacc434714cfe_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/ingest/hostStages.ts",
+      "2b848556ea7d94a9f9247a6780428585e56e5d281364e16ff9cefad465ff05e1_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/ingest/cycleGuard.ts",
+      "c2c969319313740b5a861ffede25512e843cdc4a62d2ed81d6ada3bfea3c6bcf_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/ingest/orchestrator.ts",
+      "f821fe8bc363157124a991a4dff62a2c96c1fefe14db54993147a00f5b522e8b_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "packlets/ingest/index.ts",
+      "95098b11f231af90b75e9b8ea81b4a2f7be28679930e6470206eda8723b2530d_5FxNr7n+qjkV58wA2j2YZUqKABE="
     ],
     [
       "index.ts",
-      "99fdcf995285072710d5a6239d578f46446eadb35c6bd5e6255d1b72394fb1c4_5FxNr7n+qjkV58wA2j2YZUqKABE="
+      "31af89fc4f15e6e2ad7542569401f39c29319d6f740c2f8be8478e2c0a266f4e_5FxNr7n+qjkV58wA2j2YZUqKABE="
+    ],
+    [
+      "test/unit/converters/antagonistRoundTrip.test.ts",
+      "716259d8068e73fd8444a306835881f9cff709e043dde61578bb2a061decdfb7_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/converters/bodyConverterRegistry.test.ts",
@@ -129,6 +169,18 @@
       "test/unit/index/memoryIndex.test.ts",
       "a9f1894d8e8ab4430709fcd6addb003ecd6ff98baebf855ace88f39427e30593_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
+    [
+      "test/unit/ingest/antagonistCycleAndParity.test.ts",
+      "af7b769809b92543b0a9cd32ddcb1de8bcb4db102d7997b71be7a84d9b1fbb09_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
+    [
+      "test/unit/ingest/cycleGuard.test.ts",
+      "ffb8024c01a769482c7abcc057c2e4ad798ffc50f010081a9283f1cf1209d56e_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
+    [
+      "test/unit/ingest/orchestrator.test.ts",
+      "945eb0d45fa417bcb4a88eb7bfb5ee8b51fbd16099925b9dc1888c69fc02d236_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
     [
       "test/unit/observe/memoryObservationStore.test.ts",
       "675e6b09c107c74fe254a0f208be0d8177ace1971fb8f1a7ae0a3c3c56f38357_fnTnCS8rja7DE6jB0bKRna1pZAg="
@@ -141,13 +193,21 @@
       "test/unit/retrieve/retrievers.test.ts",
       "e4a7ba604ec7c481d2a491358d1c42d9e1eecdb77fa3e3a804c10fe72e5506df_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
+    [
+      "test/unit/retrieve/temporalRetrievers.test.ts",
+      "e068283b7d75482efe6116e0396c6b7a6865b20bb57e4efec9abd8b811f5fc9e_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
+    [
+      "test/unit/store/antagonistTemporalBoundary.test.ts",
+      "ab04a6b3292ce201a3ad9f4528aea460ecdf9b832fcff5799aa7608d2d8f05ca_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
     [
       "test/unit/store/embedOnWrite.test.ts",
       "9bdab98d1e0cb73f16a5d18daf0bd7e4da02db28d05e82424d1c42e9fc0b2c45_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/store/fileTreeMemoryStore.test.ts",
-      "4768a91f3d0117105b77168d9fbf9184b95f2af7bfb1f802eef9f078394a38fa_fnTnCS8rja7DE6jB0bKRna1pZAg="
+      "06407be1a2dc1b914cecefe63766ea4a597c132cc04e87d8b2a373d582be435f_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
     [
       "test/unit/store/observations.test.ts",
@@ -157,6 +217,14 @@
       "test/unit/store/scopeEncoding.test.ts",
       "5ea0364489c7424bbfcae0b85f71a49aa069202e307282f808ea54449a927c3b_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
+    [
+      "test/unit/store/temporalStore.test.ts",
+      "351187294694c4f616dae51b837cc0abe346da028c08986e77a9faad4a372731_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
+    [
+      "test/unit/tools/memoryTools.test.ts",
+      "ed1b29228843e28ce103a46705426eb63b5e8b4d0f76e66c63747b259c2cd8f0_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
     [
       "test/unit/types/identityCodec.test.ts",
       "0bdce7a05231458604750150fc806f1fc64b159949edc3af2f5a20d5d9bfceee_fnTnCS8rja7DE6jB0bKRna1pZAg="
@@ -165,6 +233,14 @@
       "test/unit/types/ids.test.ts",
       "30b7ac5c0daa99f32913eefdd6825d4e73e7e91d66c5863c5a5b8d8666635fc8_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ],
+    [
+      "test/unit/types/temporalCodec.test.ts",
+      "2a7963436cf9d7518be5dabb98a7bcf8091857ddfcc1068d21a67002b564875a_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
+    [
+      "test/unit/types/temporalPolicy.test.ts",
+      "f6ff83abe5e9e418ee0445f54eda869f1400d49cd11529da9be06c69be7f7c70_fnTnCS8rja7DE6jB0bKRna1pZAg="
+    ],
     [
       "test/unit/types/writePolicy.test.ts",
       "b1dce7dcab42c012d504d2d108626e62ce024463654f118b5bb78adb2faa7dac_fnTnCS8rja7DE6jB0bKRna1pZAg="
@@ -178,5 +254,5 @@
       "fb1b4366bcd6b06174b82a3604cd6ee09692cb89a6c38b90866281ba204efc90_fnTnCS8rja7DE6jB0bKRna1pZAg="
     ]
   ],
-  "filesHash": "6mhWoAAG3IozXRRuSjvrbA"
+  "filesHash": "41qqBVkA2UlzsTYEJ5_czQ"
 }