@xyo-network/diviner-temporal-indexing-memory 4.2.1 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/diviner-temporal-indexing-memory",
-  "version": "4.2.1",
+  "version": "5.0.0",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -28,45 +28,49 @@
   },
   "module": "dist/neutral/index.mjs",
   "types": "dist/neutral/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
-    "@xylabs/array": "^4.14.1",
-    "@xylabs/assert": "^4.14.1",
-    "@xylabs/exists": "^4.14.1",
-    "@xyo-network/archivist-model": "^4.2.1",
-    "@xyo-network/archivist-wrapper": "^4.2.1",
-    "@xyo-network/boundwitness-model": "^4.2.1",
-    "@xyo-network/boundwitness-validator": "^4.2.1",
-    "@xyo-network/diviner-abstract": "^4.2.1",
-    "@xyo-network/diviner-boundwitness-abstract": "^4.2.1",
-    "@xyo-network/diviner-boundwitness-model": "^4.2.1",
-    "@xyo-network/diviner-indexing-memory": "^4.2.1",
-    "@xyo-network/diviner-indexing-model": "^4.2.1",
-    "@xyo-network/diviner-jsonpath-aggregate-memory": "^4.2.1",
-    "@xyo-network/diviner-jsonpath-model": "^4.2.1",
-    "@xyo-network/diviner-model": "^4.2.1",
-    "@xyo-network/diviner-payload-model": "^4.2.1",
-    "@xyo-network/diviner-temporal-indexing-model": "^4.2.1",
-    "@xyo-network/diviner-wrapper": "^4.2.1",
-    "@xyo-network/module-model": "^4.2.1",
-    "@xyo-network/payload-builder": "^4.2.1",
-    "@xyo-network/payload-model": "^4.2.1",
-    "@xyo-network/payload-utils": "^4.2.1",
-    "@xyo-network/witness-timestamp": "^4.2.1"
+    "@xylabs/array": "^5.0.0",
+    "@xylabs/assert": "^5.0.0",
+    "@xylabs/exists": "^5.0.0",
+    "@xyo-network/archivist-model": "^5.0.0",
+    "@xyo-network/archivist-wrapper": "^5.0.0",
+    "@xyo-network/boundwitness-model": "^5.0.0",
+    "@xyo-network/boundwitness-validator": "^5.0.0",
+    "@xyo-network/diviner-abstract": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-abstract": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-model": "^5.0.0",
+    "@xyo-network/diviner-indexing-memory": "^5.0.0",
+    "@xyo-network/diviner-indexing-model": "^5.0.0",
+    "@xyo-network/diviner-jsonpath-aggregate-memory": "^5.0.0",
+    "@xyo-network/diviner-jsonpath-model": "^5.0.0",
+    "@xyo-network/diviner-model": "^5.0.0",
+    "@xyo-network/diviner-payload-model": "^5.0.0",
+    "@xyo-network/diviner-temporal-indexing-model": "^5.0.0",
+    "@xyo-network/diviner-wrapper": "^5.0.0",
+    "@xyo-network/module-model": "^5.0.0",
+    "@xyo-network/payload-builder": "^5.0.0",
+    "@xyo-network/payload-model": "^5.0.0",
+    "@xyo-network/payload-utils": "^5.0.0",
+    "@xyo-network/witness-timestamp": "^5.0.0"
   },
   "devDependencies": {
-    "@xylabs/delay": "^4.14.1",
-    "@xylabs/hex": "^4.14.1",
-    "@xylabs/object": "^4.14.1",
-    "@xylabs/promise": "^4.14.1",
-    "@xylabs/ts-scripts-yarn3": "^7.0.1",
-    "@xylabs/tsconfig": "^7.0.1",
-    "@xylabs/vitest-extended": "^4.14.1",
-    "@xyo-network/archivist-memory": "^4.2.1",
-    "@xyo-network/boundwitness-builder": "^4.2.1",
-    "@xyo-network/manifest": "^4.2.1",
-    "@xyo-network/module-factory-locator": "^4.2.1",
-    "@xyo-network/node-memory": "^4.2.1",
-    "@xyo-network/wallet": "^4.2.1",
+    "@xylabs/delay": "^5.0.0",
+    "@xylabs/hex": "^5.0.0",
+    "@xylabs/object": "^5.0.0",
+    "@xylabs/promise": "^5.0.0",
+    "@xylabs/ts-scripts-yarn3": "^7.0.2",
+    "@xylabs/tsconfig": "^7.0.2",
+    "@xylabs/vitest-extended": "^5.0.0",
+    "@xyo-network/archivist-memory": "^5.0.0",
+    "@xyo-network/boundwitness-builder": "^5.0.0",
+    "@xyo-network/manifest": "^5.0.0",
+    "@xyo-network/module-factory-locator": "^5.0.0",
+    "@xyo-network/node-memory": "^5.0.0",
+    "@xyo-network/wallet": "^5.0.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },

package/src/DivinerQueryToIndexQueryDiviner/spec/Diviner.spec.ts

@@ -0,0 +1,244 @@
+import '@xylabs/vitest-extended'
+
+import type { SchemaToJsonPathTransformExpressionsDictionary } from '@xyo-network/diviner-jsonpath-model'
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { isPayloadDivinerQueryPayload, PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig } from '@xyo-network/diviner-temporal-indexing-model'
+import {
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema,
+  TemporalIndexingDivinerResultIndexSchema,
+} from '@xyo-network/diviner-temporal-indexing-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner } from '../Diviner.ts'
+
+type QueryType = PayloadDivinerQueryPayload<{ status?: number; success?: boolean; url: string }>
+
+describe('TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner', () => {
+  const url = 'https://xyo.network'
+  let diviner: TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner
+  describe('divine', () => {
+    describe('with with no config specified', () => {
+      const queries: QueryType[] = [
+        {
+          schema: PayloadDivinerQuerySchema,
+          url,
+        },
+        {
+          limit: 10,
+          order: 'asc',
+          schema: PayloadDivinerQuerySchema,
+        },
+      ]
+      const expected: PayloadDivinerQueryPayload[] = [
+        {
+          limit: 1,
+          order: 'desc',
+          schema: 'network.xyo.diviner.payload.query',
+          schemas: [TemporalIndexingDivinerResultIndexSchema],
+        } as unknown as PayloadDivinerQueryPayload,
+        {
+          limit: 10,
+          order: 'asc',
+          schema: 'network.xyo.diviner.payload.query',
+          schemas: [TemporalIndexingDivinerResultIndexSchema],
+        } as unknown as PayloadDivinerQueryPayload,
+      ]
+      beforeAll(async () => {
+        diviner = await TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.create({ account: 'random' })
+      })
+      const cases: [QueryType, PayloadDivinerQueryPayload][] = queries.map((query, i) => [query, expected[i]])
+      describe('with single query', () => {
+        it.each(cases)('transforms query using default settings', async (query, expected) => {
+          const results = await diviner.divine([query])
+          const actual = results.filter(isPayloadDivinerQueryPayload)
+          expect(actual).toBeArrayOfSize(1)
+          expect(PayloadBuilder.omitMeta(actual[0])).toEqual(PayloadBuilder.omitMeta(expected))
+        })
+      })
+      describe('with multiple queries', () => {
+        it('transforms queries using default settings', async () => {
+          const results = await diviner.divine(queries)
+          const actual = results.filter(isPayloadDivinerQueryPayload)
+          expect(actual).toBeArrayOfSize(expected.length)
+          expect(actual.map(i => PayloadBuilder.omitMeta(i))).toEqual(expected.map(i => PayloadBuilder.omitMeta(i)))
+        })
+      })
+    })
+    describe('with config fields specified', () => {
+      const divinerQuerySchema = 'network.xyo.test.source.query'
+      const indexQuerySchema = 'network.xyo.test.destination.query'
+      const indexSchema = 'network.xyo.test.index.schema'
+      const queries = [
+        {
+          schema: divinerQuerySchema,
+          url,
+        },
+        {
+          limit: 10,
+          order: 'asc',
+          schema: divinerQuerySchema,
+          status: 200,
+          success: true,
+          url,
+        },
+        {
+          limit: 10,
+          schema: divinerQuerySchema,
+          url,
+        },
+        {
+          schema: divinerQuerySchema,
+          url,
+        },
+        {
+          order: 'asc',
+          schema: divinerQuerySchema,
+          url,
+        },
+        {
+          schema: divinerQuerySchema,
+          status: 200,
+          url,
+        },
+        {
+          schema: divinerQuerySchema,
+          success: true,
+          url,
+        },
+        {
+          schema: divinerQuerySchema,
+          success: false,
+          url,
+        },
+      ]
+      const expected = [
+        {
+          limit: 1,
+          order: 'desc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          url,
+        },
+        {
+          limit: 10,
+          order: 'asc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          status: 200,
+          success: true,
+          url,
+        },
+        {
+          limit: 10,
+          order: 'desc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          url,
+        },
+        {
+          limit: 1,
+          order: 'desc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          url,
+        },
+        {
+          limit: 1,
+          order: 'asc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          url,
+        },
+        {
+          limit: 1,
+          order: 'desc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          status: 200,
+          url,
+        },
+        {
+          limit: 1,
+          order: 'desc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          success: true,
+          url,
+        },
+        {
+          limit: 1,
+          order: 'desc',
+          schema: indexQuerySchema,
+          schemas: [indexSchema],
+          success: false,
+          url,
+        },
+      ]
+      const cases: [Payload, Payload][] = queries.map((query, i) => [query, expected[i]])
+      const schemaTransforms: SchemaToJsonPathTransformExpressionsDictionary = {
+        [divinerQuerySchema]: [
+          {
+            destinationField: 'url',
+            sourcePathExpression: '$.url',
+          },
+          {
+            defaultValue: 1,
+            destinationField: 'limit',
+            sourcePathExpression: '$.limit',
+          },
+          {
+            // defaultValue: 0,
+            destinationField: 'cursor',
+            sourcePathExpression: '$.cursor',
+          },
+          {
+            defaultValue: 'desc',
+            destinationField: 'order',
+            sourcePathExpression: '$.order',
+          },
+          {
+            destinationField: 'status',
+            sourcePathExpression: '$.status',
+          },
+          {
+            destinationField: 'success',
+            sourcePathExpression: '$.success',
+          },
+        ],
+      }
+      const config: TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig = {
+        divinerQuerySchema,
+        indexQuerySchema,
+        indexSchema,
+        schema: TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema,
+        schemaTransforms,
+      }
+      beforeAll(async () => {
+        diviner = await TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.create({ account: 'random', config })
+      })
+      describe('with single query', () => {
+        it.each(cases)('transforms query using default settings', async (query, expected) => {
+          const results = await diviner.divine([query])
+          const actual = results.filter(isPayloadOfSchemaType<Payload>(indexQuerySchema))
+          expect(actual).toBeArrayOfSize(1)
+          expect(PayloadBuilder.omitMeta(actual[0])).toEqual(PayloadBuilder.omitMeta(expected))
+        })
+      })
+      describe('with multiple queries', () => {
+        it('transforms queries using default settings', async () => {
+          const results = await diviner.divine(queries)
+          const actual = results.filter(isPayloadOfSchemaType<Payload>(indexQuerySchema))
+          expect(actual).toBeArrayOfSize(expected.length)
+          expect(actual.map(i => PayloadBuilder.omitMeta(i))).toEqual(expected.map(i => PayloadBuilder.omitMeta(i)))
+        })
+      })
+    })
+  })
+})

package/src/IndexCandidateToIndexDiviner/spec/Diviner.spec.ts

@@ -0,0 +1,247 @@
+import '@xylabs/vitest-extended'
+
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import type { BoundWitness } from '@xyo-network/boundwitness-model'
+import type { SchemaToJsonPathTransformExpressionsDictionary } from '@xyo-network/diviner-jsonpath-model'
+import { isTemporalIndexingDivinerResultIndex } from '@xyo-network/diviner-temporal-indexing-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import type { TimeStamp } from '@xyo-network/witness-timestamp'
+import { TimestampSchema } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { TemporalIndexingDivinerIndexCandidateToIndexDiviner } from '../Diviner.ts'
+
+type ImageThumbnail = Payload<{
+  http?: {
+    ipAddress?: string
+    status?: number
+  }
+  // schema: 'network.xyo.image.thumbnail'
+  sourceUrl: string
+  url?: string
+}>
+
+describe('TemporalIndexCandidateToImageThumbnailIndexDiviner', () => {
+  describe('divine', () => {
+    const timestampA = 1_234_567_890
+    const timestampPayloadA: TimeStamp = { schema: TimestampSchema, timestamp: timestampA }
+    const imageThumbnailPayloadA: ImageThumbnail = {
+      http: { status: 200 },
+      schema: 'network.xyo.image.thumbnail',
+      sourceUrl: 'https://xyo.network',
+      url: 'data',
+    }
+    const timestampB = 1_234_567_891
+    const timestampPayloadB: TimeStamp = { schema: TimestampSchema, timestamp: timestampB }
+    const imageThumbnailPayloadB: ImageThumbnail = {
+      http: { status: 500 },
+      schema: 'network.xyo.image.thumbnail',
+      sourceUrl: 'https://xyo.network',
+    }
+    const timestampC = 1_234_567_892
+    const timestampPayloadC: TimeStamp = { schema: TimestampSchema, timestamp: timestampC }
+    const imageThumbnailPayloadC: ImageThumbnail = {
+
+      http: { ipAddress: '192.169.1.1' },
+      schema: 'network.xyo.image.thumbnail',
+      sourceUrl: 'https://www.google.com',
+    }
+    describe('with single schema transform', () => {
+      const validateSingleResult = async (
+        input: [boundWitness: BoundWitness, timestamp: TimeStamp, thumbnail: ImageThumbnail],
+        result: Payload[],
+      ) => {
+        const [boundWitness, timestamp, thumbnail] = input
+        const payloadDictionary = await PayloadBuilder.toHashMap([boundWitness, timestamp, thumbnail])
+        expect(result).toBeArrayOfSize(1)
+        expect(result.filter(isTemporalIndexingDivinerResultIndex)).toBeArrayOfSize(1)
+        const index = result.find(isTemporalIndexingDivinerResultIndex)
+        // eslint-disable-next-line sonarjs/no-alphabetical-sort
+        expect(index?.$sources.sort()).toEqual(Object.keys(payloadDictionary).toSorted())
+        expect(index?.timestamp).toBe(timestamp.timestamp)
+        expect((index as { url?: string })?.url).toBe(thumbnail.sourceUrl)
+        expect((index as { status?: number })?.status).toBe(thumbnail.http?.status)
+      }
+      beforeAll(async () => {
+        diviner = await TemporalIndexingDivinerIndexCandidateToIndexDiviner.create({
+          account: 'random',
+          config: {
+            schema: TemporalIndexingDivinerIndexCandidateToIndexDiviner.defaultConfigSchema,
+            schemaTransforms,
+          },
+        })
+      })
+      const schemaTransforms: SchemaToJsonPathTransformExpressionsDictionary = {
+        'network.xyo.image.thumbnail': [
+          { destinationField: 'url', sourcePathExpression: '$.sourceUrl' },
+          { destinationField: 'status', sourcePathExpression: '$.http.status' },
+        ],
+        'network.xyo.timestamp': [{ destinationField: 'timestamp', sourcePathExpression: '$.timestamp' }],
+      }
+      let diviner: TemporalIndexingDivinerIndexCandidateToIndexDiviner
+
+      const cases: [TimeStamp, ImageThumbnail][] = [
+        [timestampPayloadA, imageThumbnailPayloadA],
+        [timestampPayloadB, imageThumbnailPayloadB],
+        [timestampPayloadC, imageThumbnailPayloadC],
+      ]
+      describe('with single result', () => {
+        it.each(cases)('transforms single result', async (timestamp, thumbnail) => {
+          const [boundWitness] = await new BoundWitnessBuilder().payloads([timestamp, thumbnail]).build()
+          const result = await diviner.divine([boundWitness, timestamp, thumbnail])
+          await validateSingleResult([boundWitness, timestamp, thumbnail], result)
+        })
+        it('transforms BW with multiple results inside', async () => {
+          const payloads = cases.flat()
+          const [boundWitness] = await new BoundWitnessBuilder().payloads(payloads).build()
+          const results = await diviner.divine([boundWitness, ...payloads])
+          expect(results).toBeArrayOfSize(Math.pow(cases.length, cases[0].length))
+          let resultIndex = 0
+          for (let i = 0; i < cases.length; i++) {
+            const thumbnail = cases[i][1]
+            // eslint-disable-next-line unicorn/no-for-loop
+            for (let j = 0; j < cases.length; j++) {
+              const timestamp = cases[j][0]
+              const result = results[resultIndex]
+              await validateSingleResult([boundWitness, timestamp, thumbnail], [result])
+              resultIndex++
+            }
+          }
+        })
+        it.each(cases)('handles sparse inputs', async (thumbnail, timestamp) => {
+          const [boundWitness] = await new BoundWitnessBuilder().payloads([timestamp, thumbnail]).build()
+          expect(await diviner.divine([thumbnail, timestamp])).toBeArrayOfSize(0)
+          expect(await diviner.divine([boundWitness, timestamp])).toBeArrayOfSize(0)
+          expect(await diviner.divine([boundWitness, thumbnail])).toBeArrayOfSize(0)
+        })
+      })
+      describe('with multiple results', () => {
+        it('transforms multiple results', async () => {
+          const data: [BoundWitness, TimeStamp, ImageThumbnail][] = await Promise.all(
+            cases.map(async (payloads) => {
+              const [bw] = await new BoundWitnessBuilder().payloads(payloads).build()
+              return [bw, ...payloads]
+            }),
+          )
+          const results = await diviner.divine(data.flat())
+          expect(results).toBeArrayOfSize(cases.length)
+
+          await Promise.all(
+            data.map(async (input, i) => {
+              const result = results[i]
+              await validateSingleResult(input, [result])
+            }),
+          )
+        })
+        it('handles sparse inputs', async () => {
+          const [bw] = await new BoundWitnessBuilder().payloads(cases[0]).build()
+          const results = await diviner.divine([bw, ...cases.flat()])
+          expect(results).toBeArrayOfSize(1)
+          await validateSingleResult([bw, ...cases[0]], results)
+        })
+        it('handles missing inputs', async () => {
+          const [bw] = await new BoundWitnessBuilder().payloads([...cases[0]]).build()
+          const results = await diviner.divine([bw, ...cases[0].slice(0, -1)])
+          expect(results).toBeArrayOfSize(0)
+        })
+      })
+    })
+    describe('with multiple schema transforms', () => {
+      const validateMultiResult = async (
+        input: [boundWitness: BoundWitness, timestamp: TimeStamp, thumbnail: ImageThumbnail, payload: Payload],
+        result: Payload[],
+      ) => {
+        const [boundWitness, timestamp, thumbnail, payload] = input
+        const payloadDictionary = await PayloadBuilder.toHashMap([boundWitness, timestamp, thumbnail, payload])
+        expect(result).toBeArrayOfSize(1)
+        expect(result.filter(isTemporalIndexingDivinerResultIndex)).toBeArrayOfSize(1)
+        const index = result.find(isTemporalIndexingDivinerResultIndex)
+        // eslint-disable-next-line sonarjs/no-alphabetical-sort
+        expect(index?.$sources.sort()).toEqual(Object.keys(payloadDictionary).toSorted())
+        expect(index?.timestamp).toBe(timestamp.timestamp)
+        expect((index as { url?: string })?.url).toBe((payload as { sourceUrl?: string }).sourceUrl)
+        expect((index as { status?: number })?.status).toBe(thumbnail.http?.status)
+      }
+      beforeAll(async () => {
+        diviner = await TemporalIndexingDivinerIndexCandidateToIndexDiviner.create({
+          account: 'random',
+          config: {
+            schema: TemporalIndexingDivinerIndexCandidateToIndexDiviner.defaultConfigSchema,
+            schemaTransforms,
+          },
+        })
+      })
+      const schemaTransforms: SchemaToJsonPathTransformExpressionsDictionary = {
+        'network.xyo.image.thumbnail': [{ destinationField: 'status', sourcePathExpression: '$.http.status' }],
+        'network.xyo.image.thumbnail.other': [{ destinationField: 'url', sourcePathExpression: '$.sourceUrl' }],
+        'network.xyo.timestamp': [{ destinationField: 'timestamp', sourcePathExpression: '$.timestamp' }],
+      }
+      let diviner: TemporalIndexingDivinerIndexCandidateToIndexDiviner
+
+      const cases: [TimeStamp, ImageThumbnail, Payload<{ sourceUrl: string }>][] = [
+        [
+          timestampPayloadA,
+          { ...imageThumbnailPayloadA, sourceUrl: '' },
+          { schema: 'network.xyo.image.thumbnail.other', sourceUrl: imageThumbnailPayloadA.sourceUrl },
+        ],
+        [
+          timestampPayloadB,
+          { ...imageThumbnailPayloadB, sourceUrl: '' },
+          { schema: 'network.xyo.image.thumbnail.other', sourceUrl: imageThumbnailPayloadB.sourceUrl },
+        ],
+        [
+          timestampPayloadC,
+          { ...imageThumbnailPayloadC, sourceUrl: '' },
+          { schema: 'network.xyo.image.thumbnail.other', sourceUrl: imageThumbnailPayloadC.sourceUrl },
+        ],
+      ]
+      describe('with single result', () => {
+        it.each(cases)('transforms single result', async (timestamp, thumbnail, payload) => {
+          const [boundWitness] = await new BoundWitnessBuilder().payloads([timestamp, thumbnail, payload]).build()
+          const result = await diviner.divine([boundWitness, timestamp, thumbnail, payload])
+          await validateMultiResult([boundWitness, timestamp, thumbnail, payload], result)
+        })
+        it.each(cases)('handles sparse inputs', async (thumbnail, timestamp, payload) => {
+          const [boundWitness] = await new BoundWitnessBuilder().payloads([timestamp, thumbnail, payload]).build()
+          expect(await diviner.divine([thumbnail, timestamp])).toBeArrayOfSize(0)
+          expect(await diviner.divine([boundWitness, timestamp])).toBeArrayOfSize(0)
+          expect(await diviner.divine([boundWitness, thumbnail])).toBeArrayOfSize(0)
+        })
+      })
+      describe('with multiple results', () => {
+        it('transforms multiple results', async () => {
+          const data: [BoundWitness, TimeStamp, ImageThumbnail, Payload][] = await Promise.all(
+            cases.map(async (payloads) => {
+              const [bw] = await new BoundWitnessBuilder().payloads(payloads).build()
+              return [bw, ...payloads]
+            }),
+          )
+          const results = await diviner.divine(data.flat())
+          expect(results).toBeArrayOfSize(cases.length)
+
+          await Promise.all(
+            data.map(async (input, i) => {
+              const result = results[i]
+              await validateMultiResult(input, [result])
+            }),
+          )
+        })
+        it('handles sparse inputs', async () => {
+          const [bw] = await new BoundWitnessBuilder().payloads(cases[0]).build()
+          const results = await diviner.divine([bw, ...cases.flat()])
+          expect(results).toBeArrayOfSize(1)
+          await validateMultiResult([bw, ...cases[0]], results)
+        })
+        it('handles missing inputs', async () => {
+          const [bw] = await new BoundWitnessBuilder().payloads([...cases[0]]).build()
+          const results = await diviner.divine([bw, ...cases[0].slice(0, -1)])
+          expect(results).toBeArrayOfSize(0)
+        })
+      })
+    })
+  })
+})

package/src/IndexQueryResponseToDivinerQueryResponseDiviner/spec/Diviner.spec.ts

@@ -0,0 +1,103 @@
+import '@xylabs/vitest-extended'
+
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { Payload } from '@xyo-network/payload-model'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner } from '../Diviner.ts'
+
+type QueryType = Payload<PayloadDivinerQueryPayload & Payload<{ status?: number; success?: boolean; url: string }>>
+
+describe('TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner', () => {
+  const url = 'https://xyo.network'
+  const queries: QueryType[] = [
+    {
+      schema: PayloadDivinerQuerySchema,
+      url,
+    },
+    {
+      schema: PayloadDivinerQuerySchema,
+      url,
+    },
+  ]
+  const indexes = [
+    [
+      {
+        schema: 'TODO',
+        sources: [],
+        status: 200,
+        success: true,
+        timestamp: 1_234_567_890,
+        url,
+      },
+    ],
+    [
+      {
+        schema: 'TODO',
+        sources: [],
+        status: 200,
+        success: true,
+        timestamp: 1_234_567_891,
+        url,
+      },
+      {
+        schema: 'TODO',
+        sources: [],
+        status: 500,
+        success: false,
+        timestamp: 1_234_567_892,
+        url,
+      },
+    ],
+  ]
+  let diviner: TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner
+  beforeAll(async () => {
+    diviner = await TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.create({ account: 'random' })
+  })
+  const cases: [QueryType, Payload[]][] = queries.map((query, i) => [query, indexes[i]])
+  describe('divine', () => {
+    describe('with single url in index result', () => {
+      it.each(cases)('transforms single url index results', async (imageThumbnailDivinerQuery, imageThumbnailResultIndex) => {
+        const results = await diviner.divine([imageThumbnailDivinerQuery, ...imageThumbnailResultIndex])
+        expect(results).toBeArrayOfSize(imageThumbnailResultIndex.length)
+        expect(results).toBeArrayOfSize(imageThumbnailResultIndex.length)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, unicorn/no-array-for-each
+        results.forEach((result: any, i) => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const index = imageThumbnailResultIndex[i] as any
+          expect(result.url).toBe(imageThumbnailDivinerQuery.url)
+          expect(result.success).toBe(index.success)
+          expect(result.timestamp).toBe(index.timestamp)
+          expect(result.status).toBe(index.status)
+          expect(result.schema).toBe('TODO')
+        })
+      })
+    })
+    describe('with multiple urls in index result', () => {
+      it('transforms multiple url index results', async () => {
+        const indexesLength = indexes.flat().length
+        const results = await diviner.divine([...queries, ...indexes.flat()])
+        expect(results).toBeArrayOfSize(indexesLength)
+        expect(results).toBeArrayOfSize(indexesLength)
+        let resultsIterator = 0
+        for (const [i, { url }] of queries.entries()) {
+          const indexSet = indexes[i]
+          for (const index of indexSet) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = results[resultsIterator] as any
+            expect(result.url).toBe(url)
+            expect(result.success).toBe(index.success)
+            expect(result.timestamp).toBe(index.timestamp)
+            expect(result.status).toBe(index.status)
+            expect(result.schema).toBe('TODO')
+            resultsIterator = ++resultsIterator
+          }
+        }
+      })
+    })
+  })
+})

