@xyo-network/diviner-temporal-indexing-memory 2.80.0-rc.1

package/src/IndexCandidateToIndexDiviner/Diviner.ts

@@ -0,0 +1,144 @@
+import { containsAll } from '@xylabs/array'
+import { assertEx } from '@xylabs/assert'
+import { exists } from '@xylabs/exists'
+import { AbstractDiviner } from '@xyo-network/abstract-diviner'
+import { BoundWitness, isBoundWitness } from '@xyo-network/boundwitness-model'
+import { PayloadHasher } from '@xyo-network/core'
+import { DivinerConfigSchema } from '@xyo-network/diviner-model'
+import { TemporalIndexingDivinerResultIndexSchema } from '@xyo-network/diviner-temporal-indexing-model'
+import { Labels } from '@xyo-network/module-model'
+import { Payload } from '@xyo-network/payload-model'
+import { isTimestamp, TimeStamp, TimestampSchema } from '@xyo-network/witness-timestamp'
+import jsonpath from 'jsonpath'
+
+import { PayloadTransformer, StringToJsonPathTransformExpressionsDictionary, StringToPayloadTransformersDictionary } from '../lib'
+import { TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema } from './Config'
+import { TemporalIndexCandidateToIndexDivinerParams } from './Params'
+
+export type IndexablePayloads = [BoundWitness, TimeStamp, ...Payload[]]
+
+const moduleName = 'TemporalIndexingDivinerIndexCandidateToIndexDiviner'
+
+/**
+ * Transforms candidates for image thumbnail indexing into their indexed representation
+ */
+export class TemporalIndexingDivinerIndexCandidateToIndexDiviner<
+  TParams extends TemporalIndexCandidateToIndexDivinerParams = TemporalIndexCandidateToIndexDivinerParams,
+> extends AbstractDiviner<TParams, Payload, Payload> {
+  static override configSchema = TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema
+  static override configSchemas = [DivinerConfigSchema, TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema]
+  static labels: Labels = {
+    'network.xyo.diviner.stage': 'indexCandidateToIndexDiviner',
+  }
+
+  private _indexableSchemas: string[] | undefined
+  private _schemaToPayloadTransformersDictionary: StringToPayloadTransformersDictionary | undefined
+
+  /**
+   * List of indexable schemas for this diviner
+   */
+  protected get indexableSchemas() {
+    // Return the computed result if we've calculated it before as the config
+    // shouldn't change after initialization
+    if (this._indexableSchemas) return this._indexableSchemas
+    this._indexableSchemas = [...Object.keys(this.schemaTransforms)]
+    return this._indexableSchemas
+  }
+
+  /**
+   * Dictionary of schemas to payload transformers for creating indexes
+   * from the payloads within a Bound Witness
+   */
+  protected get schemaToPayloadTransformersDictionary(): StringToPayloadTransformersDictionary {
+    // Return the computed result if we've calculated it before as the config
+    // shouldn't change after initialization
+    if (this._schemaToPayloadTransformersDictionary) return this._schemaToPayloadTransformersDictionary
+    this._schemaToPayloadTransformersDictionary = Object.fromEntries(
+      Object.entries(this.schemaTransforms).map(([schema, jsonPathTransformerExpressions]) => {
+        const transformers = jsonPathTransformerExpressions.map((transformExpression) => {
+          const { sourcePathExpression, destinationField } = transformExpression
+          const transformer: PayloadTransformer = (x: Payload) => {
+            // eslint-disable-next-line import/no-named-as-default-member
+            const source = jsonpath.value(x, sourcePathExpression)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const transformed = {} as { [key: string]: any }
+            transformed[destinationField] = source
+            return transformed
+          }
+          return transformer
+        })
+        return [schema, transformers]
+      }),
+    )
+    return this._schemaToPayloadTransformersDictionary
+  }
+
+  /**
+   * The dictionary of schemas to JSON Path transform expressions for creating indexes
+   * from the payloads within a Bound Witness
+   */
+  protected get schemaTransforms(): StringToJsonPathTransformExpressionsDictionary {
+    return assertEx(this.config?.schemaTransforms, () => `${moduleName}: Missing config.schemaTransforms section`)
+  }
+
+  protected override async divineHandler(payloads: Payload[] = []): Promise<Payload[]> {
+    const bws: BoundWitness[] = payloads.filter(isBoundWitness)
+    const timestampPayloads: TimeStamp[] = payloads.filter(isTimestamp)
+    const indexablePayloads: Payload[] = payloads.filter((p) => this.isIndexablePayload(p))
+    if (bws.length && timestampPayloads.length && indexablePayloads.length) {
+      const payloadDictionary = await PayloadHasher.toMap(payloads)
+      const validIndexableTuples: IndexablePayloads[] = bws.reduce<IndexablePayloads[]>((indexableTuples, bw) => {
+        // If this Bound Witness doesn't contain all the required schemas don't index it
+        if (!containsAll(bw.payload_schemas, this.indexableSchemas)) return indexableTuples
+        // Find the timestamp
+        const timestampPosition = bw.payload_schemas?.findIndex((schema) => schema === TimestampSchema)
+        const timestampHash = bw.payload_hashes?.[timestampPosition]
+        const timestamp = [payloadDictionary[timestampHash]].find(isTimestamp)
+        // Find the remaining indexable payloads
+        const indexablePayloadPositions = this.indexableSchemas.map((schema) => bw.payload_schemas.indexOf(schema))
+        const indexablePayloadHashes = indexablePayloadPositions.map((index) => bw.payload_hashes?.[index])
+        const indexablePayloads = indexablePayloadHashes.map((hash) => payloadDictionary[hash]).filter(exists)
+        // If we found a timestamp and the right amount of indexable payloads (of the
+        // correct schema as checked above) in this BW, then index it
+        if (timestamp && indexablePayloads.length === this.indexableSchemas.length) indexableTuples.push([bw, timestamp, ...indexablePayloads])
+        return indexableTuples
+      }, [])
+      // Create the indexes from the tuples
+      const indexes = await Promise.all(
+        validIndexableTuples.map(async ([bw, timestampPayload, ...remainingPayloads]) => {
+          const partials = remainingPayloads
+            .map((payload) => {
+              const transforms = this.schemaToPayloadTransformersDictionary[payload.schema]
+              const transformed: Partial<Payload>[] = transforms.map((transform) => transform(payload))
+              return transformed
+            })
+            .flat()
+          const transformed = Object.assign({}, ...partials, { schema: TemporalIndexingDivinerResultIndexSchema })
+          const { timestamp } = timestampPayload
+          const sources = (await PayloadHasher.hashPairs([bw, timestampPayload, ...remainingPayloads])).map(([, hash]) => hash)
+          return [{ ...transformed, sources, timestamp }]
+        }),
+      )
+      return indexes.flat()
+    }
+    return Promise.resolve([])
+  }
+
+  /**
+   * Identifies if a payload is one that is indexed by this diviner
+   * @param x The candidate payload
+   * @returns True if the payload is one indexed by this diviner, false otherwise
+   */
+  protected isIndexablePayload = (x: Payload) => {
+    return this.indexableSchemas.includes(x?.schema)
+  }
+
+  /**
+   * Identifies if a schema is one that is indexed by this diviner
+   * @param schema The candidate schema
+   * @returns True if this schema is one indexed by this diviner, false otherwise
+   */
+  protected isIndexableSchema = (schema?: string | null) => {
+    return this.indexableSchemas.some((s) => s === schema)
+  }
+}

