@xyo-network/sdk 7.0.3 → 7.0.5

package/dist/_pkg/archivist-model/neutral/PayloadArchivist.d.ts

@@ -1,17 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import type { Payload, PayloadHashMap, Sequence, WithStorageMeta } from '../../sdk-protocol/neutral/index.ts';
-import type { AllArchivistFunctions, ReadArchivistFunctions, StashArchivistFunctions, WriteArchivistFunctions } from './ArchivistFunctions.ts';
-export interface AllArchivist<TReadResponse extends Payload = Payload, TId extends string = Hash> extends AllArchivistFunctions<WithStorageMeta<TReadResponse>, PayloadHashMap<WithStorageMeta<TReadResponse>, TId>> {
-}
-export interface ReadArchivist<TReadResponse extends Payload = Payload, TId extends string = Hash, TCursor extends string = Sequence> extends ReadArchivistFunctions<WithStorageMeta<TReadResponse>, TId, TCursor> {
-}
-export interface WriteArchivist<TReadResponse extends Payload = Payload, TWriteResponse extends Payload = TReadResponse, TWrite extends Payload = TReadResponse, TId extends string = Hash> extends WriteArchivistFunctions<WithStorageMeta<TReadResponse>, WithStorageMeta<TWriteResponse>, TWrite, TId> {
-}
-export interface ReadWriteArchivist<TReadResponse extends Payload = Payload, TWriteResponse extends Payload = TReadResponse, TWrite extends Payload = TReadResponse, TId extends string = Hash> extends WriteArchivist<TReadResponse, TWriteResponse, TWrite, TId>, ReadArchivist<TReadResponse, TId> {
-}
-export interface StashArchivist<TWriteResponse extends Payload = Payload> extends StashArchivistFunctions<WithStorageMeta<TWriteResponse>> {
-}
-export interface FullArchivist<TReadResponse extends Payload = Payload, TWriteResponse extends Payload = TReadResponse, TWrite extends Payload = TReadResponse, TId extends string = Hash> extends ReadWriteArchivist<TReadResponse, TWriteResponse, TWrite, TId>, StashArchivist<TWriteResponse> {
-}
-export interface Archivist<TReadResponse extends Payload = Payload, TWriteResponse extends Payload = Payload, TWrite extends Payload = TReadResponse & Payload, TId extends string = Hash, TCursor extends string = Sequence> extends ReadArchivist<WithStorageMeta<TReadResponse>, TId, TCursor>, AllArchivist<WithStorageMeta<TReadResponse>, TId>, WriteArchivist<WithStorageMeta<TReadResponse>, WithStorageMeta<TWriteResponse>, TWrite, TId>, StashArchivistFunctions<TWriteResponse> {
-}

package/dist/_pkg/archivist-model/neutral/Queries/All.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistAllQuerySchema: 'network.xyo.query.archivist.all' & {
-    readonly __schema: true;
-};
-export type ArchivistAllQuerySchema = typeof ArchivistAllQuerySchema;
-export declare const ArchivistAllQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistAllQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type ArchivistAllQuery = z.infer<typeof ArchivistAllQueryZod>;
-export declare const isArchivistAllQuery: ReturnType<typeof zodIsFactory<ArchivistAllQuery>>;
-export declare const asArchivistAllQuery: ReturnType<typeof zodAsFactory<ArchivistAllQuery>>;
-export declare const toArchivistAllQuery: ReturnType<typeof zodToFactory<ArchivistAllQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Clear.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistClearQuerySchema: 'network.xyo.query.archivist.clear' & {
-    readonly __schema: true;
-};
-export type ArchivistClearQuerySchema = typeof ArchivistClearQuerySchema;
-export declare const ArchivistClearQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistClearQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type ArchivistClearQuery = z.infer<typeof ArchivistClearQueryZod>;
-export declare const isArchivistClearQuery: ReturnType<typeof zodIsFactory<ArchivistClearQuery>>;
-export declare const asArchivistClearQuery: ReturnType<typeof zodAsFactory<ArchivistClearQuery>>;
-export declare const toArchivistClearQuery: ReturnType<typeof zodToFactory<ArchivistClearQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Commit.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistCommitQuerySchema: 'network.xyo.query.archivist.commit' & {
-    readonly __schema: true;
-};
-export type ArchivistCommitQuerySchema = typeof ArchivistCommitQuerySchema;
-export declare const ArchivistCommitQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistCommitQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type ArchivistCommitQuery = z.infer<typeof ArchivistCommitQueryZod>;
-export declare const isArchivistCommitQuery: ReturnType<typeof zodIsFactory<ArchivistCommitQuery>>;
-export declare const asArchivistCommitQuery: ReturnType<typeof zodAsFactory<ArchivistCommitQuery>>;
-export declare const toArchivistCommitQuery: ReturnType<typeof zodToFactory<ArchivistCommitQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Delete.d.ts