package/src/StateToIndexCandidateDiviner/spec/Diviner.spec.ts

@@ -0,0 +1,167 @@
+import '@xylabs/vitest-extended'
+
+import { filterAs } from '@xylabs/array'
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import type { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import { isBoundWitness } from '@xyo-network/boundwitness-model'
+import type { IndexingDivinerState } from '@xyo-network/diviner-indexing-model'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { ModuleState } from '@xyo-network/module-model'
+import { isModuleState, ModuleStateSchema } from '@xyo-network/module-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import { asOptionalStorageMeta } from '@xyo-network/payload-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { TimeStamp } from '@xyo-network/witness-timestamp'
+import { isTimestamp, TimestampSchema } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { TemporalIndexingDivinerStateToIndexCandidateDiviner } from '../Diviner.ts'
+import TemporalStateToIndexCandidateDivinerManifest from './TemporalStateToIndexCandidateDiviner.json' with { type: 'json' }
+
+/**
+ * @group slow
+ */
+describe('TemporalStateToIndexCandidateDiviner', () => {
+  const sourceUrl = 'https://placekitten.com/200/300'
+  const thumbnailHttpSuccess = {
+    http: { status: 200 },
+    schema: 'network.xyo.image.thumbnail',
+    sourceHash: '7f39363514d9d9b958a5a993edeba35cb44f912c7072ed9ddd628728ac0fd681',
+    sourceUrl,
+    url: 'data:image/png;base64,===',
+  }
+
+  const thumbnailHttpFail = {
+    http: {
+
+      ipAddress: '104.17.96.13',
+      status: 429,
+    },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  const thumbnailCodeFail = {
+    http: { code: 'FAILED' },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  const thumbnailWitnessFail = {
+
+    http: { ipAddress: '104.17.96.13' },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  let testCases: WithStorageMeta<Payload>[][] = []
+  let archivist: MemoryArchivist
+  let sut: TemporalIndexingDivinerStateToIndexCandidateDiviner
+
+  beforeAll(async () => {
+    const wallet = await HDWallet.random()
+    const locator = new ModuleFactoryLocator()
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory())
+    const manifest = TemporalStateToIndexCandidateDivinerManifest as PackageManifestPayload
+    const manifestWrapper = new ManifestWrapper(manifest, wallet, locator)
+    const node = await manifestWrapper.loadNodeFromIndex(0)
+    await node.start()
+
+    const privateModules = manifest.nodes[0].modules?.private ?? []
+    const publicModules = manifest.nodes[0].modules?.public ?? []
+    const mods = await node.resolve('*')
+    expect(mods.length).toBe(privateModules.length + publicModules.length + 1)
+
+    // Insert previously witnessed payloads into thumbnail archivist
+    const httpSuccessTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: 1 }
+    const [httpSuccessBoundWitness, httpSuccessPayloads] = await new BoundWitnessBuilder()
+      .payloads([thumbnailHttpSuccess, httpSuccessTimestamp])
+      .build()
+    const httpFailTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: 2 }
+    const [httpFailBoundWitness, httpFailPayloads] = await (new BoundWitnessBuilder().payloads([thumbnailHttpFail, httpFailTimestamp])).build()
+
+    const witnessFailTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: 3 }
+    const [witnessFailBoundWitness, witnessFailPayloads] = await new BoundWitnessBuilder()
+      .payloads([thumbnailWitnessFail, witnessFailTimestamp])
+      .build()
+
+    const codeFailTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: 4 }
+    const [codeFailBoundWitness, codeFailPayloads] = await (new BoundWitnessBuilder().payloads([thumbnailCodeFail, codeFailTimestamp])).build()
+
+    archivist = assertEx(asArchivistInstance<MemoryArchivist>(await node.resolve('ImageThumbnailArchivist')))
+    const testCasesToCreate = [
+      [httpSuccessBoundWitness, ...httpSuccessPayloads],
+      [httpFailBoundWitness, ...httpFailPayloads],
+      [witnessFailBoundWitness, ...witnessFailPayloads],
+      [codeFailBoundWitness, ...codeFailPayloads],
+    ]
+
+    for (const [bw, ...payloads] of testCasesToCreate) {
+      const createdTestCase = []
+      for (const payload of [bw, ...payloads]) {
+        await delay(2)
+        const [signedPayload] = await archivist.insert([payload])
+        createdTestCase.push(signedPayload)
+      }
+      testCases.push(createdTestCase)
+    }
+
+    sut = assertEx(
+      asDivinerInstance(await node.resolve('TemporalStateToIndexCandidateDiviner')),
+    ) as TemporalIndexingDivinerStateToIndexCandidateDiviner
+  })
+
+  describe('divine', () => {
+    describe('with no previous state', () => {
+      it('returns next state and batch results', async () => {
+        const results = await sut.divine()
+        expect(results.length).toBe(testCases.flat().length + 1)
+        const state = results.find(isModuleState<IndexingDivinerState>)
+        expect(state).toBeDefined()
+        const last = filterAs(results, asOptionalStorageMeta)
+          .map(p => p as WithStorageMeta<Payload>)
+          .sort(PayloadBuilder.compareStorageMeta)
+          .at(-1)
+        expect(last).toBeDefined()
+        expect(state?.state.cursor).toBe(last?._sequence)
+      })
+    })
+    describe('with previous state', () => {
+      it.each([1, 2, 3])('returns next state and batch results', async (batch) => {
+        const all = (await archivist.all()).sort(PayloadBuilder.compareStorageMeta)
+        const batchOffset = all.at((3 * batch) - 1)
+        expect(batchOffset).toBeDefined()
+        // Test across all offsets
+        const cursor = assertEx(batchOffset)._sequence
+        const lastState: ModuleState<IndexingDivinerState> = { schema: ModuleStateSchema, state: { cursor } }
+        const results = await sut.divine([lastState])
+
+        // Validate expected results length
+        // [BW, ImageThumbnail, TimeStamp] + 1 [ModuleState]
+        const expectedResults = testCases.slice(batch).flat().length + 1
+        expect(results.length).toBe(expectedResults)
+
+        // Validate expected state
+        const nextState = results.find(isModuleState<IndexingDivinerState>)
+        expect(nextState).toBeDefined()
+        expect(nextState?.state?.cursor).toBeDefined()
+        expect(nextState?.state.cursor).toBe(testCases?.at(-1)?.at(-1)?._sequence)
+
+        // Validate expected individual results
+        const bws = results.filter(isBoundWitness)
+        expect(bws.length).toBeGreaterThan(0)
+        const timestamps = results.filter(isTimestamp)
+        expect(timestamps.length).toBeGreaterThan(0)
+      })
+    })
+  })
+})

