@xyo-network/sdk 7.0.3 → 7.0.4

package/dist/_pkg/domain-payload-plugin/neutral/index.mjs

@@ -1,484 +0,0 @@
-// src/DomainConfigPayload.ts
-import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory as zodToFactory2
-} from "@xylabs/sdk";
-import { PayloadZodOfSchema as PayloadZodOfSchema2 } from "../../payload-model/neutral/index.mjs";
-import * as z2 from "zod/mini";
-
-// src/DomainConfigSchema.ts
-import { asSchema } from "../../payload-model/neutral/index.mjs";
-var DomainConfigSchema = asSchema("network.xyo.domain.config", true);
-
-// src/Payload.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@xylabs/sdk";
-import { PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
-import * as z from "zod/mini";
-
-// src/Schema.ts
-import { asSchema as asSchema2 } from "../../payload-model/neutral/index.mjs";
-var DomainSchema = asSchema2("network.xyo.domain", true);
-
-// src/Payload.ts
-var AliasZod = z.object({
-  /** huri to the aliased payload */
-  huri: z.string(),
-  /** canonical name (ex. network.xyo.example) */
-  name: z.optional(z.string())
-});
-var SchemaDefinitionZod = z.looseObject({ $id: z.optional(z.string()) });
-var SchemaMapEntryZod = z.union([z.string(), SchemaDefinitionZod]);
-var stringZod = z.string();
-var optionalStringArrayZod = z.optional(z.array(stringZod));
-var optionalAliasRecordZod = z.optional(z.record(stringZod, AliasZod));
-var networkPayloadZod = z.custom();
-var optionalNetworkPayloadArrayZod = z.optional(z.array(networkPayloadZod));
-var optionalSchemaMapEntryRecordZod = z.optional(z.record(stringZod, SchemaMapEntryZod));
-var DomainConfigFieldsZod = z.object({
-  /** Additional config files [huri] [out] */
-  additional: optionalStringArrayZod,
-  /** Values associated with this domain [out] */
-  aliases: optionalAliasRecordZod,
-  /** Known networks [out] */
-  networks: optionalNetworkPayloadArrayZod,
-  /** Official schemas published by this domain, keyed by schema name [out] */
-  schemas: optionalSchemaMapEntryRecordZod
-});
-var DomainPayloadZod = z.extend(PayloadZodOfSchema(DomainSchema), DomainConfigFieldsZod.shape);
-var isDomainPayload = zodIsFactory(DomainPayloadZod);
-var asDomainPayload = zodAsFactory(DomainPayloadZod, "asDomainPayload");
-var toDomainPayload = zodToFactory(DomainPayloadZod, "toDomainPayload");
-
-// src/DomainConfigPayload.ts
-var DomainConfigPayloadZod = z2.extend(PayloadZodOfSchema2(DomainConfigSchema), DomainConfigFieldsZod.shape);
-var isDomainConfigPayload = zodIsFactory2(DomainConfigPayloadZod);
-var asDomainConfigPayload = zodAsFactory2(DomainConfigPayloadZod, "asDomainConfigPayload");
-var toDomainConfigPayload = zodToFactory2(DomainConfigPayloadZod, "toDomainConfigPayload");
-
-// src/DomainConfigPlugin.ts
-import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
-
-// src/DomainConfigTemplate.ts
-var domainConfigPayloadTemplate = () => ({
-  schema: DomainConfigSchema,
-  schemas: {
-    "com.example.inline": {
-      properties: { value: { type: "string" } },
-      type: "object"
-    },
-    "com.example.referenced": ""
-  }
-});
-
-// src/DomainConfigPlugin.ts
-var DomainConfigPayloadPlugin = () => createPayloadPlugin({
-  schema: DomainConfigSchema,
-  template: domainConfigPayloadTemplate,
-  zod: DomainConfigPayloadZod
-});
-
-// src/Plugin.ts
-import { createPayloadPlugin as createPayloadPlugin2 } from "../../payload-plugin/neutral/index.mjs";
-
-// src/Template.ts
-import { asSchema as asSchema3 } from "../../payload-model/neutral/index.mjs";
-var domainConfigTemplate = () => ({
-  aliases: { "com.example.id": { huri: "" } },
-  networks: [
-    {
-      name: "",
-      nodes: [
-        {
-          name: "",
-          schema: asSchema3("network.xyo.network.node", true),
-          slug: "",
-          type: "archivist",
-          uri: ""
-        }
-      ],
-      schema: asSchema3("network.xyo.network", true),
-      slug: ""
-    }
-  ],
-  schema: DomainSchema
-});
-
-// src/Wrapper.ts
-import {
-  Base,
-  FetchClientError,
-  fetchJson,
-  isBrowser,
-  isString
-} from "@xylabs/sdk";
-import { isHash as isHash2 } from "@xylabs/sdk";
-import { DnsRecordType, domainResolve } from "../../dns/neutral/index.mjs";
-import { Huri } from "../../huri/neutral/index.mjs";
-import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
-import { PayloadWrapper } from "../../payload-wrapper/neutral/index.mjs";
-
-// src/Resolution/XyoDnsRecords.ts
-import { isHash } from "@xylabs/sdk";
-var SCHEMA_KEY_PREFIX = "schema.";
-function normalizeTxtData(data) {
-  const trimmed = data.trim();
-  if (trimmed.includes('"')) {
-    const quotedParts = Array.from(trimmed.matchAll(/"([^"]*)"/g), (match) => match[1]);
-    return quotedParts.join("") || trimmed;
-  }
-  return trimmed;
-}
-function parseXyoTxtRecords(answers) {
-  const entries = (answers ?? []).map((answer) => answer.data).filter((data) => typeof data === "string").map(normalizeTxtData).toSorted((left, right) => left.localeCompare(right));
-  const records = { legacyHashes: [], schemas: {} };
-  for (const entry of entries) {
-    if (isHash(entry)) {
-      records.legacyHashes.push(entry);
-    } else if (entry.startsWith(SCHEMA_KEY_PREFIX)) {
-      const separatorIndex = entry.indexOf("=");
-      if (separatorIndex > SCHEMA_KEY_PREFIX.length) {
-        const name = entry.slice(SCHEMA_KEY_PREFIX.length, separatorIndex);
-        const value = entry.slice(separatorIndex + 1);
-        if (name.length > 0 && value.length > 0) {
-          records.schemas[name] ??= value;
-        }
-      }
-    } else if (entry.startsWith("domain=")) {
-      const value = entry.slice("domain=".length);
-      if (value.length > 0) {
-        records.domain ??= value;
-      }
-    } else if (entry.startsWith("config=")) {
-      const value = entry.slice("config=".length);
-      if (value.length > 0) {
-        records.config ??= value;
-      }
-    }
-  }
-  return records;
-}
-
-// src/Wrapper.ts
-var DomainPayloadWrapper = class _DomainPayloadWrapper extends PayloadWrapper {
-  aliases;
-  static async discover(reverseDomainName, proxy) {
-    const parts = reverseDomainName.split(".");
-    for (let i = 2; i <= parts.length; i++) {
-      const domainToCheck = parts.filter((_, index) => index < i).toReversed().join(".");
-      const result = await this.discoverDNSEntry(domainToCheck) ?? await this.discoverRootFile(domainToCheck, proxy);
-      if (result) {
-        return result;
-      }
-    }
-  }
-  static async discoverDNSEntry(domain) {
-    try {
-      const { Answer } = await domainResolve(`_xyo.${domain}`, DnsRecordType.TXT) ?? {};
-      const records = parseXyoTxtRecords(Answer);
-      const candidates = [records.config, ...records.legacyHashes].filter((element) => isString(element));
-      for (const candidate of candidates) {
-        const huri = new Huri(candidate);
-        const payload = await huri.fetch();
-        if (isDomainPayload(payload) || isDomainConfigPayload(payload)) {
-          return new _DomainPayloadWrapper(payload);
-        }
-      }
-    } catch {
-      Base.defaultLogger?.log(`DomainConfig dns reading error entry not found [${domain}]`);
-    }
-  }
-  static async discoverRootFile(domain, proxy) {
-    return await this.discoverRootFileDirect(domain) ?? (isBrowser() || isString(proxy) ? await this.discoverRootFileWithProxy(domain, proxy) : void 0);
-  }
-  static async discoverRootFileDirect(domain) {
-    const urls = [`https://${domain}/xyo.json`, `https://xyo.${domain}/`, `https://${domain}/xyo-config.json`];
-    for (const url of urls) {
-      try {
-        const response = await fetchJson(url);
-        if (response.data) {
-          return new _DomainPayloadWrapper(response.data);
-        }
-      } catch {
-        console.log(`DomainConfig root file not found [${url}]`);
-      }
-    }
-  }
-  static async discoverRootFileWithProxy(domain, proxy = "https://api.archivist.xyo.network/domain") {
-    try {
-      const requestUrl = `${proxy}/${domain.split(".").toReversed().join(".")}`;
-      const response = await fetchJson(requestUrl);
-      if (response.data?.data) {
-        return new _DomainPayloadWrapper(response.data.data);
-      }
-    } catch (ex) {
-      const status = ex instanceof FetchClientError ? ex.response.status : "unknown";
-      console.log(`DomainConfig root file not found using proxy [${domain}] [${status}]`);
-    }
-  }
-  async fetchAlias(alias, huriOptions) {
-    const huri = new Huri(alias.huri, huriOptions);
-    const payload = await huri.fetch();
-    return payload ? {
-      alias,
-      huri,
-      payload
-    } : null;
-  }
-  async findArchivistUri(hash) {
-    const network = await this.getNetwork(hash);
-    return network?.nodes?.find((payload) => payload.type === "archivist" ? payload : void 0)?.uri;
-  }
-  async getNetwork(hash) {
-    return isHash2(hash) ? await PayloadBuilder.findByDataHash(this.payload.networks, hash) : this.payload.networks?.[0];
-  }
-  async fetch(networkSlug) {
-    await this.fetchAliases(networkSlug);
-  }
-  async fetchAliases(networkSlug) {
-    this.aliases = null;
-    const archivistUri = await this.findArchivistUri(networkSlug);
-    if (this.payload.aliases) {
-      const fetchedAliases = await Promise.all(
-        Object.values(this.payload.aliases ?? {}).map((alias) => {
-          return this.fetchAlias(alias, { archivistUri });
-        })
-      );
-      this.aliases = fetchedAliases.filter(Boolean);
-    }
-  }
-};
-
-// src/Plugin.ts
-var DomainPayloadPlugin = () => createPayloadPlugin2({
-  schema: DomainSchema,
-  template: domainConfigTemplate,
-  wrap: (payload) => DomainPayloadWrapper.wrap(payload)
-});
-
-// src/Resolution/DomainSchemaResolver.ts
-import {
-  fetchJson as fetchJson2,
-  isBrowser as isBrowser2,
-  isString as isString2
-} from "@xylabs/sdk";
-import { DnsRecordType as DnsRecordType2, domainResolve as domainResolve2 } from "../../dns/neutral/index.mjs";
-import { Huri as Huri2 } from "../../huri/neutral/index.mjs";
-import { PayloadBuilder as PayloadBuilder2 } from "../../payload-builder/neutral/index.mjs";
-import { isSchemaPayload, SchemaSchema } from "../../schema-payload-plugin/neutral/index.mjs";
-var DEFAULT_MAX_INDIRECTION_DEPTH = 3;
-var DEFAULT_PROXY = "https://api.archivist.xyo.network/domain";
-function candidateDomains(schemaName) {
-  const parts = schemaName.split(".");
-  const domains = [];
-  for (let i = 2; i <= parts.length; i++) {
-    domains.push(parts.slice(0, i).toReversed().join("."));
-  }
-  return domains;
-}
-function isSchemaInDomainNamespace(schemaName, domain) {
-  return candidateDomains(schemaName).some((candidate) => candidate === domain || domain.endsWith(`.${candidate}`));
-}
-function isValidSchemaName(schemaName) {
-  return schemaName.length > 0 && schemaName === schemaName.toLowerCase() && schemaName.split(".").length >= 3;
-}
-var DomainSchemaResolver = class {
-  async resolve(schemaName, options = {}) {
-    if (!isValidSchemaName(schemaName)) {
-      return { status: "not-published" };
-    }
-    const context = {
-      anyCleanAnswer: false,
-      archivistUri: options.archivistUri,
-      proxy: options.proxy,
-      visited: /* @__PURE__ */ new Set()
-    };
-    const depth = options.maxIndirectionDepth ?? DEFAULT_MAX_INDIRECTION_DEPTH;
-    for (const domain of candidateDomains(schemaName)) {
-      const resolved = await this.resolveAtDomain(domain, schemaName, depth, context);
-      if (resolved) {
-        return {
-          payload: resolved.payload,
-          source: resolved.source,
-          status: "resolved"
-        };
-      }
-    }
-    return { status: context.anyCleanAnswer ? "not-published" : "unreachable" };
-  }
-  /** Fetch a payload by hash (or HURI href) and verify it against the referenced hash */
-  async fetchPayload(hashOrHref, context, configFields) {
-    try {
-      const archivistUri = context.archivistUri ?? findArchivistUri(configFields);
-      const huri = new Huri2(hashOrHref, { archivistUri });
-      const payload = await huri.fetch();
-      if (!payload) {
-        context.anyCleanAnswer = true;
-        return void 0;
-      }
-      if (await PayloadBuilder2.dataHash(payload) !== huri.hash && await PayloadBuilder2.hash(payload) !== huri.hash) {
-        console.warn(`DomainSchemaResolver: hash mismatch for [${huri.hash}]`);
-        context.anyCleanAnswer = true;
-        return void 0;
-      }
-      return payload;
-    } catch {
-      return void 0;
-    }
-  }
-  async fetchSchemaPayloadByHash(hashOrHref, schemaName, context, configFields) {
-    const payload = await this.fetchPayload(hashOrHref, context, configFields);
-    if (isSchemaPayload(payload) && payload.definition.$id === schemaName) {
-      return payload;
-    }
-  }
-  lookupHash(fields, schemaName) {
-    const entry = fields.schemas?.[schemaName];
-    if (isString2(entry)) return entry;
-    const alias = fields.aliases?.[schemaName];
-    if (isString2(alias?.huri) && alias.huri.length > 0) return alias.huri;
-  }
-  /** Find the schema in a domain config document (schemas map first, then legacy aliases) */
-  async lookupInConfig(fields, schemaName, domain, mechanism, context, url) {
-    if (!fields) return void 0;
-    context.anyCleanAnswer = true;
-    const entry = fields.schemas?.[schemaName];
-    if (entry !== void 0 && !isString2(entry)) {
-      const payload = { definition: { ...entry, $id: schemaName }, schema: SchemaSchema };
-      return {
-        payload,
-        source: {
-          domain,
-          mechanism,
-          url
-        }
-      };
-    }
-    const hash = this.lookupHash(fields, schemaName);
-    if (isString2(hash)) {
-      const payload = await this.fetchSchemaPayloadByHash(hash, schemaName, context, fields);
-      if (payload) {
-        const huri = new Huri2(hash);
-        return {
-          payload,
-          source: {
-            domain,
-            hash: huri.hash,
-            mechanism,
-            url
-          }
-        };
-      }
-    }
-  }
-  async resolveAtDomain(domain, schemaName, depth, context) {
-    if (context.visited.has(domain)) return void 0;
-    context.visited.add(domain);
-    const dnsResolved = await this.resolveViaDns(domain, schemaName, depth, context);
-    if (dnsResolved) return dnsResolved;
-    const fileCandidates = [
-      [`https://${domain}/xyo.json`, "file-root"],
-      [`https://xyo.${domain}/`, "file-subdomain"],
-      [`https://${domain}/xyo-config.json`, "file-legacy"]
-    ];
-    let anyDirectTransportFailure = false;
-    for (const [url, mechanism] of fileCandidates) {
-      try {
-        const response = await fetchJson2(url);
-        context.anyCleanAnswer = true;
-        const resolved = await this.lookupInConfig(response.data ?? void 0, schemaName, domain, mechanism, context, url);
-        if (resolved) return resolved;
-      } catch {
-        anyDirectTransportFailure = true;
-      }
-    }
-    if (isString2(context.proxy) || isBrowser2() && anyDirectTransportFailure) {
-      const url = `${context.proxy ?? DEFAULT_PROXY}/${domain.split(".").toReversed().join(".")}`;
-      try {
-        const response = await fetchJson2(url);
-        context.anyCleanAnswer = true;
-        const resolved = await this.lookupInConfig(response.data?.data, schemaName, domain, "file-proxy", context, url);
-        if (resolved) return resolved;
-      } catch {
-      }
-    }
-  }
-  async resolveViaDns(domain, schemaName, depth, context) {
-    try {
-      const result = await domainResolve2(`_xyo.${domain}`, DnsRecordType2.TXT);
-      if (!result) return void 0;
-      context.anyCleanAnswer = true;
-      const records = parseXyoTxtRecords(result.Answer);
-      const schemaHash = records.schemas[schemaName];
-      if (isString2(schemaHash)) {
-        const payload = await this.fetchSchemaPayloadByHash(schemaHash, schemaName, context);
-        if (payload) {
-          const huri = new Huri2(schemaHash);
-          return {
-            payload,
-            source: {
-              domain,
-              hash: huri.hash,
-              mechanism: "dns-schema"
-            }
-          };
-        }
-      }
-      if (isString2(records.config)) {
-        const configPayload = await this.fetchPayload(records.config, context);
-        if (isDomainConfigPayload(configPayload) || isDomainPayload(configPayload)) {
-          const resolved = await this.lookupInConfig(configPayload, schemaName, domain, "dns-config", context);
-          if (resolved) return resolved;
-        }
-      }
-      if (isString2(records.domain) && depth > 0 && !context.visited.has(records.domain)) {
-        const resolved = await this.resolveAtDomain(records.domain, schemaName, depth - 1, context);
-        if (resolved) {
-          return { payload: resolved.payload, source: { ...resolved.source, mechanism: "dns-domain" } };
-        }
-      }
-      for (const legacyHash of records.legacyHashes) {
-        const legacyPayload = await this.fetchPayload(legacyHash, context);
-        if (isDomainPayload(legacyPayload) || isDomainConfigPayload(legacyPayload)) {
-          const resolved = await this.lookupInConfig(legacyPayload, schemaName, domain, "dns-legacy", context);
-          if (resolved) return resolved;
-        }
-      }
-    } catch {
-    }
-  }
-};
-function findArchivistUri(fields) {
-  return fields?.networks?.[0]?.nodes?.find((node) => node.type === "archivist")?.uri;
-}
-export {
-  AliasZod,
-  DomainConfigFieldsZod,
-  DomainConfigPayloadPlugin,
-  DomainConfigPayloadZod,
-  DomainConfigSchema,
-  DomainPayloadPlugin,
-  DomainPayloadWrapper,
-  DomainPayloadZod,
-  DomainSchema,
-  DomainSchemaResolver,
-  SchemaDefinitionZod,
-  SchemaMapEntryZod,
-  asDomainConfigPayload,
-  asDomainPayload,
-  candidateDomains,
-  DomainPayloadPlugin as default,
-  domainConfigPayloadTemplate,
-  domainConfigTemplate,
-  isDomainConfigPayload,
-  isDomainPayload,
-  isSchemaInDomainNamespace,
-  normalizeTxtData,
-  parseXyoTxtRecords,
-  toDomainConfigPayload,
-  toDomainPayload
-};

package/dist/_pkg/elliptic/neutral/Elliptic.d.ts

@@ -1,14 +0,0 @@
-import type { Secp256k1 } from '@bitauth/libauth';
-import { WasmSupport } from '../../wasm/neutral/index.ts';
-export declare class Elliptic {
-    static readonly wasmSupport: WasmSupport;
-    protected static _secp256k1: Secp256k1 | undefined;
-    private static _secp256k1Mutex;
-    static addressFromPublicKey(key: ArrayBufferLike): ArrayBufferLike;
-    static initialize(): Promise<Secp256k1>;
-    static publicKeyFromPrivateKey(privateKey: ArrayBufferLike, prefix?: boolean): Promise<ArrayBufferLike>;
-    static ready(): boolean;
-    static secp256k1(): Promise<Secp256k1>;
-    static sign(hash: ArrayBufferLike, key: ArrayBufferLike): Promise<ArrayBufferLike>;
-    static verify(msg: ArrayBufferLike, signature: ArrayBufferLike, address: ArrayBufferLike): Promise<boolean>;
-}

package/dist/_pkg/elliptic/neutral/index.d.ts

@@ -1 +0,0 @@
-export * from './Elliptic.ts';

package/dist/_pkg/elliptic/neutral/index.mjs

@@ -1,88 +0,0 @@
-// src/Elliptic.ts
-import { instantiateSecp256k1 } from "@bitauth/libauth";
-import {
-  assertEx,
-  toHex,
-  toUint8Array
-} from "@xylabs/sdk";
-import { Data } from "../../data/neutral/index.mjs";
-import { WasmSupport } from "../../wasm/neutral/index.mjs";
-import { Mutex } from "async-mutex";
-var wasmSupportStatic = new WasmSupport(["bigInt", "mutableGlobals", "referenceTypes", "saturatedFloatToInt", "signExtensions", "simd"]);
-var recoveryIds = [0, 1, 2, 3];
-function compareArrayBuffers(b1, b2) {
-  if (b1.byteLength !== b2.byteLength) {
-    return false;
-  }
-  const a1 = new Uint8Array(b1);
-  const a2 = new Uint8Array(b2);
-  for (let i = 0; i < b1.byteLength; i++) {
-    if (a1[i] !== a2[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-var Elliptic = class {
-  static wasmSupport = wasmSupportStatic;
-  static _secp256k1;
-  static _secp256k1Mutex = new Mutex();
-  static addressFromPublicKey(key) {
-    const data = new Data(64, key);
-    return data.keccak256.slice(12);
-  }
-  static initialize() {
-    return this.secp256k1();
-  }
-  static async publicKeyFromPrivateKey(privateKey, prefix = false) {
-    const { derivePublicKeyUncompressed } = await this.secp256k1();
-    if (BigInt(toHex(privateKey, { prefix: true })) === 0n) {
-      throw new Error(`Invalid private key [${toHex(privateKey)}]`);
-    }
-    const derivedPublicKey = derivePublicKeyUncompressed(new Uint8Array(privateKey));
-    const fullPublicKey = typeof derivedPublicKey === "string" ? toUint8Array(derivedPublicKey) : derivedPublicKey;
-    return (prefix ? fullPublicKey : fullPublicKey.slice(1)).buffer;
-  }
-  static ready() {
-    return !!this._secp256k1;
-  }
-  static async secp256k1() {
-    return await this._secp256k1Mutex.runExclusive(async () => {
-      if (this._secp256k1) return this._secp256k1;
-      await wasmSupportStatic.initialize();
-      const secp256k1 = assertEx(await instantiateSecp256k1(), () => "No Wasm Support");
-      this._secp256k1 = secp256k1;
-      return secp256k1;
-    });
-  }
-  static async sign(hash, key) {
-    const { signMessageHashCompact } = await this.secp256k1();
-    const signature = signMessageHashCompact(new Uint8Array(key), toUint8Array(hash));
-    return (typeof signature === "string" ? toUint8Array(signature) : signature).buffer;
-  }
-  static async verify(msg, signature, address) {
-    const verifier = await this.secp256k1();
-    if (this.wasmSupport.canUseWasm) {
-      for (const recoveryId of recoveryIds) {
-        try {
-          const rawRecoveredPublicKey = verifier.recoverPublicKeyUncompressed(toUint8Array(signature), recoveryId, toUint8Array(msg));
-          const recoveredPublicKey = (typeof rawRecoveredPublicKey === "string" ? toUint8Array(rawRecoveredPublicKey) : rawRecoveredPublicKey).slice(1).buffer;
-          const recoveredAddress = this.addressFromPublicKey(recoveredPublicKey);
-          if (compareArrayBuffers(address, recoveredAddress)) {
-            return true;
-          }
-        } catch (ex) {
-          const error = ex;
-          console.log(error.message);
-          console.log(error.stack);
-          continue;
-        }
-      }
-      return false;
-    }
-    throw new Error("No wasm support");
-  }
-};
-export {
-  Elliptic
-};

package/dist/_pkg/hash/browser/BrowserObjectHasher.d.ts

@@ -1,8 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk';
-import { ObjectHasher } from './ObjectHasher.ts';
-export declare class BrowserObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
-    static readonly createBrowserWorker: (url?: URL) => import("@xylabs/threads/master").Worker;
-    static readonly createNodeWorker: (func?: () => unknown) => import("@xylabs/threads/master").Worker;
-    static readonly subtleHashWorkerUrl: URL | undefined;
-    static readonly wasmHashWorkerUrl: URL | undefined;
-}

package/dist/_pkg/hash/browser/NodeObjectHasher.d.ts

@@ -1,5 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk';
-import { ObjectHasher } from './ObjectHasher.ts';
-export declare class NodeObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
-    static readonly createNodeWorker: (func?: () => unknown) => import("@xylabs/threads/master").Worker;
-}

package/dist/_pkg/hash/browser/ObjectHasher.d.ts

@@ -1,68 +0,0 @@
-import type { EmptyObject, Hash } from '@xylabs/sdk';
-import { ObjectWrapper } from '@xylabs/sdk';
-import type { Worker } from '@xylabs/threads/master';
-import { WasmSupport } from '../../wasm/neutral/index.ts';
-export type WorkerFunction = ((...args: unknown[]) => unknown) | (() => unknown);
-export type WorkerModule<Keys extends string> = Record<Keys, WorkerFunction>;
-export declare class ObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectWrapper<T> {
-    static allowHashPooling: boolean;
-    static allowSubtle: boolean;
-    static createBrowserWorker?: (url?: URL) => Worker | undefined;
-    static createNodeWorker?: (func?: () => unknown) => Worker | undefined;
-    static readonly subtleHashWorkerUrl?: URL;
-    static warnIfUsingJsHash: boolean;
-    static readonly wasmHashWorkerUrl?: URL;
-    static readonly wasmInitialized: Promise<void>;
-    static readonly wasmSupport: WasmSupport;
-    private static _subtleHashPool?;
-    private static _wasmHashPool?;
-    private static get subtleHashPool();
-    private static get wasmHashPool();
-    static createWorker(url?: URL, func?: () => unknown): Worker;
-    static filterExcludeByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
-    static filterIncludeByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
-    static findByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash): Promise<T | undefined>;
-    /**
-     * Asynchronously hashes a payload
-     * @param obj A payload
-     * @returns The payload hash
-     */
-    static hash<T extends EmptyObject>(obj: T): Promise<Hash>;
-    static hashBytes(bytes: ArrayBuffer | Uint8Array): Promise<Hash>;
-    static hashFields<T extends EmptyObject>(obj: T): T;
-    /**
-     * Creates an array of payload/hash tuples based on the payloads passed in
-     * @param objs Any array of payloads
-     * @returns An array of payload/hash tuples
-     */
-    static hashPairs<T extends EmptyObject>(objs: T[]): Promise<[T, Hash][]>;
-    /**
-     * Creates an array of payload hashes based on the payloads passed in
-     * @param objs Any array of payloads
-     * @returns An array of payload hashes
-     */
-    static hashes<T extends EmptyObject>(objs?: T[]): Promise<Hash[] | undefined>;
-    /**
-     * Returns a clone of the payload that is JSON safe
-     * @param obj A payload
-     * @param meta Keeps underscore (meta) fields if set to true
-     * @returns Returns a clone of the payload that is JSON safe
-     */
-    static json<T extends EmptyObject>(payload: T, meta?: boolean): T;
-    /** @deprecated us JSON instead */
-    static jsonPayload<T extends EmptyObject>(payload: T, meta?: boolean): T;
-    static stringifyHashFields<T extends EmptyObject>(obj: T): string;
-    static subtleHash(data: Uint8Array<ArrayBuffer>): Promise<ArrayBuffer>;
-    static wasmHash(data: Uint8Array): Promise<Hash>;
-    private static createWorkerPool;
-    hash(): Promise<Hash>;
-    /**
-     * Returns a clone of the payload that is JSON safe
-     * @param meta Keeps underscore (meta) fields if set to true
-     * @returns Returns a clone of the payload that is JSON safe
-     */
-    json(meta?: boolean): T;
-}
-/** @deprecated use PayloadBuilder or ObjectHasher instead */
-export declare class PayloadHasher<T extends object> extends ObjectHasher<T> {
-}

package/dist/_pkg/hash/browser/createBrowserWorker.d.ts

@@ -1,2 +0,0 @@
-import { Worker } from '@xylabs/threads/master';
-export declare const createBrowserWorker: (url?: URL) => Worker;

package/dist/_pkg/hash/browser/createNodeWorker.d.ts

@@ -1,2 +0,0 @@
-import { Worker } from '@xylabs/threads/master';
-export declare const createNodeWorker: (func?: () => unknown) => Worker;

package/dist/_pkg/hash/browser/hasEmptyFields.d.ts

@@ -1,2 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk';
-export declare const hasEmptyFields: <T extends EmptyObject>(obj: T) => boolean;