@@ -1,17 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistDeleteQuerySchema: 'network.xyo.query.archivist.delete' & {
-    readonly __schema: true;
-};
-export type ArchivistDeleteQuerySchema = typeof ArchivistDeleteQuerySchema;
-export declare const ArchivistDeleteQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistDeleteQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'] & {
-    hashes: z.ZodMiniArray<z.ZodMiniCustom<Hash, Hash>>;
-}, z.core.$strip>;
-export type ArchivistDeleteQuery = z.infer<typeof ArchivistDeleteQueryZod>;
-export declare const isArchivistDeleteQuery: ReturnType<typeof zodIsFactory<ArchivistDeleteQuery>>;
-export declare const asArchivistDeleteQuery: ReturnType<typeof zodAsFactory<ArchivistDeleteQuery>>;
-export declare const toArchivistDeleteQuery: ReturnType<typeof zodToFactory<ArchivistDeleteQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Get.d.ts

@@ -1,17 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistGetQuerySchema: 'network.xyo.query.archivist.get' & {
-    readonly __schema: true;
-};
-export type ArchivistGetQuerySchema = typeof ArchivistGetQuerySchema;
-export declare const ArchivistGetQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistGetQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'] & {
-    hashes: z.ZodMiniArray<z.ZodMiniCustom<Hash, Hash>>;
-}, z.core.$strip>;
-export type ArchivistGetQuery = z.infer<typeof ArchivistGetQueryZod>;
-export declare const isArchivistGetQuery: ReturnType<typeof zodIsFactory<ArchivistGetQuery>>;
-export declare const asArchivistGetQuery: ReturnType<typeof zodAsFactory<ArchivistGetQuery>>;
-export declare const toArchivistGetQuery: ReturnType<typeof zodToFactory<ArchivistGetQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Insert.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistInsertQuerySchema: 'network.xyo.query.archivist.insert' & {
-    readonly __schema: true;
-};
-export type ArchivistInsertQuerySchema = typeof ArchivistInsertQuerySchema;
-export declare const ArchivistInsertQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistInsertQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type ArchivistInsertQuery = z.infer<typeof ArchivistInsertQueryZod>;
-export declare const isArchivistInsertQuery: ReturnType<typeof zodIsFactory<ArchivistInsertQuery>>;
-export declare const asArchivistInsertQuery: ReturnType<typeof zodAsFactory<ArchivistInsertQuery>>;
-export declare const toArchivistInsertQuery: ReturnType<typeof zodToFactory<ArchivistInsertQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Next.d.ts

@@ -1,20 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import type { Sequence } from '../../../sdk-protocol/neutral/index.ts';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistNextQuerySchema: 'network.xyo.query.archivist.next' & {
-    readonly __schema: true;
-};
-export type ArchivistNextQuerySchema = typeof ArchivistNextQuerySchema;
-export declare const ArchivistNextQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistNextQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'] & {
-    cursor: z.ZodMiniOptional<z.ZodMiniCustom<Sequence, Sequence>>;
-    limit: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    open: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    order: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<'asc'>, z.ZodMiniLiteral<'desc'>]>>;
-}, z.core.$strip>;
-export type ArchivistNextQuery = z.infer<typeof ArchivistNextQueryZod>;
-export declare const isArchivistNextQuery: ReturnType<typeof zodIsFactory<ArchivistNextQuery>>;
-export declare const asArchivistNextQuery: ReturnType<typeof zodAsFactory<ArchivistNextQuery>>;
-export declare const toArchivistNextQuery: ReturnType<typeof zodToFactory<ArchivistNextQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/Snapshot.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ArchivistSnapshotQuerySchema: 'network.xyo.query.archivist.snapshot' & {
-    readonly __schema: true;
-};
-export type ArchivistSnapshotQuerySchema = typeof ArchivistSnapshotQuerySchema;
-export declare const ArchivistSnapshotQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ArchivistSnapshotQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type ArchivistSnapshotQuery = z.infer<typeof ArchivistSnapshotQueryZod>;
-export declare const isArchivistSnapshotQuery: ReturnType<typeof zodIsFactory<ArchivistSnapshotQuery>>;
-export declare const asArchivistSnapshotQuery: ReturnType<typeof zodAsFactory<ArchivistSnapshotQuery>>;
-export declare const toArchivistSnapshotQuery: ReturnType<typeof zodToFactory<ArchivistSnapshotQuery>>;