package/src/spec/Diviner.Multiple.spec.ts

@@ -0,0 +1,214 @@
+import '@xylabs/vitest-extended'
+
+import { filterAs } from '@xylabs/array'
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import { AsObjectFactory } from '@xylabs/object'
+import type { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import { asBoundWitness } from '@xyo-network/boundwitness-model'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import { isTemporalIndexingDivinerResultIndex } from '@xyo-network/diviner-temporal-indexing-model'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type {
+  Labels, ModuleState, StateDictionary,
+} from '@xyo-network/module-model'
+import { isModuleState } from '@xyo-network/module-model'
+import type { MemoryNode } from '@xyo-network/node-memory'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { TimeStamp } from '@xyo-network/witness-timestamp'
+import { TimestampSchema } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { TemporalIndexingDiviner } from '../Diviner.ts'
+import { TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner } from '../DivinerQueryToIndexQueryDiviner/index.ts'
+import { TemporalIndexingDivinerIndexCandidateToIndexDiviner } from '../IndexCandidateToIndexDiviner/index.ts'
+import { TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner } from '../IndexQueryResponseToDivinerQueryResponseDiviner/index.ts'
+import { TemporalIndexingDivinerStateToIndexCandidateDiviner } from '../StateToIndexCandidateDiviner/index.ts'
+import imageThumbnailDivinerManifest from './TemporalDiviner.json' with { type: 'json' }
+
+type ImageThumbnail = Payload<{
+  http?: {
+    code?: string
+    ipAddress?: string
+    status?: number
+  }
+  // schema: 'network.xyo.image.thumbnail'
+  sourceHash?: string
+  sourceUrl: string
+  url?: string
+}>
+
+type Query = PayloadDivinerQueryPayload & { status?: number; success?: boolean; url?: string }
+
+/**
+ * @group slow
+ */
+describe('TemporalIndexingDiviner - Multiple', () => {
+  const sourceUrl = 'https://placekitten.com/200/300'
+  const thumbnailHttpSuccess: ImageThumbnail = {
+    http: { status: 200 },
+    schema: 'network.xyo.image.thumbnail',
+    sourceHash: '7f39363514d9d9b958a5a993edeba35cb44f912c7072ed9ddd628728ac0fd681',
+    sourceUrl,
+    url: 'data:image/png;base64,===',
+  }
+
+  const thumbnailHttpFail: ImageThumbnail = {
+    http: {
+
+      ipAddress: '104.17.96.13',
+      status: 429,
+    },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  const thumbnailCodeFail: ImageThumbnail = {
+    http: { code: 'FAILED' },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  const thumbnailWitnessFail: ImageThumbnail = {
+
+    http: { ipAddress: '104.17.96.13' },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+  const witnessedThumbnails = [thumbnailHttpSuccess, thumbnailHttpFail, thumbnailCodeFail, thumbnailWitnessFail]
+
+  let sut: TemporalIndexingDiviner
+  let node: MemoryNode
+
+  beforeAll(async () => {
+    const labels: Labels = { 'network.xyo.image.thumbnail': 'diviner' }
+    const wallet = await HDWallet.random()
+    const locator = new ModuleFactoryLocator()
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory(), labels)
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory(), labels)
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory(), labels)
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory(), labels)
+    locator.register(TemporalIndexingDiviner.factory(), labels)
+    const manifest = imageThumbnailDivinerManifest as PackageManifestPayload
+    const manifestWrapper = new ManifestWrapper(manifest, wallet, locator)
+    node = await manifestWrapper.loadNodeFromIndex(0)
+    await node.start()
+
+    // Insert previously witnessed payloads into thumbnail archivist
+    const timestamp: TimeStamp = { schema: TimestampSchema, timestamp: Date.now() }
+    const [boundWitness, payloads] = await new BoundWitnessBuilder().payloads([timestamp, ...witnessedThumbnails]).build()
+
+    const thumbnailArchivist = assertEx(asArchivistInstance<MemoryArchivist>(await node.resolve('ImageThumbnailArchivist')))
+    await thumbnailArchivist.insert([boundWitness, ...payloads])
+
+    sut = assertEx(asDivinerInstance(await node.resolve('ImageThumbnailDiviner'))) as TemporalIndexingDiviner
+
+    // Allow enough time for diviner to divine
+    await delay(1000)
+  }, 40_000)
+  describe('diviner state', () => {
+    let stateArchivist: MemoryArchivist
+    beforeAll(async () => {
+      const mod = await node.resolve('AddressStateArchivist')
+      stateArchivist = assertEx(asArchivistInstance<MemoryArchivist>(mod))
+    })
+    it('has expected bound witnesses', async () => {
+      const payloads = await stateArchivist.all()
+      const stateBoundWitnesses = filterAs(payloads, asBoundWitness)
+      expect(stateBoundWitnesses).toBeArrayOfSize(1)
+      for (const stateBoundWitness of stateBoundWitnesses) {
+        expect(stateBoundWitness).toBeObject()
+        expect(stateBoundWitness.addresses).toBeArrayOfSize(1)
+        expect(stateBoundWitness.addresses).toContain(sut.address)
+      }
+    })
+    it('has expected state', async () => {
+      const payloads = await stateArchivist.all()
+      try {
+        const asModuleState = AsObjectFactory.create<ModuleState<StateDictionary>>(isModuleState)
+        const statePayloads = filterAs(payloads, asModuleState)
+        expect(statePayloads).toBeArrayOfSize(1)
+        expect(statePayloads.at(-1)).toBeObject()
+        const statePayload = assertEx(statePayloads.at(-1))
+        expect(statePayload.state).toBeObject()
+        expect(statePayload.state?.cursor).toBeDefined()
+      } catch (ex) {
+        console.error('State payloads:', payloads)
+        throw ex
+      }
+    })
+  })
+  describe('diviner index', () => {
+    let indexArchivist: MemoryArchivist
+    beforeAll(async () => {
+      const mod = await node.resolve('ImageThumbnailDivinerIndexArchivist')
+      indexArchivist = assertEx(asArchivistInstance<MemoryArchivist>(mod))
+    })
+    // NOTE: We're not signing indexes for performance reasons
+    it.skip('has expected bound witnesses', async () => {
+      const payloads = await indexArchivist.all()
+      const indexBoundWitnesses = filterAs(payloads, asBoundWitness)
+      expect(indexBoundWitnesses).toBeArrayOfSize(1)
+      const indexBoundWitness = indexBoundWitnesses[0]
+      expect(indexBoundWitness).toBeObject()
+      expect(indexBoundWitness.addresses).toBeArrayOfSize(1)
+      expect(indexBoundWitness.addresses).toContain(sut.address)
+    })
+    it('has expected index', async () => {
+      const payloads = await indexArchivist.all()
+      const indexPayloads = payloads.filter(isTemporalIndexingDivinerResultIndex)
+      expect(indexPayloads).toBeArrayOfSize((witnessedThumbnails).length)
+    })
+  })
+  describe('with no thumbnail for the provided URL', () => {
+    const url = 'https://does.not.exist.io'
+    const schema = PayloadDivinerQuerySchema
+    it('returns nothing', async () => {
+      const query: Query = { schema, url }
+      const result = await sut.divine([query])
+      expect(result).toBeArrayOfSize(0)
+    })
+  })
+  describe('with thumbnails for the provided URL', () => {
+    const url = sourceUrl
+    const schema = PayloadDivinerQuerySchema
+    describe('with no filter criteria', () => {
+      it('returns the most recent result', async () => {
+        const query: Query = { schema, url }
+        const results = await sut.divine([query])
+        const result = results.find(isTemporalIndexingDivinerResultIndex)
+        expect(result).toBeDefined()
+        const payload = assertEx((witnessedThumbnails).at(-1))
+        const expected = await PayloadBuilder.dataHash(payload)
+        expect(result?.$sources).toContain(expected)
+      })
+    })
+    describe('with filter criteria', () => {
+      describe('for status code', () => {
+        const cases: ImageThumbnail[] = [thumbnailHttpSuccess, thumbnailHttpFail]
+        it.each(cases)('returns the most recent instance of that status code', async (payload) => {
+          const { status } = payload.http ?? {}
+          const query: Query = {
+            schema, status, url,
+          }
+          const results = await sut.divine([query])
+          const result = results.find(isTemporalIndexingDivinerResultIndex)
+          expect(result).toBeDefined()
+          const expected = await PayloadBuilder.dataHash(payload)
+          expect(result?.$sources).toContain(expected)
+        })
+      })
+    })
+  })
+})

