@xyo-network/sdk 7.0.3 → 7.0.4

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

@@ -1,562 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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