@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/archivist-abstract/neutral/index.mjs

@@ -0,0 +1,562 @@
+// src/AbstractArchivist.ts
+import {
+  assertEx,
+  difference,
+  exists,
+  globallyUnique,
+  isNull,
+  isUndefined
+} from "@xylabs/sdk";
+import {
+  ArchivistAllQuerySchema,
+  ArchivistClearQuerySchema,
+  ArchivistCommitQuerySchema,
+  ArchivistConfigSchema,
+  ArchivistDeleteQuerySchema,
+  ArchivistGetQuerySchema,
+  ArchivistInsertQuerySchema,
+  ArchivistNextQuerySchema,
+  ArchivistSnapshotQuerySchema,
+  ArchivistStatsPayloadSchema,
+  asArchivistInstance,
+  isArchivistInstance
+} from "../../archivist-model/neutral/index.mjs";
+import { AbstractModuleInstance } from "../../module-abstract/neutral/index.mjs";
+import { duplicateModules } from "../../module-model/neutral/index.mjs";
+import { PayloadBuilder, QueryBoundWitnessWrapper } from "../../sdk-protocol/neutral/index.mjs";
+import { LRUCache } from "lru-cache";
+
+// src/StorageClassLabel.ts
+var StorageClassLabel = "network.xyo.storage.class";
+
+// src/AbstractArchivist.ts
+var NOT_IMPLEMENTED = "Not implemented";
+var AbstractArchivist = class _AbstractArchivist extends AbstractModuleInstance {
+  static configSchemas = [...super.configSchemas, ArchivistConfigSchema];
+  static defaultConfigSchema = ArchivistConfigSchema;
+  static labels = { ...super.labels, [StorageClassLabel]: "unknown" };
+  static uniqueName = globallyUnique("AbstractArchivist", _AbstractArchivist, "xyo");
+  // override this if a specialized archivist should have a different default next limit
+  static defaultNextLimitSetting = 100;
+  _getCache;
+  _parentArchivists;
+  _payloadCountGauge;
+  _payloadCountMeter;
+  // do not override this!  It is meant to get the this.defaultNextLimitSetting and work if it is overridden
+  static get defaultNextLimit() {
+    return this.defaultNextLimitSetting;
+  }
+  get queries() {
+    return [ArchivistGetQuerySchema, ...super.queries];
+  }
+  get requireAllParents() {
+    return this.config.requireAllParents ?? false;
+  }
+  get payloadCountGauge() {
+    const meter = this.payloadCountMeter;
+    if (!isNull(meter)) {
+      this._payloadCountGauge = meter?.createGauge("payloadCount", { description: "Payloads in the archivist" });
+    }
+    return this._payloadCountGauge;
+  }
+  get payloadCountMeter() {
+    if (isUndefined(this._payloadCountMeter)) {
+      this._payloadCountMeter = this.params?.meterProvider?.getMeter(this.id) ?? null;
+    }
+    return this._payloadCountMeter ?? null;
+  }
+  get storeParentReads() {
+    return !!this.config?.storeParentReads;
+  }
+  /** @deprecated use next or snapshot instead */
+  async all() {
+    this._noOverride("all");
+    this.isSupportedQuery(ArchivistAllQuerySchema, "all");
+    return await this.spanAsync(`${this.id}|all`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return [];
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          return PayloadBuilder.omitPrivateStorageMeta(await this.allHandler());
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  /** deprecated use nextQuery or snapshotQuery instead */
+  async allQuery(account) {
+    this._noOverride("allQuery");
+    const queryPayload = { schema: ArchivistAllQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async clear() {
+    this._noOverride("clear");
+    this.isSupportedQuery(ArchivistClearQuerySchema, "clear");
+    return await this.spanAsync(`${this.id}|clear`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return;
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          await this.clearHandler();
+          this.reportPayloadCount();
+          await this.emit("cleared", { mod: this });
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async clearQuery(account) {
+    this._noOverride("clearQuery");
+    const queryPayload = { schema: ArchivistClearQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async commit() {
+    this._noOverride("commit");
+    this.isSupportedQuery(ArchivistCommitQuerySchema, "commit");
+    return await this.spanAsync(`${this.id}commit`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return [];
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          return await this.commitHandler();
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async commitQuery(account) {
+    this._noOverride("commitQuery");
+    const queryPayload = { schema: ArchivistCommitQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async delete(hashes) {
+    this._noOverride("delete");
+    this.isSupportedQuery(ArchivistDeleteQuerySchema, "delete");
+    return await this.spanAsync(`${this.id}|delete`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return [];
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          return await this.deleteWithConfig(hashes);
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async deleteQuery(hashes, account) {
+    this._noOverride("deleteQuery");
+    const queryPayload = { hashes, schema: ArchivistDeleteQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async get(hashes) {
+    this._noOverride("get");
+    this.isSupportedQuery(ArchivistGetQuerySchema, "get");
+    return await this.spanAsync(`${this.id}|get`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return [];
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          return await this.getWithConfig(hashes);
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async getQuery(hashes, account) {
+    this._noOverride("getQuery");
+    const queryPayload = { hashes, schema: ArchivistGetQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async insert(payloads) {
+    this._noOverride("insert");
+    this.isSupportedQuery(ArchivistInsertQuerySchema, "insert");
+    return await this.spanAsync(`${this.id}|insert`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return [];
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          return await this.insertWithConfig(PayloadBuilder.omitStorageMeta(payloads));
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async insertQuery(payloads, account) {
+    this._noOverride("insertQuery");
+    const queryPayload = { schema: ArchivistInsertQuerySchema };
+    return await this.sendQueryRaw(queryPayload, payloads, account);
+  }
+  async next(options) {
+    this._noOverride("next");
+    this.isSupportedQuery(ArchivistNextQuerySchema, "next");
+    return await this.spanAsync(`${this.id}|next`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        return [];
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          const { limit = _AbstractArchivist.defaultNextLimit, ...otherOptions } = options ?? {};
+          return await this.nextWithConfig({ limit, ...otherOptions });
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async nextQuery(options, account) {
+    this._noOverride("nextQuery");
+    const queryPayload = { schema: ArchivistNextQuerySchema, ...options };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async snapshot() {
+    this._noOverride("snapshot");
+    this.isSupportedQuery(ArchivistSnapshotQuerySchema, "snapshot");
+    return await this.spanAsync(`${this.id}|snapshot`, async () => {
+      if (this.reentrancy?.scope === "global" && this.reentrancy.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+        throw new Error("Cannot take snapshot while in a global reentrancy lock");
+      }
+      try {
+        await this.globalReentrancyMutex?.acquire();
+        return await this.busy(async () => {
+          await this.startedAsync("throw");
+          return await this.snapshotHandler();
+        });
+      } finally {
+        this.globalReentrancyMutex?.release();
+      }
+    }, { timeBudgetLimit: this.timeBudget });
+  }
+  async snapshotQuery(account) {
+    this._noOverride("snapshotQuery");
+    const queryPayload = { schema: ArchivistSnapshotQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  allHandler() {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  clearHandler() {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  commitHandler() {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  deleteHandler(_hashes) {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  async deleteWithConfig(hashes, config) {
+    const emitEvents = config?.emitEvents ?? true;
+    const payloads = await this.deleteHandler(hashes);
+    const hashesDeleted = payloads.map((p) => p._hash);
+    if (emitEvents) {
+      await this.emit("deleted", {
+        hashes: hashesDeleted,
+        payloads,
+        mod: this
+      });
+    }
+    this.reportPayloadCount();
+    return payloads;
+  }
+  generateStats() {
+    return {
+      payloadCount: this.payloadCountHandler(),
+      schema: ArchivistStatsPayloadSchema
+    };
+  }
+  async getFromParent(hashes, archivist) {
+    const foundPairs = (await PayloadBuilder.dataHashPairs(await archivist.get(hashes))).filter(([, hash]) => {
+      const askedFor = hashes.includes(hash);
+      if (!askedFor) {
+        console.warn(`Parent returned payload with hash not asked for: ${hash}`);
+      }
+      return askedFor;
+    });
+    const foundHashes = new Set(foundPairs.map(([, hash]) => hash));
+    const foundPayloads = foundPairs.map(([payload]) => payload);
+    const notfound = hashes.filter((hash) => !foundHashes.has(hash));
+    return [foundPayloads, notfound];
+  }
+  async getFromParents(hashes) {
+    const parents = Object.values((await this.parentArchivists())?.read ?? {});
+    let remainingHashes = [...hashes];
+    let parentIndex = 0;
+    let result = [];
+    while (parentIndex < parents.length && remainingHashes.length > 0) {
+      const parent = parents[parentIndex];
+      if (parent) {
+        const [found, notfound] = await this.getFromParent(remainingHashes, parent);
+        result = [...result, ...found];
+        remainingHashes = notfound;
+      }
+      parentIndex++;
+    }
+    return [result, remainingHashes];
+  }
+  getHandler(_hashes) {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  // eslint-disable-next-line max-statements
+  async getWithConfig(hashes, _config) {
+    const requestedHashes = new Set(hashes);
+    const cache = this._getCache;
+    let fromCache = [];
+    let remainingHashes = [...requestedHashes];
+    if (cache !== void 0) {
+      fromCache = hashes.map((hash) => cache.get(hash)).filter(exists);
+      remainingHashes = hashes.filter((hash) => !fromCache.some((payload) => payload?._hash === hash || payload?._dataHash === hash));
+    }
+    const fromGet = await this.getHandler([...remainingHashes]);
+    const gotten = [...fromCache, ...fromGet].toSorted(PayloadBuilder.compareStorageMeta);
+    const foundPayloads = [];
+    const foundHashes = /* @__PURE__ */ new Set();
+    for (const payload of gotten) {
+      const map = {
+        [payload._hash]: payload,
+        [payload._dataHash]: payload
+      };
+      for (const [key, payload2] of Object.entries(map)) {
+        let requestedPayloadFound = false;
+        const hash = key;
+        if (requestedHashes.has(hash) && !foundHashes.has(hash)) {
+          requestedPayloadFound = true;
+          foundHashes.add(hash);
+        }
+        if (requestedPayloadFound) foundPayloads.push(payload2);
+      }
+    }
+    const notFoundHashes = [...difference(requestedHashes, foundHashes)];
+    const [parentFoundPayloads] = await this.getFromParents(notFoundHashes);
+    if (this.storeParentReads) {
+      await this.insertWithConfig(parentFoundPayloads);
+    }
+    const result = this.omitClientMetaForDataHashes(
+      hashes,
+      PayloadBuilder.omitPrivateStorageMeta([
+        ...foundPayloads,
+        ...parentFoundPayloads
+      ]).toSorted(PayloadBuilder.compareStorageMeta)
+    );
+    if (cache !== void 0) {
+      for (const payload of fromGet) {
+        cache.set(payload._hash, payload);
+        cache.set(payload._dataHash, payload);
+      }
+      for (const payload of parentFoundPayloads) {
+        cache.set(payload._hash, payload);
+        cache.set(payload._dataHash, payload);
+      }
+    }
+    return result;
+  }
+  insertHandler(_payloads) {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  async insertQueryHandler(query, payloads) {
+    assertEx(payloads, () => `Missing payloads: ${JSON.stringify(query.payload, null, 2)}`);
+    const resolvedPayloads = await PayloadBuilder.filterIncludeByEitherHash(payloads, query.payloadHashes);
+    assertEx(
+      resolvedPayloads.length === query.payloadHashes.length,
+      () => `Could not find some passed hashes [${resolvedPayloads.length} != ${query.payloadHashes.length}]`
+    );
+    const queryPayload = await query.getQuery();
+    const payloadsWithoutQuery = await PayloadBuilder.filterExclude(resolvedPayloads, await PayloadBuilder.dataHash(queryPayload));
+    const result = await this.insertWithConfig(payloadsWithoutQuery);
+    return result;
+  }
+  async insertWithConfig(payloads, config) {
+    const emitEvents = config?.emitEvents ?? true;
+    const writeToParents = config?.writeToParents ?? true;
+    const withStorageMeta = await PayloadBuilder.addStorageMeta(payloads);
+    const hashes = withStorageMeta.map((p) => p._hash);
+    const existingPayloads = await this.getWithConfig(hashes);
+    const existingHashes = new Set(existingPayloads.map((p) => p._hash));
+    const payloadsToInsert = withStorageMeta.filter((p) => !existingHashes.has(p._hash));
+    const insertedPayloads = await this.insertHandler(payloadsToInsert);
+    if (writeToParents) {
+      await this.writeToParents(insertedPayloads);
+    }
+    if (emitEvents) {
+      await this.emit("inserted", {
+        mod: this,
+        payloads: insertedPayloads,
+        outPayloads: insertedPayloads,
+        inPayloads: payloads
+      });
+    }
+    this.reportPayloadCount();
+    return PayloadBuilder.omitPrivateStorageMeta(insertedPayloads);
+  }
+  nextHandler(_options) {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  async nextWithConfig(options, _config) {
+    const foundPayloads = await this.nextHandler(options);
+    return PayloadBuilder.omitPrivateStorageMeta(foundPayloads);
+  }
+  async parentArchivists() {
+    this._parentArchivists = this._parentArchivists ?? {
+      commit: { ...await this.resolveArchivists(this.config?.parents?.commit, this.params.parents?.commit) },
+      read: { ...await this.resolveArchivists(this.config?.parents?.read) },
+      write: { ...await this.resolveArchivists(this.config?.parents?.write) }
+    };
+    return assertEx(this._parentArchivists);
+  }
+  // the number of payloads in the archivist, -1 if not implemented
+  // the implementations of these must be fast, so they may not be promises and should read an auto updated value
+  payloadCountHandler() {
+    return -1;
+  }
+  // eslint-disable-next-line max-statements
+  async queryHandler(query, payloads, queryConfig) {
+    const sanitizedQuery = PayloadBuilder.omitStorageMeta(query);
+    const sanitizedPayloads = PayloadBuilder.omitStorageMeta(payloads);
+    const wrappedQuery = QueryBoundWitnessWrapper.parseQuery(sanitizedQuery, sanitizedPayloads);
+    const queryPayload = await wrappedQuery.getQuery();
+    assertEx(await this.queryable(sanitizedQuery, sanitizedPayloads, queryConfig));
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case ArchivistAllQuerySchema: {
+        resultPayloads.push(...await this.allHandler());
+        break;
+      }
+      case ArchivistClearQuerySchema: {
+        await this.clearHandler();
+        break;
+      }
+      case ArchivistCommitQuerySchema: {
+        resultPayloads.push(...await this.commitHandler());
+        break;
+      }
+      case ArchivistDeleteQuerySchema: {
+        const typedQueryPayload = queryPayload;
+        resultPayloads.push(...await this.deleteWithConfig(typedQueryPayload.hashes));
+        break;
+      }
+      case ArchivistGetQuerySchema: {
+        const typedQueryPayload = queryPayload;
+        resultPayloads.push(...await this.getWithConfig(typedQueryPayload.hashes ?? []));
+        break;
+      }
+      case ArchivistInsertQuerySchema: {
+        resultPayloads.push(...await this.insertQueryHandler(wrappedQuery, sanitizedPayloads));
+        break;
+      }
+      case ArchivistNextQuerySchema: {
+        const typedQueryPayload = queryPayload;
+        resultPayloads.push(...await this.nextHandler(typedQueryPayload));
+        break;
+      }
+      case ArchivistSnapshotQuerySchema: {
+        resultPayloads.push(...await this.snapshotHandler());
+        break;
+      }
+      default: {
+        const result = await super.queryHandler(sanitizedQuery, sanitizedPayloads);
+        if (this.config.storeQueries) {
+          await this.insertWithConfig([sanitizedQuery]);
+        }
+        return PayloadBuilder.omitPrivateStorageMeta(result);
+      }
+    }
+    if (this.config.storeQueries) {
+      await this.insertWithConfig([sanitizedQuery]);
+    }
+    return PayloadBuilder.omitPrivateStorageMeta(resultPayloads);
+  }
+  reportPayloadCount() {
+    this._noOverride("reportPayloadCount");
+    const gauge = this.payloadCountGauge;
+    if (gauge) {
+      gauge.record(this.payloadCountHandler());
+    }
+  }
+  snapshotHandler() {
+    throw new Error(NOT_IMPLEMENTED);
+  }
+  async startHandler() {
+    if (this.config.getCache?.enabled === true) {
+      this._getCache = new LRUCache({
+        max: this.config.getCache?.maxEntries ?? 1e4,
+        allowStale: true,
+        noDisposeOnSet: false,
+        updateAgeOnGet: true
+      });
+    }
+    const result = await super.startHandler();
+    this.reportPayloadCount();
+    return result;
+  }
+  async stateHandler() {
+    return [...await super.stateHandler(), await this.generateStats()];
+  }
+  async writeToParent(parent, payloads) {
+    return await parent.insert(PayloadBuilder.omitStorageMeta(payloads));
+  }
+  async writeToParents(payloads) {
+    const parents = await this.parentArchivists();
+    return (await Promise.all(
+      Object.values(parents.write ?? {}).map(async (parent) => {
+        return parent ? await this.writeToParent(parent, payloads) : void 0;
+      })
+    )).filter(exists).flat();
+  }
+  omitClientMetaForDataHashes(hashes, payloads) {
+    return payloads.map((payload) => {
+      if (hashes.includes(payload._dataHash) && !hashes.includes(payload._hash)) {
+        const result = PayloadBuilder.omitClientMeta(payload);
+        result._hash = result._dataHash;
+        return result;
+      } else {
+        return payload;
+      }
+    });
+  }
+  async resolveArchivists(archivists = [], archivistInstances) {
+    const archivistModules = (await Promise.all(archivists.map((archivist) => this.resolve(archivist)))).filter(exists).filter(duplicateModules);
+    assertEx(
+      !this.requireAllParents || archivistModules.length === archivists.length,
+      () => `Failed to find some archivists for ${this.modName} (set allRequired to false if ok)]`
+    );
+    const archivistInstancesMap = {};
+    for (const archivistInstance of archivistInstances ?? []) {
+      archivistInstancesMap[archivistInstance.address] = archivistInstance;
+    }
+    return archivistModules.reduce((prev, mod) => {
+      prev[mod.address] = asArchivistInstance(mod, () => {
+        isArchivistInstance(mod, { log: console });
+        return `Unable to cast resolved module to an archivist: [${mod.address}, ${mod.modName}, ${mod.config.schema})}]`;
+      }, { required: true });
+      return prev;
+    }, archivistInstancesMap);
+  }
+};
+export {
+  AbstractArchivist,
+  StorageClassLabel
+};

package/dist/_pkg/archivist-generic/neutral/Archivist.d.ts

@@ -0,0 +1,28 @@
+import type { BrandedHash, Hash, Promisable, PromisableArray } from '@xylabs/sdk';
+import { AbstractArchivist } from '../../archivist-abstract/neutral/index.ts';
+import type { ArchivistDriver, ArchivistModuleEventData, ArchivistNextOptions, ArchivistParams, ArchivistSnapshotPayload, AttachableArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { AnyConfigSchema, ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { AccountInstance, BoundWitness, Payload, Schema, WithStorageMeta } from '../../sdk-protocol/neutral/index.ts';
+import type { GenericArchivistConfig } from './Config.ts';
+export interface GenericArchivistParams<TConfig extends AnyConfigSchema<GenericArchivistConfig> = AnyConfigSchema<GenericArchivistConfig>> extends ArchivistParams<TConfig> {
+    driver?: ArchivistDriver<Hash, Payload, WithStorageMeta<Payload>>;
+}
+export declare class GenericArchivist<TParams extends GenericArchivistParams<AnyConfigSchema<GenericArchivistConfig>> = GenericArchivistParams, TEventData extends ArchivistModuleEventData = ArchivistModuleEventData> extends AbstractArchivist<TParams, TEventData> implements AttachableArchivistInstance, ModuleInstance {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly labels: {
+        'network.xyo.storage.class': string;
+    };
+    get queries(): Schema[];
+    protected get driver(): ArchivistDriver<BrandedHash, Payload, WithStorageMeta<Payload>>;
+    static from(payloads: Payload[], account?: AccountInstance): Promise<GenericArchivist>;
+    protected allHandler(): Promisable<WithStorageMeta<Payload>[]>;
+    protected clearHandler(): Promisable<void>;
+    protected commitHandler(): Promise<BoundWitness[]>;
+    protected deleteHandler(hashes: Hash[]): Promise<WithStorageMeta<Payload>[]>;
+    protected getHandler(hashes: Hash[]): Promisable<WithStorageMeta<Payload>[]>;
+    protected insertHandler(payloads: WithStorageMeta<Payload>[]): WithStorageMeta<Payload>[];
+    protected nextHandler(options?: ArchivistNextOptions): Promisable<WithStorageMeta<Payload>[]>;
+    protected payloadCountHandler(): number;
+    protected snapshotHandler(): PromisableArray<ArchivistSnapshotPayload<WithStorageMeta<Payload>, Hash>>;
+}

package/dist/_pkg/archivist-generic/neutral/Config.d.ts

@@ -0,0 +1,21 @@
+import type { EmptyObject, WithAdditional } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ArchivistConfig } from '../../archivist-model/neutral/index.ts';
+import { ArchivistConfigZod } from '../../archivist-model/neutral/index.ts';
+import { type Payload, type Schema } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const GenericArchivistConfigSchema: 'network.xyo.archivist.generic.config' & {
+    readonly __schema: true;
+};
+export type GenericArchivistConfigSchema = typeof GenericArchivistConfigSchema;
+export declare const GenericArchivistConfigZod: z.ZodMiniObject<Omit<(typeof ArchivistConfigZod)['shape'], 'schema'> & {
+    max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    schema: z.ZodMiniLiteral<GenericArchivistConfigSchema>;
+}, z.core.$strip>;
+export type GenericArchivistConfigBase = z.infer<typeof GenericArchivistConfigZod>;
+export declare const isGenericArchivistConfig: ReturnType<typeof zodIsFactory<GenericArchivistConfigBase>>;
+export declare const asGenericArchivistConfig: ReturnType<typeof zodAsFactory<GenericArchivistConfigBase>>;
+export declare const toGenericArchivistConfig: ReturnType<typeof zodToFactory<GenericArchivistConfigBase>>;
+export type GenericArchivistConfig<TConfig extends Payload | EmptyObject | void = void, TSchema extends Schema | void = void> = ArchivistConfig<WithAdditional<{
+    max?: number;
+}, TConfig>, TSchema extends Schema ? TSchema : GenericArchivistConfigSchema | ArchivistConfig['schema']>;

package/dist/_pkg/archivist-generic/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Archivist.ts';
+export * from './Config.ts';