package/src/spec/Diviner.spec.ts

@@ -0,0 +1,225 @@
+import '@xylabs/vitest-extended'
+
+import { filterAs } from '@xylabs/array'
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import type { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import { asBoundWitness } from '@xyo-network/boundwitness-model'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import { isTemporalIndexingDivinerResultIndex } from '@xyo-network/diviner-temporal-indexing-model'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { Labels } from '@xyo-network/module-model'
+import { asModuleState } from '@xyo-network/module-model'
+import type { MemoryNode } from '@xyo-network/node-memory'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { TimeStamp } from '@xyo-network/witness-timestamp'
+import { TimestampSchema } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { TemporalIndexingDiviner } from '../Diviner.ts'
+import { TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner } from '../DivinerQueryToIndexQueryDiviner/index.ts'
+import { TemporalIndexingDivinerIndexCandidateToIndexDiviner } from '../IndexCandidateToIndexDiviner/index.ts'
+import { TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner } from '../IndexQueryResponseToDivinerQueryResponseDiviner/index.ts'
+import { TemporalIndexingDivinerStateToIndexCandidateDiviner } from '../StateToIndexCandidateDiviner/index.ts'
+import imageThumbnailDivinerManifest from './TemporalDiviner.json' with { type: 'json' }
+
+type ImageThumbnail = Payload<{
+  http?: {
+    code?: string
+    ipAddress?: string
+    status?: number
+  }
+  // schema: 'network.xyo.image.thumbnail'
+  sourceHash?: string
+  sourceUrl: string
+  url?: string
+}>
+
+type Query = PayloadDivinerQueryPayload & { status?: number; success?: boolean; url?: string }
+
+/**
+ * @group slow
+ */
+describe('TemporalIndexingDiviner', () => {
+  const sourceUrl = 'https://placekitten.com/200/300'
+  const thumbnailHttpSuccess: ImageThumbnail = {
+    http: { status: 200 },
+    schema: 'network.xyo.image.thumbnail',
+    sourceHash: '7f39363514d9d9b958a5a993edeba35cb44f912c7072ed9ddd628728ac0fd681',
+    sourceUrl,
+    url: 'data:image/png;base64,===',
+  }
+
+  const thumbnailHttpFail: ImageThumbnail = {
+    http: {
+
+      ipAddress: '104.17.96.13',
+      status: 429,
+    },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  const thumbnailCodeFail: ImageThumbnail = {
+    http: { code: 'FAILED' },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+
+  const thumbnailWitnessFail: ImageThumbnail = {
+
+    http: { ipAddress: '104.17.96.13' },
+    schema: 'network.xyo.image.thumbnail',
+    sourceUrl,
+  }
+  const witnessedThumbnails = [thumbnailHttpSuccess, thumbnailHttpFail, thumbnailCodeFail, thumbnailWitnessFail]
+
+  let sut: TemporalIndexingDiviner
+  let node: MemoryNode
+
+  beforeAll(async () => {
+    const labels: Labels = { 'network.xyo.image.thumbnail': 'diviner' }
+    const wallet = await HDWallet.random()
+    const locator = new ModuleFactoryLocator()
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory(), labels)
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory(), labels)
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory(), labels)
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory(), labels)
+    locator.register(TemporalIndexingDiviner.factory(), labels)
+    const manifest = imageThumbnailDivinerManifest as PackageManifestPayload
+    const manifestWrapper = new ManifestWrapper(manifest, wallet, locator)
+    node = await manifestWrapper.loadNodeFromIndex(0)
+    await node.start()
+
+    // Insert previously witnessed payloads into thumbnail archivist
+    const httpSuccessTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: Date.now() }
+    const [httpSuccessBoundWitness, httpSuccessPayloads] = await new BoundWitnessBuilder()
+      .payloads([thumbnailHttpSuccess, httpSuccessTimestamp])
+      .build()
+    const httpFailTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: Date.now() }
+    const [httpFailBoundWitness, httpFailPayloads] = await new BoundWitnessBuilder().payloads([thumbnailHttpFail, httpFailTimestamp]).build()
+
+    const witnessFailTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: Date.now() }
+    const [witnessFailBoundWitness, witnessFailPayloads] = await new BoundWitnessBuilder()
+      .payloads([thumbnailWitnessFail, witnessFailTimestamp])
+      .build()
+
+    const codeFailTimestamp: TimeStamp = { schema: TimestampSchema, timestamp: Date.now() }
+    const [codeFailBoundWitness, codeFailPayloads] = await new BoundWitnessBuilder().payloads([thumbnailCodeFail, codeFailTimestamp]).build()
+
+    const thumbnailArchivist = assertEx(asArchivistInstance<MemoryArchivist>(await node.resolve('ImageThumbnailArchivist')))
+    await thumbnailArchivist.insert([
+      httpSuccessBoundWitness,
+      ...httpSuccessPayloads,
+      httpFailBoundWitness,
+      ...httpFailPayloads,
+      witnessFailBoundWitness,
+      ...witnessFailPayloads,
+      codeFailBoundWitness,
+      ...codeFailPayloads,
+    ])
+
+    sut = assertEx(asDivinerInstance(await node.resolve('ImageThumbnailDiviner'))) as TemporalIndexingDiviner
+
+    // Allow enough time for diviner to divine
+    await delay(1000)
+  }, 40_000)
+  describe('diviner state', () => {
+    let stateArchivist: MemoryArchivist
+    beforeAll(async () => {
+      const mod = await node.resolve('AddressStateArchivist')
+      stateArchivist = assertEx(asArchivistInstance<MemoryArchivist>(mod))
+    })
+    it('has expected bound witnesses', async () => {
+      const payloads = await stateArchivist.all()
+      const stateBoundWitnesses = filterAs(payloads, asBoundWitness)
+      expect(stateBoundWitnesses).toBeArrayOfSize(1)
+      for (const stateBoundWitness of stateBoundWitnesses) {
+        expect(stateBoundWitness).toBeObject()
+        expect(stateBoundWitness.addresses).toBeArrayOfSize(1)
+        expect(stateBoundWitness.addresses).toContain(sut.address)
+      }
+    })
+    it('has expected state', async () => {
+      const payloads = await stateArchivist.all()
+      const statePayloads = filterAs(payloads, asModuleState)
+      expect(statePayloads).toBeArrayOfSize(1)
+      expect(statePayloads.at(-1)).toBeObject()
+      const statePayload = assertEx(statePayloads.at(-1))
+      expect(statePayload.state).toBeObject()
+      expect(statePayload.state?.cursor).toBeDefined()
+    })
+  })
+  describe('diviner index', () => {
+    let indexArchivist: MemoryArchivist
+    beforeAll(async () => {
+      const mod = await node.resolve('ImageThumbnailDivinerIndexArchivist')
+      indexArchivist = assertEx(asArchivistInstance<MemoryArchivist>(mod))
+    })
+    // NOTE: We're not signing indexes for performance reasons
+    it.skip('has expected bound witnesses', async () => {
+      const payloads = await indexArchivist.all()
+      const indexBoundWitnesses = filterAs(payloads, asBoundWitness)
+      expect(indexBoundWitnesses).toBeArrayOfSize(1)
+      const indexBoundWitness = indexBoundWitnesses[0]
+      expect(indexBoundWitness).toBeObject()
+      expect(indexBoundWitness.addresses).toBeArrayOfSize(1)
+      expect(indexBoundWitness.addresses).toContain(sut.address)
+    })
+    it('has expected index', async () => {
+      const payloads = await indexArchivist.all()
+      const indexPayloads = payloads.filter(isTemporalIndexingDivinerResultIndex)
+      expect(indexPayloads).toBeArrayOfSize(witnessedThumbnails.length)
+    })
+  })
+  describe('with no thumbnail for the provided URL', () => {
+    const url = 'https://does.not.exist.io'
+    const schema = PayloadDivinerQuerySchema
+    it('returns nothing', async () => {
+      const query: Query = { schema, url }
+      const result = await sut.divine([query])
+      expect(result).toBeArrayOfSize(0)
+    })
+  })
+  describe('with thumbnails for the provided URL', () => {
+    const url = sourceUrl
+    const schema = PayloadDivinerQuerySchema
+    describe('with no filter criteria', () => {
+      it('returns the most recent result', async () => {
+        const query: Query = { schema, url }
+        const results = await sut.divine([query])
+        const result = results.find(isTemporalIndexingDivinerResultIndex)
+        expect(result).toBeDefined()
+        const expected = await PayloadBuilder.dataHash(thumbnailCodeFail)
+        expect(result?.$sources).toContain(expected)
+      })
+    })
+    describe('with filter criteria', () => {
+      describe('for status code', () => {
+        const cases: ImageThumbnail[] = [thumbnailHttpSuccess, thumbnailHttpFail]
+        it.each(cases)('returns the most recent instance of that status code', async (payload) => {
+          const { status } = payload.http ?? {}
+          const query: Query = {
+            schema, status, url,
+          }
+          const results = await sut.divine([query])
+          const result = results.find(isTemporalIndexingDivinerResultIndex)
+          expect(result).toBeDefined()
+          const expected = await PayloadBuilder.dataHash(payload)
+          expect(result?.$sources).toContain(expected)
+        })
+      })
+    })
+  })
+})