package/src/IndexCandidateToIndexDiviner/Params.ts

@@ -0,0 +1,6 @@
+import { DivinerParams } from '@xyo-network/diviner-model'
+import { AnyConfigSchema } from '@xyo-network/module-model'
+
+import { TemporalIndexingDivinerIndexCandidateToIndexDivinerConfig } from './Config'
+
+export type TemporalIndexCandidateToIndexDivinerParams = DivinerParams<AnyConfigSchema<TemporalIndexingDivinerIndexCandidateToIndexDivinerConfig>>

package/src/IndexCandidateToIndexDiviner/Schema.ts

@@ -0,0 +1,4 @@
+import { TemporalIndexingDivinerSchema } from '@xyo-network/diviner-temporal-indexing-model'
+
+export type TemporalIndexingDivinerIndexCandidateToIndexDivinerSchema = `${TemporalIndexingDivinerSchema}.stage.indexCandidateToIndexDiviner`
+export const TemporalIndexingDivinerIndexCandidateToIndexDivinerSchema: TemporalIndexingDivinerIndexCandidateToIndexDivinerSchema = `${TemporalIndexingDivinerSchema}.stage.indexCandidateToIndexDiviner`

package/src/IndexCandidateToIndexDiviner/index.ts

@@ -0,0 +1,4 @@
+export * from './Config'
+export * from './Diviner'
+export * from './Params'
+export * from './Schema'