package/dist/_pkg/archivist-model/neutral/Queries/index.d.ts

@@ -1,19 +0,0 @@
-export * from './All.ts';
-export * from './Clear.ts';
-export * from './Commit.ts';
-export * from './Delete.ts';
-export * from './Get.ts';
-export * from './Insert.ts';
-export * from './Next.ts';
-export * from './Snapshot.ts';
-import type { ModuleQueries } from '../../../module-model/neutral/index.ts';
-import type { ArchivistAllQuery } from './All.ts';
-import type { ArchivistClearQuery } from './Clear.ts';
-import type { ArchivistCommitQuery } from './Commit.ts';
-import type { ArchivistDeleteQuery } from './Delete.ts';
-import type { ArchivistGetQuery } from './Get.ts';
-import type { ArchivistInsertQuery } from './Insert.ts';
-import type { ArchivistNextQuery } from './Next.ts';
-import type { ArchivistSnapshotQuery } from './Snapshot.ts';
-export type ArchivistQueries = ArchivistAllQuery | ArchivistClearQuery | ArchivistCommitQuery | ArchivistDeleteQuery | ArchivistGetQuery | ArchivistInsertQuery | ArchivistNextQuery | ArchivistSnapshotQuery;
-export type ArchivistModuleQueries = ModuleQueries | ArchivistQueries;

package/dist/_pkg/archivist-model/neutral/RawQueryFunctions.d.ts

@@ -1,13 +0,0 @@
-import type { Hash, Promisable } from '@xylabs/sdk';
-import type { ModuleQueryResult } from '../../module-model/neutral/index.ts';
-import type { AccountInstance, Payload } from '../../sdk-protocol/neutral/index.ts';
-import type { ArchivistNextOptions } from './NextOptions.ts';
-export interface ArchivistRawQueryFunctions {
-    allQuery(account?: AccountInstance): Promisable<ModuleQueryResult>;
-    clearQuery(account?: AccountInstance): Promisable<ModuleQueryResult>;
-    commitQuery(account?: AccountInstance): Promisable<ModuleQueryResult>;
-    deleteQuery(hashes: Hash[], account?: AccountInstance): Promisable<ModuleQueryResult>;
-    getQuery(hashes: Hash[], account?: AccountInstance): Promisable<ModuleQueryResult>;
-    insertQuery(payloads: Payload[], account?: AccountInstance): Promisable<ModuleQueryResult>;
-    nextQuery(options?: ArchivistNextOptions, account?: AccountInstance): Promisable<ModuleQueryResult>;
-}

package/dist/_pkg/archivist-model/neutral/attachable/AttachableInstance.d.ts

@@ -1,12 +0,0 @@
-import type { TypeCheck } from '@xylabs/sdk';
-import { IsObjectFactory } from '@xylabs/sdk';
-import type { AttachableModuleInstance } from '../../../module-model/neutral/index.ts';
-import type { Payload } from '../../../sdk-protocol/neutral/index.ts';
-import type { ArchivistModuleEventData } from '../EventData.ts';
-import type { ArchivistInstance, ArchivistParams } from '../Instance.ts';
-import type { ArchivistModuleInstance } from '../ModuleInstance.ts';
-export interface AttachableArchivistInstance<TParams extends ArchivistParams = ArchivistParams, TEventData extends ArchivistModuleEventData = ArchivistModuleEventData, TPayload extends Payload = Payload> extends ArchivistModuleInstance<TParams, TEventData>, AttachableModuleInstance<TParams, TEventData>, ArchivistInstance<TParams, TEventData, TPayload> {
-}
-export type AttachableArchivistInstanceTypeCheck<T extends AttachableArchivistInstance = AttachableArchivistInstance> = TypeCheck<T>;
-export declare class IsAttachableArchivistInstanceFactory<T extends AttachableArchivistInstance = AttachableArchivistInstance> extends IsObjectFactory<T> {
-}

package/dist/_pkg/archivist-model/neutral/attachable/asAttachableInstance.d.ts

@@ -1 +0,0 @@
-export declare const asAttachableArchivistInstance: import("@xylabs/sdk").AsTypeFunction<import("./AttachableInstance.ts").AttachableArchivistInstance<import("../Instance.ts").ArchivistParams<import("../../../module-model/neutral/index.ts").AnyConfigSchema<import("../Config.ts").ArchivistConfig>>, import("../EventData.ts").ArchivistModuleEventData, import("../../../sdk-protocol/neutral/index.ts").Payload>>;

package/dist/_pkg/archivist-model/neutral/attachable/index.d.ts

