@xyo-network/diviner-temporal-indexing-memory 2.80.12 → 2.80.14

package/dist/node/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,45 +17,389 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  TemporalIndexingDiviner: () => TemporalIndexingDiviner
+  TemporalIndexingDiviner: () => TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner: () => TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner: () => TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner: () => TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner: () => TemporalIndexingDivinerStateToIndexCandidateDiviner
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/Diviner.ts
+var import_assert3 = require("@xylabs/assert");
 var import_diviner_indexing_memory = require("@xyo-network/diviner-indexing-memory");
 var import_diviner_indexing_model = require("@xyo-network/diviner-indexing-model");
+var import_diviner_model5 = require("@xyo-network/diviner-model");
+var import_diviner_temporal_indexing_model5 = require("@xyo-network/diviner-temporal-indexing-model");
+var import_node_model = require("@xyo-network/node-model");
+
+// src/DivinerQueryToIndexQueryDiviner/Diviner.ts
+var import_abstract_diviner = require("@xyo-network/abstract-diviner");
 var import_diviner_model = require("@xyo-network/diviner-model");
+var import_diviner_payload_model = require("@xyo-network/diviner-payload-model");
+var import_diviner_temporal_indexing_model = require("@xyo-network/diviner-temporal-indexing-model");
+var import_payload_builder2 = require("@xyo-network/payload-builder");
+var import_payload_model = require("@xyo-network/payload-model");
+
+// src/jsonpath/toPayloadTransformer.ts
+var import_jsonpath = __toESM(require("jsonpath"));
+var toPayloadTransformer = (transformExpression) => {
+  const { defaultValue, destinationField, sourcePathExpression } = transformExpression;
+  const transformer = (x) => {
+    const source = import_jsonpath.default.value(x, sourcePathExpression);
+    const transformed = {};
+    const destinationValue = source === void 0 ? defaultValue : source;
+    if (destinationValue !== void 0)
+      transformed[destinationField] = destinationValue;
+    return transformed;
+  };
+  return transformer;
+};
+
+// src/jsonpath/jsonPathToTransformersDictionary.ts
+var jsonPathToTransformersDictionary = (schemaTransforms) => {
+  return Object.fromEntries(
+    Object.entries(schemaTransforms).map(([schema, jsonPathTransformerExpressions]) => {
+      const transformers = jsonPathTransformerExpressions.map(toPayloadTransformer);
+      return [schema, transformers];
+    })
+  );
+};
+
+// src/jsonpath/reducePayloads.ts
+var import_core = require("@xyo-network/core");
+var import_payload_builder = require("@xyo-network/payload-builder");
+var reducePayloads = async (payloads, payloadTransformers, destinationSchema) => {
+  const indexFields = payloads.map((payload) => {
+    const transformers = payloadTransformers[payload.schema];
+    return transformers ? transformers.map((transform) => transform(payload)) : [];
+  }).flat();
+  const sources = (await import_core.PayloadHasher.hashPairs([...payloads])).map(([, hash]) => hash);
+  return new import_payload_builder.PayloadBuilder({ schema: destinationSchema }).fields(Object.assign({ sources }, ...indexFields)).build();
+};
+
+// src/DivinerQueryToIndexQueryDiviner/Diviner.ts
+var TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner = class extends import_abstract_diviner.AbstractDiviner {
+  static configSchema = import_diviner_temporal_indexing_model.TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema;
+  static configSchemas = [import_diviner_model.DivinerConfigSchema, import_diviner_temporal_indexing_model.TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema];
+  static labels = {
+    "network.xyo.diviner.stage": "divinerQueryToIndexQueryDiviner"
+  };
+  _indexableSchemas;
+  _payloadTransformers;
+  /**
+   * The schema of the diviner query payloads
+   */
+  get divinerQuerySchema() {
+    return this.config.divinerQuerySchema ?? import_diviner_payload_model.PayloadDivinerQuerySchema;
+  }
+  /**
+   * The schema of the index query payloads
+   */
+  get indexQuerySchema() {
+    return this.config.indexQuerySchema ?? import_diviner_payload_model.PayloadDivinerQuerySchema;
+  }
+  /**
+   * The schema of the index payloads
+   */
+  get indexSchema() {
+    return this.config.indexSchema ?? import_diviner_temporal_indexing_model.TemporalIndexingDivinerResultIndexSchema;
+  }
+  /**
+   * List of indexable schemas for this diviner
+   */
+  get indexableSchemas() {
+    if (!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
+   */
+  get payloadTransformers() {
+    if (!this._payloadTransformers)
+      this._payloadTransformers = jsonPathToTransformersDictionary(this.schemaTransforms);
+    return this._payloadTransformers;
+  }
+  /**
+   * The dictionary of schemas to JSON Path transform expressions for creating indexes
+   * from the payloads within a Bound Witness
+   */
+  get schemaTransforms() {
+    var _a;
+    return ((_a = this.config) == null ? void 0 : _a.schemaTransforms) ?? {
+      [this.divinerQuerySchema]: [
+        {
+          defaultValue: 1,
+          destinationField: "limit",
+          sourcePathExpression: "$.limit"
+        },
+        {
+          defaultValue: 0,
+          destinationField: "offset",
+          sourcePathExpression: "$.offset"
+        },
+        {
+          defaultValue: "desc",
+          destinationField: "order",
+          sourcePathExpression: "$.order"
+        }
+      ]
+    };
+  }
+  async divineHandler(payloads = []) {
+    const queries = payloads.filter((0, import_payload_model.isPayloadOfSchemaType)(this.divinerQuerySchema));
+    if (queries.length) {
+      const results = await Promise.all(
+        queries.map(async (query) => {
+          const fields = await reducePayloads(
+            [query],
+            this.payloadTransformers,
+            this.indexQuerySchema
+          );
+          fields.schemas = [this.indexSchema];
+          delete fields.sources;
+          return new import_payload_builder2.PayloadBuilder({ schema: this.indexQuerySchema }).fields(fields).build();
+        })
+      );
+      return results;
+    }
+    return Promise.resolve([]);
+  }
+};
+
+// src/IndexCandidateToIndexDiviner/Diviner.ts
+var import_array = require("@xylabs/array");
+var import_assert = require("@xylabs/assert");
+var import_exists = require("@xylabs/exists");
+var import_abstract_diviner2 = require("@xyo-network/abstract-diviner");
+var import_boundwitness_model = require("@xyo-network/boundwitness-model");
+var import_core2 = require("@xyo-network/core");
+var import_diviner_model2 = require("@xyo-network/diviner-model");
+var import_diviner_temporal_indexing_model2 = require("@xyo-network/diviner-temporal-indexing-model");
+var import_payload_builder3 = require("@xyo-network/payload-builder");
+var moduleName = "TemporalIndexingDivinerIndexCandidateToIndexDiviner";
+var TemporalIndexingDivinerIndexCandidateToIndexDiviner = class extends import_abstract_diviner2.AbstractDiviner {
+  static configSchema = import_diviner_temporal_indexing_model2.TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema;
+  static configSchemas = [import_diviner_model2.DivinerConfigSchema, import_diviner_temporal_indexing_model2.TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema];
+  static labels = {
+    "network.xyo.diviner.stage": "indexCandidateToIndexDiviner"
+  };
+  _indexableSchemas;
+  _payloadTransformers;
+  /**
+   * List of indexable schemas for this diviner
+   */
+  get indexableSchemas() {
+    if (!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
+   */
+  get payloadTransformers() {
+    if (!this._payloadTransformers)
+      this._payloadTransformers = jsonPathToTransformersDictionary(this.schemaTransforms);
+    return this._payloadTransformers;
+  }
+  /**
+   * The dictionary of schemas to JSON Path transform expressions for creating indexes
+   * from the payloads within a Bound Witness
+   */
+  get schemaTransforms() {
+    var _a;
+    return (0, import_assert.assertEx)((_a = this.config) == null ? void 0 : _a.schemaTransforms, () => `${moduleName}: Missing config.schemaTransforms section`);
+  }
+  async divineHandler(payloads = []) {
+    const bws = payloads.filter(import_boundwitness_model.isBoundWitness);
+    const indexablePayloads = payloads.filter((p) => this.isIndexablePayload(p));
+    if (bws.length && indexablePayloads.length) {
+      const payloadDictionary = await import_core2.PayloadHasher.toMap(payloads);
+      const validIndexableTuples = bws.reduce((indexableTuples, bw) => {
+        if (!(0, import_array.containsAll)(bw.payload_schemas, this.indexableSchemas))
+          return indexableTuples;
+        const indexablePayloadPositions = this.indexableSchemas.map((schema) => bw.payload_schemas.indexOf(schema));
+        const indexablePayloadHashes = indexablePayloadPositions.map((index) => {
+          var _a;
+          return (_a = bw.payload_hashes) == null ? void 0 : _a[index];
+        });
+        const indexablePayloads2 = indexablePayloadHashes.map((hash) => payloadDictionary[hash]).filter(import_exists.exists);
+        if (indexablePayloads2.length === this.indexableSchemas.length)
+          indexableTuples.push([bw, ...indexablePayloads2]);
+        return indexableTuples;
+      }, []);
+      const indexes = await Promise.all(
+        validIndexableTuples.map(async ([bw, ...sourcePayloads]) => {
+          const indexFields = sourcePayloads.map((payload) => {
+            const transformers = this.payloadTransformers[payload.schema];
+            return transformers ? transformers.map((transform) => transform(payload)) : [];
+          }).flat();
+          const sources = Object.keys(await import_core2.PayloadHasher.toMap([bw, ...sourcePayloads]));
+          return new import_payload_builder3.PayloadBuilder({ schema: import_diviner_temporal_indexing_model2.TemporalIndexingDivinerResultIndexSchema }).fields(Object.assign({ sources }, ...indexFields)).build();
+        })
+      );
+      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
+   */
+  isIndexablePayload = (x) => {
+    return this.indexableSchemas.includes(x == null ? void 0 : 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
+   */
+  isIndexableSchema = (schema) => {
+    return this.indexableSchemas.some((s) => s === schema);
+  };
+};
+
+// src/IndexQueryResponseToDivinerQueryResponseDiviner/Diviner.ts
+var import_abstract_diviner3 = require("@xyo-network/abstract-diviner");
+var import_diviner_model3 = require("@xyo-network/diviner-model");
+var import_diviner_payload_model2 = require("@xyo-network/diviner-payload-model");
+var import_diviner_temporal_indexing_model3 = require("@xyo-network/diviner-temporal-indexing-model");
+var TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner = class extends import_abstract_diviner3.AbstractDiviner {
+  static configSchema = import_diviner_temporal_indexing_model3.TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema;
+  static configSchemas = [import_diviner_model3.DivinerConfigSchema, import_diviner_temporal_indexing_model3.TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema];
+  static labels = {
+    "network.xyo.diviner.stage": "indexQueryResponseToDivinerQueryResponseDiviner"
+  };
+  async divineHandler(payloads = []) {
+    const responses = payloads.filter((p) => !(0, import_diviner_payload_model2.isPayloadDivinerQueryPayload)(p));
+    return await Promise.resolve(responses);
+  }
+};
+
+// src/StateToIndexCandidateDiviner/Diviner.ts
+var import_assert2 = require("@xylabs/assert");
+var import_exists2 = require("@xylabs/exists");
+var import_abstract_diviner4 = require("@xyo-network/abstract-diviner");
+var import_archivist_wrapper = require("@xyo-network/archivist-wrapper");
+var import_boundwitness_model2 = require("@xyo-network/boundwitness-model");
+var import_diviner_boundwitness_model = require("@xyo-network/diviner-boundwitness-model");
+var import_diviner_model4 = require("@xyo-network/diviner-model");
+var import_diviner_temporal_indexing_model4 = require("@xyo-network/diviner-temporal-indexing-model");
+var import_diviner_wrapper = require("@xyo-network/diviner-wrapper");
+var import_module_model = require("@xyo-network/module-model");
+var import_payload_builder4 = require("@xyo-network/payload-builder");
+var import_payload_model2 = require("@xyo-network/payload-model");
+var import_witness_timestamp = require("@xyo-network/witness-timestamp");
+var order = "asc";
+var moduleName2 = "TemporalIndexingDivinerStateToIndexCandidateDiviner";
+var TemporalIndexingDivinerStateToIndexCandidateDiviner = class extends import_abstract_diviner4.AbstractDiviner {
+  static configSchema = import_diviner_temporal_indexing_model4.TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema;
+  static configSchemas = [import_diviner_model4.DivinerConfigSchema, import_diviner_temporal_indexing_model4.TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema];
+  static labels = {
+    "network.xyo.diviner.stage": "stateToIndexCandidateDiviner"
+  };
+  get payloadDivinerLimit() {
+    return this.config.payloadDivinerLimit ?? 1e3;
+  }
+  /**
+   * The required payload_schemas within BoundWitnesses to identify index candidates
+   */
+  get payload_schemas() {
+    var _a;
+    const schemas = (_a = this.config.filter) == null ? void 0 : _a.payload_schemas;
+    return [import_witness_timestamp.TimestampSchema, ...schemas ?? []];
+  }
+  async divineHandler(payloads = []) {
+    const lastState = payloads.find(import_module_model.isModuleState);
+    if (!lastState)
+      return [{ schema: import_module_model.ModuleStateSchema, state: { offset: 0 } }];
+    const { offset } = lastState.state;
+    const boundWitnessDiviner = await this.getBoundWitnessDivinerForStore();
+    if (!boundWitnessDiviner)
+      return [lastState];
+    const query = new import_payload_builder4.PayloadBuilder({ schema: import_diviner_boundwitness_model.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];
+    const sourceArchivist = await this.getArchivistForStore();
+    if (!sourceArchivist)
+      return [lastState];
+    const indexCandidates = (await Promise.all(batch.filter(import_boundwitness_model2.isBoundWitness).map((bw) => this.getPayloadsInBoundWitness(bw, sourceArchivist)))).filter(import_exists2.exists).flat();
+    const nextState = { schema: import_module_model.ModuleStateSchema, state: { ...lastState.state, offset: offset + batch.length } };
+    return [nextState, ...indexCandidates];
+  }
+  /**
+   * Retrieves the archivist for the payloadStore
+   * @returns The archivist for the payloadStore or undefined if not resolvable
+   */
+  async getArchivistForStore() {
+    var _a, _b;
+    const name = (0, import_assert2.assertEx)((_b = (_a = this.config) == null ? void 0 : _a.payloadStore) == null ? void 0 : _b.archivist, () => `${moduleName2}: Config for payloadStore.archivist not specified`);
+    const mod = await this.resolve(name);
+    if (!mod)
+      return void 0;
+    return import_archivist_wrapper.ArchivistWrapper.wrap(mod, this.account);
+  }
+  /**
+   * Retrieves the BoundWitness Diviner for the payloadStore
+   * @returns The BoundWitness Diviner for the payloadStore or undefined if not resolvable
+   */
+  async getBoundWitnessDivinerForStore() {
+    var _a, _b;
+    const name = (0, import_assert2.assertEx)(
+      (_b = (_a = this.config) == null ? void 0 : _a.payloadStore) == null ? void 0 : _b.boundWitnessDiviner,
+      () => `${moduleName2}: Config for payloadStore.boundWitnessDiviner not specified`
+    );
+    const mod = await this.resolve(name);
+    if (!mod)
+      return void 0;
+    return import_diviner_wrapper.DivinerWrapper.wrap(mod, this.account);
+  }
+  async getPayloadsInBoundWitness(bw, archivist) {
+    const indexes = this.payload_schemas.map((schema) => {
+      var _a;
+      return (_a = bw.payload_schemas) == null ? void 0 : _a.findIndex((s) => s === schema);
+    });
+    const hashes = indexes.map((index) => {
+      var _a;
+      return (_a = bw.payload_hashes) == null ? void 0 : _a[index];
+    });
+    const results = await archivist.get(hashes);
+    const indexCandidateIdentityFunctions = this.payload_schemas.map(import_payload_model2.isPayloadOfSchemaType);
+    const filteredResults = indexCandidateIdentityFunctions.map((is) => results.find(is));
+    if (filteredResults.some((f) => f === void 0))
+      return void 0;
+    const indexCandidates = filteredResults.filter(import_exists2.exists);
+    return [bw, ...indexCandidates];
+  }
+};
+
+// src/Diviner.ts
+var moduleName3 = "TemporalIndexingDiviner";
 var TemporalIndexingDiviner = class extends import_diviner_indexing_memory.IndexingDiviner {
-  static configSchemas = [import_diviner_indexing_model.IndexingDivinerConfigSchema, import_diviner_model.DivinerConfigSchema];
+  static configSchema = import_diviner_temporal_indexing_model5.TemporalIndexingDivinerConfigSchema;
+  static configSchemas = [import_diviner_temporal_indexing_model5.TemporalIndexingDivinerConfigSchema, import_diviner_indexing_model.IndexingDivinerConfigSchema, import_diviner_model5.DivinerConfigSchema];
   _divinerQueryToIndexQueryDiviner;
   _indexCandidateToIndexDiviner;
   _indexQueryResponseToDivinerQueryResponseDiviner;
   _stateToIndexCandidateDiviner;
-  get divinerQueryToIndexQueryDiviner() {
-    if (this._divinerQueryToIndexQueryDiviner)
-      return this._divinerQueryToIndexQueryDiviner;
-    throw new Error("TODO: Create diviner");
-  }
-  get indexCandidateToIndexDiviner() {
-    if (this._indexCandidateToIndexDiviner)
-      return this._indexCandidateToIndexDiviner;
-    throw new Error("TODO: Create diviner");
-  }
-  get indexQueryResponseToDivinerQueryResponseDiviner() {
-    if (this._indexQueryResponseToDivinerQueryResponseDiviner)
-      return this._indexQueryResponseToDivinerQueryResponseDiviner;
-    throw new Error("TODO: Create diviner");
-  }
-  get stateToIndexCandidateDiviner() {
-    if (this._stateToIndexCandidateDiviner)
-      return this._stateToIndexCandidateDiviner;
-    throw new Error("TODO: Create diviner");
-  }
   /**
    * Gets the Diviner for the supplied Indexing Diviner stage
    * @param transform The Indexing Diviner stage
@@ -62,22 +408,125 @@ var TemporalIndexingDiviner = class extends import_diviner_indexing_memory.Index
   getIndexingDivinerStage(transform) {
     switch (transform) {
       case "divinerQueryToIndexQueryDiviner":
-        return Promise.resolve(this.divinerQueryToIndexQueryDiviner);
+        return this.getDivinerQueryToIndexQueryDiviner();
       case "indexCandidateToIndexDiviner":
-        return Promise.resolve(this.indexCandidateToIndexDiviner);
+        return this.getIndexCandidateToIndexDiviner();
       case "indexQueryResponseToDivinerQueryResponseDiviner":
-        return Promise.resolve(this.indexQueryResponseToDivinerQueryResponseDiviner);
+        return this.getIndexQueryResponseToDivinerQueryResponseDiviner();
       case "stateToIndexCandidateDiviner":
-        return Promise.resolve(this.stateToIndexCandidateDiviner);
+        return this.getStateToIndexCandidateDiviner();
     }
   }
   async startHandler() {
     await super.startHandler();
     return true;
   }
+  /**
+   * Adds the supplied module to the parent Node of this Diviner
+   * @param mod The module to add to the parent Node of this Diviner
+   * @returns
+   */
+  async attachModuleToParentNode(mod) {
+    const parent = (await this.resolve({ maxDepth: 1, query: [["network.xyo.query.node.attach"]] })).shift();
+    if (parent) {
+      const node = (0, import_node_model.asNodeInstance)(parent);
+      if (node) {
+        await node.register(mod);
+        await node.attach(mod.address, false);
+      }
+    }
+  }
+  async getDivinerQueryToIndexQueryDiviner() {
+    var _a, _b;
+    if (!this._divinerQueryToIndexQueryDiviner) {
+      const name = (_a = this.config.indexingDivinerStages) == null ? void 0 : _a.divinerQueryToIndexQueryDiviner;
+      if (name) {
+        this._divinerQueryToIndexQueryDiviner = await this.resolve(name);
+      } else {
+        const stageConfig = (_b = this.config.stageConfigs) == null ? void 0 : _b.divinerQueryToIndexQueryDiviner;
+        if (stageConfig) {
+          const config = { schema: import_diviner_temporal_indexing_model5.TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema, ...stageConfig };
+          const stage = await TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.create({ config });
+          await this.attachModuleToParentNode(stage);
+          this._divinerQueryToIndexQueryDiviner = stage;
+        }
+      }
+    }
+    return (0, import_assert3.assertEx)(
+      this._divinerQueryToIndexQueryDiviner,
+      () => `${moduleName3}: Failed to resolve indexing diviner stage for divinerQueryToIndexQueryDiviner`
+    );
+  }
+  async getIndexCandidateToIndexDiviner() {
+    var _a, _b;
+    if (!this._indexCandidateToIndexDiviner) {
+      const name = (_a = this.config.indexingDivinerStages) == null ? void 0 : _a.indexCandidateToIndexDiviner;
+      if (name) {
+        this._indexCandidateToIndexDiviner = await this.resolve(name);
+      } else {
+        const stageConfig = (_b = this.config.stageConfigs) == null ? void 0 : _b.indexCandidateToIndexDiviner;
+        if (stageConfig) {
+          const config = { schema: import_diviner_temporal_indexing_model5.TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema, ...stageConfig };
+          const stage = await TemporalIndexingDivinerIndexCandidateToIndexDiviner.create({ config });
+          await this.attachModuleToParentNode(stage);
+          this._indexCandidateToIndexDiviner = stage;
+        }
+      }
+    }
+    return (0, import_assert3.assertEx)(
+      this._indexCandidateToIndexDiviner,
+      () => `${moduleName3}: Failed to resolve indexing diviner stage for indexCandidateToIndexDiviner`
+    );
+  }
+  async getIndexQueryResponseToDivinerQueryResponseDiviner() {
+    var _a, _b;
+    if (!this._indexQueryResponseToDivinerQueryResponseDiviner) {
+      const name = (_a = this.config.indexingDivinerStages) == null ? void 0 : _a.indexQueryResponseToDivinerQueryResponseDiviner;
+      if (name) {
+        this._indexQueryResponseToDivinerQueryResponseDiviner = await this.resolve(name);
+      } else {
+        const stageConfig = (_b = this.config.stageConfigs) == null ? void 0 : _b.indexQueryResponseToDivinerQueryResponseDiviner;
+        if (stageConfig) {
+          const config = { schema: import_diviner_temporal_indexing_model5.TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema, ...stageConfig };
+          const stage = await TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.create({ config });
+          await this.attachModuleToParentNode(stage);
+          this._indexQueryResponseToDivinerQueryResponseDiviner = stage;
+        }
+      }
+    }
+    return (0, import_assert3.assertEx)(
+      this._indexQueryResponseToDivinerQueryResponseDiviner,
+      () => `${moduleName3}: Failed to resolve indexing diviner stage for indexQueryResponseToDivinerQueryResponseDiviner`
+    );
+  }
+  async getStateToIndexCandidateDiviner() {
+    var _a, _b;
+    if (!this._stateToIndexCandidateDiviner) {
+      const name = (_a = this.config.indexingDivinerStages) == null ? void 0 : _a.stateToIndexCandidateDiviner;
+      if (name) {
+        this._stateToIndexCandidateDiviner = await this.resolve(name);
+      } else {
+        const stageConfig = (_b = this.config.stageConfigs) == null ? void 0 : _b.stateToIndexCandidateDiviner;
+        if (stageConfig) {
+          const config = { schema: import_diviner_temporal_indexing_model5.TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema, ...stageConfig };
+          const stage = await TemporalIndexingDivinerStateToIndexCandidateDiviner.create({ config });
+          await this.attachModuleToParentNode(stage);
+          this._stateToIndexCandidateDiviner = stage;
+        }
+      }
+    }
+    return (0, import_assert3.assertEx)(
+      this._stateToIndexCandidateDiviner,
+      () => `${moduleName3}: Failed to resolve indexing diviner stage for stateToIndexCandidateDiviner`
+    );
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TemporalIndexingDiviner
+  TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner
 });
 //# sourceMappingURL=index.js.map