package/src/IndexQueryResponseToDivinerQueryResponseDiviner.ts

@@ -0,0 +1,21 @@
+import { AbstractDiviner } from '@xyo-network/abstract-diviner'
+import { DivinerConfigSchema } from '@xyo-network/diviner-model'
+import { isPayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { Labels } from '@xyo-network/module-model'
+import { Payload } from '@xyo-network/payload-model'
+
+/**
+ * Transforms an ImageThumbnailIndex response into an ImageThumbnailResponse response
+ */
+export class TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner extends AbstractDiviner {
+  static override configSchemas = [DivinerConfigSchema]
+  static labels: Labels = {
+    'network.xyo.diviner.stage': 'indexQueryResponseToDivinerQueryResponseDiviner',
+  }
+
+  protected override async divineHandler(payloads: Payload[] = []): Promise<Payload[]> {
+    await Promise.resolve()
+    const imageThumbnailDivinerQueries = payloads.filter(isPayloadDivinerQueryPayload)
+    return imageThumbnailDivinerQueries
+  }
+}

package/src/StateToIndexCandidateDiviner/Config.ts

@@ -0,0 +1,21 @@
+import { BoundWitnessDivinerPredicate } from '@xyo-network/diviner-boundwitness-model'
+import { SearchableStorage } from '@xyo-network/diviner-indexing-model'
+import { DivinerConfig } from '@xyo-network/diviner-model'
+
+import { TemporalStateToIndexCandidateDivinerSchema } from './Schema'
+
+export type TemporalStateToIndexCandidateDivinerConfigSchema = `${TemporalStateToIndexCandidateDivinerSchema}.config`
+export const TemporalStateToIndexCandidateDivinerConfigSchema: TemporalStateToIndexCandidateDivinerConfigSchema = `${TemporalStateToIndexCandidateDivinerSchema}.config`
+
+export type TemporalStateToIndexCandidateDivinerConfig = DivinerConfig<{
+  /**
+   * The filter to use to identify index candidates
+   */
+  filter: BoundWitnessDivinerPredicate
+  payloadDivinerLimit?: number
+  /**
+   * Where the diviner should look for stored thumbnails
+   */
+  payloadStore?: SearchableStorage
+  schema: TemporalStateToIndexCandidateDivinerConfigSchema
+}>

package/src/StateToIndexCandidateDiviner/Diviner.ts

@@ -0,0 +1,128 @@
+import { assertEx } from '@xylabs/assert'
+import { exists } from '@xylabs/exists'
+import { AbstractDiviner } from '@xyo-network/abstract-diviner'
+import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
+import { BoundWitness, isBoundWitness } from '@xyo-network/boundwitness-model'
+import { BoundWitnessDivinerQueryPayload, BoundWitnessDivinerQuerySchema } from '@xyo-network/diviner-boundwitness-model'
+import { IndexingDivinerState } from '@xyo-network/diviner-indexing-model'
+import { DivinerConfigSchema } from '@xyo-network/diviner-model'
+import { DivinerWrapper } from '@xyo-network/diviner-wrapper'
+import { isModuleState, Labels, ModuleState, ModuleStateSchema } from '@xyo-network/module-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { isPayloadOfSchemaType, Payload } from '@xyo-network/payload-model'
+import { TimeStamp, TimestampSchema } from '@xyo-network/witness-timestamp'
+
+import { TemporalStateToIndexCandidateDivinerConfigSchema } from './Config'
+import { TemporalStateToIndexCandidateDivinerParams as TemporalIndexingDivinerStateToIndexCandidateDiviner } from './Params'
+
+/**
+ * All Payload types involved in index candidates for indexing
+ */
+export type IndexCandidate = BoundWitness | Payload | TimeStamp
+
+/**
+ * The response from the TemporalStateToIndexCandidateDiviner
+ */
+export type TemporalStateToIndexCandidateDivinerResponse = [
+  /**
+   * The next state of the diviner
+   */
+  nextState: ModuleState<IndexingDivinerState>,
+  /**
+   * The index candidates
+   */
+  ...IndexCandidate[],
+]
+
+/**
+ * The default order to search Bound Witnesses to identify index candidates
+ */
+const order = 'asc'
+
+/**
+ * The name of the module (for logging purposes)
+ */
+const moduleName = 'TemporalStateToIndexCandidateDiviner'
+
+/**
+ * Transforms candidates for image thumbnail indexing into their indexed representation
+ */
+export class TemporalStateToIndexCandidateDiviner<
+  TParams extends TemporalIndexingDivinerStateToIndexCandidateDiviner = TemporalIndexingDivinerStateToIndexCandidateDiviner,
+> extends AbstractDiviner<TParams> {
+  static override configSchemas = [DivinerConfigSchema, TemporalStateToIndexCandidateDivinerConfigSchema]
+  static labels: Labels = {
+    'network.xyo.diviner.stage': 'stateToIndexCandidateDiviner',
+  }
+
+  get payloadDivinerLimit() {
+    return this.config.payloadDivinerLimit ?? 1_000
+  }
+
+  /**
+   * The required payload_schemas within BoundWitnesses to identify index candidates
+   */
+  protected get payload_schemas(): string[] {
+    const schemas = this.config.filter?.payload_schemas
+    return [TimestampSchema, ...(schemas ?? [])]
+  }
+
+  protected override async divineHandler(payloads: Payload[] = []): Promise<[ModuleState, ...IndexCandidate[]]> {
+    // Retrieve the last state from what was passed in
+    const lastState = payloads.find(isModuleState<IndexingDivinerState>)
+    // If there is no last state, start from the beginning
+    if (!lastState) return [{ schema: ModuleStateSchema, state: { offset: 0 } }]
+    // Otherwise, get the last offset
+    const { offset } = lastState.state
+    // Get next batch of results starting from the offset
+    const boundWitnessDiviner = await this.getBoundWitnessDivinerForStore()
+    const query = new PayloadBuilder<BoundWitnessDivinerQueryPayload>({ schema: BoundWitnessDivinerQuerySchema })
+      .fields({ limit: this.payloadDivinerLimit, offset, order, payload_schemas: this.payload_schemas })
+      .build()
+    const batch = await boundWitnessDiviner.divine([query])
+    if (batch.length === 0) return [lastState]
+    // Get source data
+    const sourceArchivist = await this.getArchivistForStore()
+    const indexCandidates: IndexCandidate[] = (
+      await Promise.all(batch.filter(isBoundWitness).map((bw) => this.getPayloadsInBoundWitness(bw, sourceArchivist)))
+    )
+      .filter(exists)
+      .flat()
+    const nextState = { schema: ModuleStateSchema, state: { ...lastState.state, offset: offset + batch.length } }
+    return [nextState, ...indexCandidates]
+  }
+  /**
+   * Retrieves the archivist for the payloadStore
+   * @returns The archivist for the payloadStore
+   */
+  protected async getArchivistForStore() {
+    const name: string = assertEx(this.config?.payloadStore?.archivist, () => `${moduleName}: Config for payloadStore.archivist not specified`)
+    const mod = assertEx(await this.resolve(name), () => `${moduleName}: Failed to resolve payloadStore.archivist`)
+    return ArchivistWrapper.wrap(mod, this.account)
+  }
+
+  /**
+   * Retrieves the BoundWitness Diviner for the payloadStore
+   * @returns The BoundWitness Diviner for the payloadStore
+   */
+  protected async getBoundWitnessDivinerForStore() {
+    const name: string = assertEx(
+      this.config?.payloadStore?.boundWitnessDiviner,
+      () => `${moduleName}: Config for payloadStore.boundWitnessDiviner not specified`,
+    )
+    const mod = assertEx(await this.resolve(name), () => `${moduleName}: Failed to resolve payloadStore.boundWitnessDiviner`)
+    return DivinerWrapper.wrap(mod, this.account)
+  }
+
+  protected async getPayloadsInBoundWitness(bw: BoundWitness, archivist: ArchivistInstance): Promise<IndexCandidate[] | undefined> {
+    const indexes = this.payload_schemas.map((schema) => bw.payload_schemas?.findIndex((s) => s === schema))
+    const hashes = indexes.map((index) => bw.payload_hashes?.[index])
+    const results = await archivist.get(hashes)
+    const indexCandidateIdentityFunctions = this.payload_schemas.map(isPayloadOfSchemaType)
+    const filteredResults = indexCandidateIdentityFunctions.map((is) => results.find(is))
+    if (filteredResults.some((f) => f === undefined)) return undefined
+    const indexCandidates: IndexCandidate[] = filteredResults.filter(exists) as IndexCandidate[]
+    return [bw, ...indexCandidates]
+  }
+}

package/src/StateToIndexCandidateDiviner/Params.ts

@@ -0,0 +1,6 @@
+import { DivinerParams } from '@xyo-network/diviner-model'
+import { AnyConfigSchema } from '@xyo-network/module-model'
+
+import { TemporalStateToIndexCandidateDivinerConfig } from './Config'
+
+export type TemporalStateToIndexCandidateDivinerParams = DivinerParams<AnyConfigSchema<TemporalStateToIndexCandidateDivinerConfig>>

package/src/StateToIndexCandidateDiviner/Schema.ts

@@ -0,0 +1,4 @@
+import { TemporalIndexingDivinerSchema } from '@xyo-network/diviner-temporal-indexing-model'
+
+export type TemporalStateToIndexCandidateDivinerSchema = `${TemporalIndexingDivinerSchema}.stage.stateToIndexCandidateDiviner`
+export const TemporalStateToIndexCandidateDivinerSchema: TemporalStateToIndexCandidateDivinerSchema = `${TemporalIndexingDivinerSchema}.stage.stateToIndexCandidateDiviner`

package/src/StateToIndexCandidateDiviner/index.ts

@@ -0,0 +1 @@
+export * from './Diviner'

package/src/StateToIndexCandidateDiviner/spec/TemporalStateToIndexCandidateDiviner.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  "nodes": [
+    {
+      "config": {
+        "name": "DivinerTest",
+        "schema": "network.xyo.node.config"
+      },
+      "modules": {
+        "public": [
+          {
+            "config": {
+              "language": "javascript",
+              "name": "ImageThumbnailArchivist",
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "ImageThumbnailArchivist",
+              "language": "javascript",
+              "name": "ImageThumbnailBoundWitnessDiviner",
+              "schema": "network.xyo.diviner.boundwitness.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "ImageThumbnailArchivist",
+              "language": "javascript",
+              "name": "ImageThumbnailPayloadDiviner",
+              "schema": "network.xyo.diviner.payload.config"
+            }
+          },
+          {
+            "config": {
+              "filter": {
+                "payload_schemas": ["network.xyo.image.thumbnail"]
+              },
+              "labels": {
+                "network.xyo.diviner.stage": "stateToIndexCandidateDiviner"
+              },
+              "language": "javascript",
+              "name": "TemporalStateToIndexCandidateDiviner",
+              "payloadStore": {
+                "archivist": "ImageThumbnailArchivist",
+                "boundWitnessDiviner": "ImageThumbnailBoundWitnessDiviner",
+                "payloadDiviner": "ImageThumbnailPayloadDiviner"
+              },
+              "schema": "network.xyo.diviner.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './Diviner'

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from './jsonpath'

package/src/lib/jsonpath/JsonPathTransformExpression.ts

@@ -0,0 +1,14 @@
+/**
+ * Describes the JSON-path transformation to retrieve a field on a source object
+ * and the target field to store the value to on a destination object
+ */
+export interface JsonPathTransformExpression {
+  /**
+   * The target field to store the source field into on the destination object
+   */
+  destinationField: string
+  /**
+   * The JSON path expressions for the source field on the source object
+   */
+  sourcePathExpression: string
+}

package/src/lib/jsonpath/PayloadTransformer.ts

@@ -0,0 +1,3 @@
+import { Payload } from '@xyo-network/payload-model'
+
+export type PayloadTransformer = (x: Payload) => Partial<Payload>

package/src/lib/jsonpath/StringToJsonPathTransformExpressionDictionary.ts

@@ -0,0 +1,8 @@
+import { JsonPathTransformExpression } from './JsonPathTransformExpression'
+
+/**
+ * A dictionary of string keys to JsonPathTransformExpressions.
+ */
+export type StringToJsonPathTransformExpressionsDictionary<T extends { [key: string]: unknown } = { [key: string]: unknown }> = {
+  [key in keyof T]: JsonPathTransformExpression[]
+}

package/src/lib/jsonpath/StringToPayloadTransformersDictionary.ts

@@ -0,0 +1,3 @@
+import { PayloadTransformer } from './PayloadTransformer'
+
+export type StringToPayloadTransformersDictionary = { [key: string]: PayloadTransformer[] }

package/src/lib/jsonpath/index.ts

@@ -0,0 +1,4 @@
+export * from './JsonPathTransformExpression'
+export * from './PayloadTransformer'
+export * from './StringToJsonPathTransformExpressionDictionary'
+export * from './StringToPayloadTransformersDictionary'

package/src/spec/ImageThumbnailDivinerManifest.json

@@ -0,0 +1,159 @@
+{
+  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  "nodes": [
+    {
+      "config": {
+        "name": "DivinerTest",
+        "schema": "network.xyo.node.config"
+      },
+      "modules": {
+        "public": [
+          {
+            "config": {
+              "language": "javascript",
+              "name": "AddressStateArchivist",
+              "schema": "network.xyo.archivist.config",
+              "storeQueries": false
+            }
+          },
+          {
+            "config": {
+              "archivist": "AddressStateArchivist",
+              "language": "javascript",
+              "name": "AddressStateBoundWitnessDiviner",
+              "schema": "network.xyo.diviner.boundwitness.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "AddressStateArchivist",
+              "language": "javascript",
+              "name": "AddressStatePayloadDiviner",
+              "schema": "network.xyo.diviner.payload.config"
+            }
+          },
+          {
+            "config": {
+              "language": "javascript",
+              "name": "ImageThumbnailArchivist",
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "ImageThumbnailArchivist",
+              "language": "javascript",
+              "name": "ImageThumbnailBoundWitnessDiviner",
+              "schema": "network.xyo.diviner.boundwitness.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "ImageThumbnailArchivist",
+              "language": "javascript",
+              "name": "ImageThumbnailPayloadDiviner",
+              "schema": "network.xyo.diviner.payload.config"
+            }
+          },
+          {
+            "config": {
+              "language": "javascript",
+              "name": "ImageThumbnailDivinerIndexArchivist",
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "ImageThumbnailDivinerIndexArchivist",
+              "language": "javascript",
+              "name": "ImageThumbnailDivinerIndexBoundWitnessDiviner",
+              "schema": "network.xyo.diviner.boundwitness.config"
+            }
+          },
+          {
+            "config": {
+              "archivist": "ImageThumbnailDivinerIndexArchivist",
+              "language": "javascript",
+              "name": "ImageThumbnailDivinerIndexPayloadDiviner",
+              "schema": "network.xyo.diviner.payload.config"
+            }
+          },
+          {
+            "config": {
+              "labels": {
+                "network.xyo.diviner.stage": "stateToIndexCandidateDiviner",
+                "network.xyo.image.thumbnail": "diviner"
+              },
+              "language": "javascript",
+              "name": "ImageThumbnailStateToIndexCandidateDiviner",
+              "payloadStore": {
+                "archivist": "ImageThumbnailArchivist",
+                "boundWitnessDiviner": "ImageThumbnailBoundWitnessDiviner",
+                "payloadDiviner": "ImageThumbnailPayloadDiviner"
+              },
+              "schema": "network.xyo.diviner.config"
+            }
+          },
+          {
+            "config": {
+              "labels": {
+                "network.xyo.diviner.stage": "indexCandidateToIndexDiviner",
+                "network.xyo.image.thumbnail": "diviner"
+              },
+              "language": "javascript",
+              "name": "ImageThumbnailIndexCandidateToImageThumbnailIndexDiviner",
+              "schema": "network.xyo.diviner.config"
+            }
+          },
+          {
+            "config": {
+              "labels": {
+                "network.xyo.diviner.stage": "divinerQueryToIndexQueryDiviner",
+                "network.xyo.image.thumbnail": "diviner"
+              },
+              "language": "javascript",
+              "name": "ImageThumbnailQueryToImageThumbnailIndexQueryDiviner",
+              "schema": "network.xyo.diviner.config"
+            }
+          },
+          {
+            "config": {
+              "labels": {
+                "network.xyo.diviner.stage": "indexQueryResponseToDivinerQueryResponseDiviner",
+                "network.xyo.image.thumbnail": "diviner"
+              },
+              "language": "javascript",
+              "name": "ImageThumbnailIndexQueryResponseToImageThumbnailQueryResponseDiviner",
+              "schema": "network.xyo.diviner.config"
+            }
+          },
+          {
+            "config": {
+              "indexStore": {
+                "archivist": "ImageThumbnailDivinerIndexArchivist",
+                "boundWitnessDiviner": "ImageThumbnailDivinerIndexBoundWitnessDiviner",
+                "payloadDiviner": "ImageThumbnailDivinerIndexPayloadDiviner"
+              },
+              "indexingDivinerStages": {
+                "divinerQueryToIndexQueryDiviner": "ImageThumbnailQueryToImageThumbnailIndexQueryDiviner",
+                "indexCandidateToIndexDiviner": "ImageThumbnailIndexCandidateToImageThumbnailIndexDiviner",
+                "indexQueryResponseToDivinerQueryResponseDiviner": "ImageThumbnailIndexQueryResponseToImageThumbnailQueryResponseDiviner",
+                "stateToIndexCandidateDiviner": "ImageThumbnailStateToIndexCandidateDiviner"
+              },
+              "language": "javascript",
+              "name": "ImageThumbnailDiviner",
+              "pollFrequency": 1000,
+              "schema": "network.xyo.diviner.indexing.config",
+              "stateStore": {
+                "archivist": "AddressStateArchivist",
+                "boundWitnessDiviner": "AddressStateBoundWitnessDiviner",
+                "payloadDiviner": "AddressStatePayloadDiviner"
+              }
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}