@@ -1,3 +0,0 @@
-export * from './asAttachableInstance.ts';
-export * from './AttachableInstance.ts';
-export * from './isAttachableInstance.ts';

package/dist/_pkg/archivist-model/neutral/attachable/isAttachableInstance.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk';
-import type { AttachableArchivistInstance } from './AttachableInstance.ts';
-export declare const requiredAttachableArchivistInstanceFunctions: ObjectTypeShape;
-export declare const isAttachableArchivistInstance: TypeCheck<AttachableArchivistInstance>;

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

@@ -1,17 +0,0 @@
-export * from './ArchivistDriver.ts';
-export * from './ArchivistFunctions.ts';
-export * from './ArchivistSnapshot.ts';
-export * from './ArchivistStats.ts';
-export * from './attachable/index.ts';
-export * from './Config.ts';
-export * from './EventData.ts';
-export * from './IndexDescription.ts';
-export * from './Instance.ts';
-export * from './Labels.ts';
-export * from './lib/index.ts';
-export * from './ModuleInstance.ts';
-export * from './NextOptions.ts';
-export * from './PayloadArchivist.ts';
-export * from './Queries/index.ts';
-export * from './RawQueryFunctions.ts';
-export * from './typeChecks.ts';

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

@@ -1,368 +0,0 @@
-// src/ArchivistSnapshot.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@xylabs/sdk";
-import { asSchema, PayloadZodOfSchema } from "../../sdk-protocol/neutral/index.mjs";
-import * as z from "zod/mini";
-var ArchivistSnapshotPayloadSchema = asSchema("network.xyo.archivist.snapshot", true);
-var ArchivistSnapshotPayloadZod = z.intersection(PayloadZodOfSchema(ArchivistSnapshotPayloadSchema), z.custom());
-var isArchivistSnapshotPayloadInternal = zodIsFactory(ArchivistSnapshotPayloadZod);
-var isArchivistSnapshotPayload = (payload) => isArchivistSnapshotPayloadInternal(payload);
-var asArchivistSnapshotPayload = zodAsFactory(ArchivistSnapshotPayloadZod, "asArchivistSnapshotPayload");
-var toArchivistSnapshotPayload = zodToFactory(ArchivistSnapshotPayloadZod, "toArchivistSnapshotPayload");
-
-// src/ArchivistStats.ts
-import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory as zodToFactory2
-} from "@xylabs/sdk";
-import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "../../sdk-protocol/neutral/index.mjs";
-import * as z2 from "zod/mini";
-var ArchivistStatsPayloadSchema = asSchema2("network.xyo.archivist.stats", true);
-var ArchivistStatsPayloadZod = z2.extend(PayloadZodOfSchema2(ArchivistStatsPayloadSchema), { payloadCount: z2.number() });
-var isArchivistStatsPayload = zodIsFactory2(ArchivistStatsPayloadZod);
-var asArchivistStatsPayload = zodAsFactory2(ArchivistStatsPayloadZod, "asArchivistStatsPayload");
-var toArchivistStatsPayload = zodToFactory2(ArchivistStatsPayloadZod, "toArchivistStatsPayload");
-
-// src/attachable/asAttachableInstance.ts
-import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk";
-
-// src/attachable/isAttachableInstance.ts
-import { IsObjectFactory } from "@xylabs/sdk";
-import { isAttachableModuleInstance } from "../../module-model/neutral/index.mjs";
-
-// src/typeChecks.ts
-import { AsObjectFactory } from "@xylabs/sdk";
-import {
-  IsInstanceFactory,
-  isModuleInstance,
-  IsQueryableModuleFactory,
-  WithFactory
-} from "../../module-model/neutral/index.mjs";
-
-// src/Queries/All.ts
-import {
-  zodAsFactory as zodAsFactory3,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory3
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema3,
-  PayloadZodOfSchema as PayloadZodOfSchema3,
-  QueryFieldsZod
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z3 from "zod/mini";
-var ArchivistAllQuerySchema = asSchema3("network.xyo.query.archivist.all", true);
-var ArchivistAllQueryZod = z3.extend(PayloadZodOfSchema3(ArchivistAllQuerySchema), { ...QueryFieldsZod.shape });
-var isArchivistAllQuery = zodIsFactory3(ArchivistAllQueryZod);
-var asArchivistAllQuery = zodAsFactory3(ArchivistAllQueryZod, "asArchivistAllQuery");
-var toArchivistAllQuery = zodToFactory3(ArchivistAllQueryZod, "toArchivistAllQuery");
-
-// src/Queries/Clear.ts
-import {
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory4,
-  zodToFactory as zodToFactory4
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema4,
-  PayloadZodOfSchema as PayloadZodOfSchema4,
-  QueryFieldsZod as QueryFieldsZod2
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z4 from "zod/mini";
-var ArchivistClearQuerySchema = asSchema4("network.xyo.query.archivist.clear", true);
-var ArchivistClearQueryZod = z4.extend(PayloadZodOfSchema4(ArchivistClearQuerySchema), { ...QueryFieldsZod2.shape });
-var isArchivistClearQuery = zodIsFactory4(ArchivistClearQueryZod);
-var asArchivistClearQuery = zodAsFactory4(ArchivistClearQueryZod, "asArchivistClearQuery");
-var toArchivistClearQuery = zodToFactory4(ArchivistClearQueryZod, "toArchivistClearQuery");
-
-// src/Queries/Commit.ts
-import {
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory5
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema5,
-  PayloadZodOfSchema as PayloadZodOfSchema5,
-  QueryFieldsZod as QueryFieldsZod3
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z5 from "zod/mini";
-var ArchivistCommitQuerySchema = asSchema5("network.xyo.query.archivist.commit", true);
-var ArchivistCommitQueryZod = z5.extend(PayloadZodOfSchema5(ArchivistCommitQuerySchema), { ...QueryFieldsZod3.shape });
-var isArchivistCommitQuery = zodIsFactory5(ArchivistCommitQueryZod);
-var asArchivistCommitQuery = zodAsFactory5(ArchivistCommitQueryZod, "asArchivistCommitQuery");
-var toArchivistCommitQuery = zodToFactory5(ArchivistCommitQueryZod, "toArchivistCommitQuery");
-
-// src/Queries/Delete.ts
-import {
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory6,
-  zodToFactory as zodToFactory6
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema6,
-  PayloadZodOfSchema as PayloadZodOfSchema6,
-  QueryFieldsZod as QueryFieldsZod4
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z6 from "zod/mini";
-var ArchivistDeleteQuerySchema = asSchema6("network.xyo.query.archivist.delete", true);
-var ArchivistDeleteQueryZod = z6.extend(PayloadZodOfSchema6(ArchivistDeleteQuerySchema), {
-  ...QueryFieldsZod4.shape,
-  hashes: z6.array(z6.custom())
-});
-var isArchivistDeleteQuery = zodIsFactory6(ArchivistDeleteQueryZod);
-var asArchivistDeleteQuery = zodAsFactory6(ArchivistDeleteQueryZod, "asArchivistDeleteQuery");
-var toArchivistDeleteQuery = zodToFactory6(ArchivistDeleteQueryZod, "toArchivistDeleteQuery");
-
-// src/Queries/Get.ts
-import {
-  zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory7,
-  zodToFactory as zodToFactory7
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema7,
-  PayloadZodOfSchema as PayloadZodOfSchema7,
-  QueryFieldsZod as QueryFieldsZod5
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z7 from "zod/mini";
-var ArchivistGetQuerySchema = asSchema7("network.xyo.query.archivist.get", true);
-var ArchivistGetQueryZod = z7.extend(PayloadZodOfSchema7(ArchivistGetQuerySchema), {
-  ...QueryFieldsZod5.shape,
-  hashes: z7.array(z7.custom())
-});
-var isArchivistGetQuery = zodIsFactory7(ArchivistGetQueryZod);
-var asArchivistGetQuery = zodAsFactory7(ArchivistGetQueryZod, "asArchivistGetQuery");
-var toArchivistGetQuery = zodToFactory7(ArchivistGetQueryZod, "toArchivistGetQuery");
-
-// src/Queries/Insert.ts
-import {
-  zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory8,
-  zodToFactory as zodToFactory8
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema8,
-  PayloadZodOfSchema as PayloadZodOfSchema8,
-  QueryFieldsZod as QueryFieldsZod6
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z8 from "zod/mini";
-var ArchivistInsertQuerySchema = asSchema8("network.xyo.query.archivist.insert", true);
-var ArchivistInsertQueryZod = z8.extend(PayloadZodOfSchema8(ArchivistInsertQuerySchema), { ...QueryFieldsZod6.shape });
-var isArchivistInsertQuery = zodIsFactory8(ArchivistInsertQueryZod);
-var asArchivistInsertQuery = zodAsFactory8(ArchivistInsertQueryZod, "asArchivistInsertQuery");
-var toArchivistInsertQuery = zodToFactory8(ArchivistInsertQueryZod, "toArchivistInsertQuery");
-
-// src/Queries/Next.ts
-import {
-  zodAsFactory as zodAsFactory9,
-  zodIsFactory as zodIsFactory9,
-  zodToFactory as zodToFactory9
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema9,
-  PayloadZodOfSchema as PayloadZodOfSchema9,
-  QueryFieldsZod as QueryFieldsZod7
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z9 from "zod/mini";
-var ArchivistNextQuerySchema = asSchema9("network.xyo.query.archivist.next", true);
-var ArchivistNextQueryZod = z9.extend(PayloadZodOfSchema9(ArchivistNextQuerySchema), {
-  ...QueryFieldsZod7.shape,
-  cursor: z9.optional(z9.custom()),
-  limit: z9.optional(z9.number()),
-  open: z9.optional(z9.boolean()),
-  order: z9.optional(z9.union([z9.literal("asc"), z9.literal("desc")]))
-});
-var isArchivistNextQuery = zodIsFactory9(ArchivistNextQueryZod);
-var asArchivistNextQuery = zodAsFactory9(ArchivistNextQueryZod, "asArchivistNextQuery");
-var toArchivistNextQuery = zodToFactory9(ArchivistNextQueryZod, "toArchivistNextQuery");
-
-// src/Queries/Snapshot.ts
-import {
-  zodAsFactory as zodAsFactory10,
-  zodIsFactory as zodIsFactory10,
-  zodToFactory as zodToFactory10
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema10,
-  PayloadZodOfSchema as PayloadZodOfSchema10,
-  QueryFieldsZod as QueryFieldsZod8
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z10 from "zod/mini";
-var ArchivistSnapshotQuerySchema = asSchema10("network.xyo.query.archivist.snapshot", true);
-var ArchivistSnapshotQueryZod = z10.extend(PayloadZodOfSchema10(ArchivistSnapshotQuerySchema), { ...QueryFieldsZod8.shape });
-var isArchivistSnapshotQuery = zodIsFactory10(ArchivistSnapshotQueryZod);
-var asArchivistSnapshotQuery = zodAsFactory10(ArchivistSnapshotQueryZod, "asArchivistSnapshotQuery");
-var toArchivistSnapshotQuery = zodToFactory10(ArchivistSnapshotQueryZod, "toArchivistSnapshotQuery");
-
-// src/typeChecks.ts
-var isArchivistInstance = new IsInstanceFactory().create({ get: "function" }, [isModuleInstance]);
-var isArchivistModule = new IsQueryableModuleFactory().create([ArchivistGetQuerySchema]);
-var asArchivistModule = AsObjectFactory.create(isArchivistModule);
-var asArchivistInstance = AsObjectFactory.create(isArchivistInstance);
-var withArchivistModule = WithFactory.create(isArchivistModule);
-var withArchivistInstance = WithFactory.create(isArchivistInstance);
-
-// src/attachable/isAttachableInstance.ts
-var requiredAttachableArchivistInstanceFunctions = {};
-var factory = new IsObjectFactory();
-var isAttachableArchivistInstance = factory.create(requiredAttachableArchivistInstanceFunctions, [
-  isArchivistInstance,
-  isAttachableModuleInstance
-]);
-
-// src/attachable/asAttachableInstance.ts
-var asAttachableArchivistInstance = AsObjectFactory2.create(isAttachableArchivistInstance);
-
-// src/attachable/AttachableInstance.ts
-import { IsObjectFactory as IsObjectFactory2 } from "@xylabs/sdk";
-var IsAttachableArchivistInstanceFactory = class extends IsObjectFactory2 {
-};
-
-// src/Config.ts
-import {
-  zodAsFactory as zodAsFactory11,
-  zodIsFactory as zodIsFactory11,
-  zodToFactory as zodToFactory11
-} from "@xylabs/sdk";
-import { ModuleConfigZod } from "../../module-model/neutral/index.mjs";
-import { asSchema as asSchema11 } from "../../sdk-protocol/neutral/index.mjs";
-import * as z11 from "zod/mini";
-var ArchivistConfigSchema = asSchema11("network.xyo.archivist.config", true);
-var ArchivistConfigZod = z11.extend(ModuleConfigZod, {
-  getCache: z11.optional(z11.custom()),
-  parents: z11.optional(z11.custom()),
-  requireAllParents: z11.optional(z11.boolean()),
-  schema: z11.literal(ArchivistConfigSchema),
-  storage: z11.optional(z11.custom()),
-  storeParentReads: z11.optional(z11.boolean())
-});
-var isArchivistConfig = zodIsFactory11(ArchivistConfigZod);
-var asArchivistConfig = zodAsFactory11(ArchivistConfigZod, "asArchivistConfig");
-var toArchivistConfig = zodToFactory11(ArchivistConfigZod, "toArchivistConfig");
-
-// src/IndexDescription.ts
-var IndexSeparator = "-";
-var buildStandardIndexName = (index) => {
-  const { key, unique } = index;
-  const prefix = unique ? "UX" : "IX";
-  const indexKeys = Object.keys(key);
-  return `${prefix}_${indexKeys.join(IndexSeparator)}`;
-};
-
-// src/lib/getBoundWitness.ts
-import { assertEx } from "@xylabs/sdk";
-import {
-  isBoundWitness,
-  isStorageMeta
-} from "../../sdk-protocol/neutral/index.mjs";
-var tryGetTypedBoundWitnessWithStorageMeta = async (archivist, hash, identity) => {
-  const payload = (await archivist.get([hash])).at(0);
-  return identity(payload) ? payload : void 0;
-};
-var getTypedBoundWitnessWithStorageMeta = async (archivist, hash, identity) => {
-  const payload = assertEx((await archivist.get([hash])).at(0), () => `failed to locate bound witness: ${hash}`);
-  return assertEx(identity(payload) ? payload : void 0, () => `located payload failed identity check: ${hash}`);
-};
-var getBoundWitnessWithStorageMeta = (archivist, hash) => {
-  return getTypedBoundWitnessWithStorageMeta(archivist, hash, (x) => isStorageMeta(x) && isBoundWitness(x));
-};
-
-// src/lib/hydrateBoundWitness.ts
-import { exists, isHash } from "@xylabs/sdk";
-import { isBoundWitness as isBoundWitness2, isStorageMeta as isStorageMeta2 } from "../../sdk-protocol/neutral/index.mjs";
-var tryHydrateTypedBoundWitness = async (archivist, hashOrBw, identity) => {
-  const bw = isHash(hashOrBw) ? await tryGetTypedBoundWitnessWithStorageMeta(archivist, hashOrBw, identity) : hashOrBw;
-  return bw ? [bw, (await archivist.get(bw?.payload_hashes)).filter(exists)] : void 0;
-};
-var hydrateTypedBoundWitness = async (archivist, hashOrBw, identity) => {
-  const bw = isHash(hashOrBw) ? await getTypedBoundWitnessWithStorageMeta(archivist, hashOrBw, identity) : hashOrBw;
-  const payloads = (await archivist.get(bw?.payload_hashes)).filter(exists);
-  if (payloads.length !== bw.payload_hashes.length) {
-    throw new Error(`missing payloads for ${bw._hash}`);
-  }
-  return [bw, payloads];
-};
-var hydrateBoundWitness = (archivist, hashOrBw) => {
-  const idFunction = (x) => isBoundWitness2(x) && isStorageMeta2(x);
-  return hydrateTypedBoundWitness(archivist, hashOrBw, idFunction);
-};
-export {
-  ArchivistAllQuerySchema,
-  ArchivistAllQueryZod,
-  ArchivistClearQuerySchema,
-  ArchivistClearQueryZod,
-  ArchivistCommitQuerySchema,
-  ArchivistCommitQueryZod,
-  ArchivistConfigSchema,
-  ArchivistConfigZod,
-  ArchivistDeleteQuerySchema,
-  ArchivistDeleteQueryZod,
-  ArchivistGetQuerySchema,
-  ArchivistGetQueryZod,
-  ArchivistInsertQuerySchema,
-  ArchivistInsertQueryZod,
-  ArchivistNextQuerySchema,
-  ArchivistNextQueryZod,
-  ArchivistSnapshotPayloadSchema,
-  ArchivistSnapshotPayloadZod,
-  ArchivistSnapshotQuerySchema,
-  ArchivistSnapshotQueryZod,
-  ArchivistStatsPayloadSchema,
-  ArchivistStatsPayloadZod,
-  IndexSeparator,
-  IsAttachableArchivistInstanceFactory,
-  asArchivistAllQuery,
-  asArchivistClearQuery,
-  asArchivistCommitQuery,
-  asArchivistConfig,
-  asArchivistDeleteQuery,
-  asArchivistGetQuery,
-  asArchivistInsertQuery,
-  asArchivistInstance,
-  asArchivistModule,
-  asArchivistNextQuery,
-  asArchivistSnapshotPayload,
-  asArchivistSnapshotQuery,
-  asArchivistStatsPayload,
-  asAttachableArchivistInstance,
-  buildStandardIndexName,
-  getBoundWitnessWithStorageMeta,
-  getTypedBoundWitnessWithStorageMeta,
-  hydrateBoundWitness,
-  hydrateTypedBoundWitness,
-  isArchivistAllQuery,
-  isArchivistClearQuery,
-  isArchivistCommitQuery,
-  isArchivistConfig,
-  isArchivistDeleteQuery,
-  isArchivistGetQuery,
-  isArchivistInsertQuery,
-  isArchivistInstance,
-  isArchivistModule,
-  isArchivistNextQuery,
-  isArchivistSnapshotPayload,
-  isArchivistSnapshotQuery,
-  isArchivistStatsPayload,
-  isAttachableArchivistInstance,
-  requiredAttachableArchivistInstanceFunctions,
-  toArchivistAllQuery,
-  toArchivistClearQuery,
-  toArchivistCommitQuery,
-  toArchivistConfig,
-  toArchivistDeleteQuery,
-  toArchivistGetQuery,
-  toArchivistInsertQuery,
-  toArchivistNextQuery,
-  toArchivistSnapshotPayload,
-  toArchivistSnapshotQuery,
-  toArchivistStatsPayload,
-  tryGetTypedBoundWitnessWithStorageMeta,
-  tryHydrateTypedBoundWitness,
-  withArchivistInstance,
-  withArchivistModule
-};

package/dist/_pkg/archivist-model/neutral/lib/HydratedBoundWitness.d.ts

@@ -1,7 +0,0 @@
-import type { BoundWitness, Payload, Signed, WithHashMeta, WithStorageMeta } from '../../../sdk-protocol/neutral/index.ts';
-export type HydratedBoundWitness<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [T, P[]];
-export type HydratedBoundWitnessWithHashMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [WithHashMeta<T>, WithHashMeta<P>[]];
-export type HydratedBoundWitnessWithStorageMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [WithStorageMeta<T>, WithStorageMeta<P>[]];
-export type SignedHydratedBoundWitness<T extends Signed<BoundWitness> = Signed<BoundWitness>, P extends Payload = Payload> = [T, P[]];
-export type SignedHydratedBoundWitnessWithHashMeta<T extends Signed<BoundWitness> = Signed<BoundWitness>, P extends Payload = Payload> = [WithHashMeta<T>, WithHashMeta<P>[]];
-export type SignedHydratedBoundWitnessWithStorageMeta<T extends Signed<BoundWitness> = Signed<BoundWitness>, P extends Payload = Payload> = [WithStorageMeta<T>, WithStorageMeta<P>[]];

package/dist/_pkg/archivist-model/neutral/lib/getBoundWitness.d.ts

@@ -1,6 +0,0 @@
-import type { Hash, IdentityFunction } from '@xylabs/sdk';
-import { type BoundWitness, type WithStorageMeta } from '../../../sdk-protocol/neutral/index.ts';
-import type { ReadArchivist } from '../PayloadArchivist.ts';
-export declare const tryGetTypedBoundWitnessWithStorageMeta: <T extends BoundWitness>(archivist: ReadArchivist, hash: Hash, identity: IdentityFunction<WithStorageMeta<T>>) => Promise<WithStorageMeta<T> | undefined>;
-export declare const getTypedBoundWitnessWithStorageMeta: <T extends BoundWitness>(archivist: ReadArchivist, hash: Hash, identity: IdentityFunction<WithStorageMeta<T>>) => Promise<WithStorageMeta<T>>;
-export declare const getBoundWitnessWithStorageMeta: (archivist: ReadArchivist, hash: Hash) => Promise<WithStorageMeta<BoundWitness>>;

package/dist/_pkg/archivist-model/neutral/lib/hydrateBoundWitness.d.ts

@@ -1,7 +0,0 @@
-import type { Hash, IdentityFunction } from '@xylabs/sdk';
-import type { BoundWitness, WithStorageMeta } from '../../../sdk-protocol/neutral/index.ts';
-import type { ReadArchivist } from '../PayloadArchivist.ts';
-import type { HydratedBoundWitness } from './HydratedBoundWitness.ts';
-export declare const tryHydrateTypedBoundWitness: <T extends BoundWitness>(archivist: ReadArchivist, hashOrBw: Hash | WithStorageMeta<T>, identity: IdentityFunction<WithStorageMeta<T>>) => Promise<HydratedBoundWitness<T> | undefined>;
-export declare const hydrateTypedBoundWitness: <T extends BoundWitness>(archivist: ReadArchivist, hashOrBw: Hash | WithStorageMeta<T>, identity: IdentityFunction<WithStorageMeta<T>>) => Promise<HydratedBoundWitness<T>>;
-export declare const hydrateBoundWitness: (archivist: ReadArchivist, hashOrBw: Hash | WithStorageMeta<BoundWitness>) => Promise<HydratedBoundWitness<BoundWitness>>;

package/dist/_pkg/archivist-model/neutral/lib/index.d.ts

@@ -1,3 +0,0 @@
-export * from './getBoundWitness.ts';
-export * from './hydrateBoundWitness.ts';
-export * from './HydratedBoundWitness.ts';