@xyo-network/sdk 2.102.4 → 7.0.3

package/dist/_pkg/sdk-protocol/_pkg/quadkey/neutral/index.mjs

@@ -0,0 +1,280 @@
+// src/Quadkey.ts
+import {
+  boundingBoxToCenter,
+  GeoJson,
+  MercatorLngLat,
+  tileFromPoint,
+  tileFromQuadkey,
+  tilesFromBoundingBox,
+  tileToBoundingBox,
+  tileToQuadkey
+} from "@xylabs/geo";
+import {
+  assertEx,
+  hexFromArrayBuffer,
+  hexFromHexString
+} from "@xylabs/sdk";
+
+// src/RelativeDirectionConstantLookup.ts
+var RelativeDirectionConstantLookup = {
+  e: 1,
+  n: -2,
+  s: 2,
+  w: -1
+};
+
+// src/Quadkey.ts
+var MAX_ZOOM = 124;
+var isQuadkey = (obj) => obj?.type === Quadkey.type;
+var FULL_MASK = 2n ** 256n - 1n;
+var ZOOM_MASK = 0xFFn << 248n;
+var ID_MASK = ZOOM_MASK ^ FULL_MASK;
+var assertMaxBitUint = (value, bits = 256n) => {
+  assertEx(value < 2n ** bits && value >= 0, () => "Not a 256 Bit Uint!");
+};
+function gridOffsetForDigit(digit, blockSize) {
+  switch (digit) {
+    case "1": {
+      return { left: blockSize, top: 0 };
+    }
+    case "2": {
+      return { left: 0, top: blockSize };
+    }
+    case "3": {
+      return { left: blockSize, top: blockSize };
+    }
+    default: {
+      return { left: 0, top: 0 };
+    }
+  }
+}
+var Quadkey = class _Quadkey {
+  static Zero = _Quadkey.from(0, 0n);
+  static root = new _Quadkey();
+  static type = "Quadkey";
+  _geoJson;
+  key;
+  type = _Quadkey.type;
+  constructor(key = 0n) {
+    assertMaxBitUint(key);
+    this.key = key;
+    this.guessZoom();
+  }
+  static from(zoom, id) {
+    const quadkey = new _Quadkey();
+    return quadkey.setId(id).setZoom(zoom);
+  }
+  static fromArrayBuffer(zoom, id) {
+    const quadkey = new _Quadkey();
+    return quadkey.setId(BigInt(hexFromArrayBuffer(id, { prefix: true }))).setZoom(zoom);
+  }
+  static fromBase16String(value) {
+    return new _Quadkey(BigInt(hexFromHexString(value, { prefix: true })));
+  }
+  static fromBase4String(value) {
+    if (value === void 0 || ["fhr", ""].includes(value)) {
+      return this.root;
+    }
+    let id = 0n;
+    for (const digit of value) {
+      const nibble = Number.parseInt(digit);
+      assertEx(nibble < 4 && nibble >= 0, () => `Invalid Base4 String: ${value}`);
+      id = id << 2n | BigInt(nibble);
+    }
+    const quadkey = new _Quadkey();
+    return quadkey.setId(id).setZoom(value.length);
+  }
+  static fromBoundingBox(boundingBox, zoom) {
+    const tiles = tilesFromBoundingBox(boundingBox, Math.floor(zoom));
+    return Array.from(tiles, (tile) => assertEx(this.fromTile(tile), () => "Bad Quadkey"));
+  }
+  static fromLngLat(point, zoom) {
+    const tile = tileFromPoint(point, zoom);
+    const quadkeyString = tileToQuadkey(tile);
+    return this.fromBase4String(quadkeyString);
+  }
+  static fromString(zoom, id, base = 16) {
+    switch (base) {
+      case 16: {
+        return this.fromBase16String(id).setZoom(zoom);
+      }
+      default: {
+        throw new Error(`Invalid base [${base}]`);
+      }
+    }
+  }
+  static fromTile(tile) {
+    return this.fromBase4String(tileToQuadkey(tile));
+  }
+  get base10String() {
+    return this.id.toString(10);
+  }
+  get base16String() {
+    return this.id.toString(16).padStart(62, "0");
+  }
+  get base4Hash() {
+    if (this.id === 0n && this.zoom === 0) {
+      return "";
+    }
+    return this.id.toString(4).padStart(this.zoom, "0");
+  }
+  get base4HashLabel() {
+    const hash = this.base4Hash;
+    return hash.length === 0 ? "fhr" : hash;
+  }
+  get boundingBox() {
+    return tileToBoundingBox(this.tile);
+  }
+  get center() {
+    const result = boundingBoxToCenter(this.boundingBox);
+    return new MercatorLngLat(result[0], result[1]);
+  }
+  get children() {
+    assertEx(this.zoom < MAX_ZOOM - 1, () => "Can not get children of bottom tiles");
+    const result = [];
+    const shiftedId = this.id << 2n;
+    for (let i = 0n; i < 4n; i++) {
+      const quadkey = new _Quadkey();
+      result.push(quadkey.setId(shiftedId | i).setZoom(this.zoom + 1));
+    }
+    return result;
+  }
+  get gridLocation() {
+    const tileData = tileFromQuadkey(this.base4Hash);
+    return {
+      col: 2 ** tileData[2] - tileData[1] - 1,
+      row: tileData[0],
+      zoom: tileData[2]
+    };
+  }
+  get id() {
+    return this.key & ID_MASK;
+  }
+  get parent() {
+    if (this.zoom <= 0) {
+      return;
+    }
+    const quadkey = new _Quadkey();
+    return quadkey.setId(this.id >> 2n).setZoom(this.zoom - 1);
+  }
+  get siblings() {
+    const siblings = assertEx(this.parent?.children, () => `siblings: parentChildren ${this.base4Hash}`);
+    const filteredSiblings = siblings.filter((quadkey) => quadkey.key !== this.key);
+    assertEx(filteredSiblings.length === 3, () => `siblings: expected 3 [${filteredSiblings.length}]`);
+    return filteredSiblings;
+  }
+  get tile() {
+    return tileFromQuadkey(this.base4Hash);
+  }
+  get valid() {
+    return this.id.toString(4) === this.base4Hash.padStart(64, "0");
+  }
+  get zoom() {
+    return Number((this.key & ZOOM_MASK) >> 248n);
+  }
+  childrenByZoom(zoom) {
+    if (zoom > 0 && zoom === this.zoom) {
+      return [this];
+    }
+    let deepResult = [];
+    for (const quadkey of this.children) {
+      deepResult = [...deepResult, ...quadkey.childrenByZoom(zoom)];
+    }
+    return deepResult;
+  }
+  clone() {
+    return new _Quadkey(this.key);
+  }
+  equals(obj) {
+    return obj.key == this.key;
+  }
+  geoJson() {
+    this._geoJson = this._geoJson ?? new GeoJson(this.base4Hash);
+    return this._geoJson;
+  }
+  getGridBoundingBox(size) {
+    const hash = this.base4Hash;
+    let index = 0;
+    let left = 0;
+    let top = 0;
+    let blockSize = size;
+    while (index < hash.length) {
+      blockSize >>= 1;
+      const offset = gridOffsetForDigit(hash[index], blockSize);
+      left += offset.left;
+      top += offset.top;
+      index++;
+    }
+    if (blockSize < 2) {
+      blockSize = 2;
+    }
+    return {
+      height: blockSize,
+      left,
+      top,
+      width: blockSize
+    };
+  }
+  /** @deprecated use .gridLocation instead */
+  getGridLocation() {
+    return this.gridLocation;
+  }
+  isInBoundingBox(boundingBox) {
+    const tileBoundingBox = tileToBoundingBox(this.tile);
+    return boundingBox.contains(tileBoundingBox.getNorthEast()) || boundingBox.contains(tileBoundingBox.getNorthWest()) || boundingBox.contains(tileBoundingBox.getSouthEast()) || boundingBox.contains(tileBoundingBox.getSouthWest());
+  }
+  relative(direction) {
+    const directionConstant = assertEx(RelativeDirectionConstantLookup[direction], () => "Invalid direction");
+    let quadkey = this.base4Hash;
+    if (quadkey.length === 0) {
+      return this;
+    }
+    let index = quadkey.length - 1;
+    while (index >= 0) {
+      let number = Number.parseInt(quadkey.charAt(index));
+      number += directionConstant;
+      if (number > 3) {
+        number -= 4;
+        quadkey = quadkey.slice(0, Math.max(0, index)) + number.toString() + quadkey.slice(Math.max(0, index + 1));
+        index--;
+      } else if (number < 0) {
+        number += 4;
+        quadkey = quadkey.slice(0, Math.max(0, index)) + number.toString() + quadkey.slice(Math.max(0, index + 1));
+        index--;
+      } else {
+        index = -1;
+      }
+    }
+    return _Quadkey.fromBase4String(quadkey);
+  }
+  setId(id) {
+    assertMaxBitUint(id, 248n);
+    this.setKey(this.zoom, id);
+    return this;
+  }
+  setKey(zoom, key) {
+    assertMaxBitUint(key);
+    this.key = key;
+    this.setZoom(zoom);
+    return this;
+  }
+  setZoom(zoom) {
+    assertEx(zoom < MAX_ZOOM, () => `Invalid zoom [${zoom}] max=${MAX_ZOOM}`);
+    this.key = this.key & ID_MASK | BigInt(zoom) << 248n;
+    return this;
+  }
+  toJSON() {
+    return this.base4HashLabel;
+  }
+  toString() {
+    return this.base4Hash;
+  }
+  guessZoom() {
+    const quadkeySimple = this.id.toString(4);
+    this.setZoom(quadkeySimple.length);
+  }
+};
+export {
+  Quadkey,
+  isQuadkey
+};

package/dist/_pkg/sdk-protocol/_pkg/quant-account/neutral/QuantAccount.d.ts

@@ -0,0 +1,33 @@
+import type { Hash } from '@xylabs/sdk';
+import type { AccountAlgorithm, AccountConfig, AccountInstance, SignJwtOptions, SignJwtResult } from '../../account-model/neutral/index.ts';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
+export declare class QuantAccount implements AccountInstance {
+    static previousHashStore: PreviousHashStore | undefined;
+    protected static _addressMap: Record<string, WeakRef<AccountInstance>>;
+    protected static _protectedConstructorKey: symbol;
+    private readonly _address;
+    private readonly _addressBytes;
+    private readonly _signingMutex;
+    protected _previousHash?: ArrayBufferLike;
+    protected readonly _publicKey: Uint8Array;
+    protected readonly _secretKey: Uint8Array;
+    readonly algorithm: AccountAlgorithm;
+    protected constructor(key: unknown, secretKey: Uint8Array, publicKey: Uint8Array);
+    static create(opts?: AccountConfig): Promise<AccountInstance>;
+    static fromPrivateKey(key: ArrayBufferLike | bigint | string): Promise<AccountInstance>;
+    static isAddress(address: string): boolean;
+    static random(): Promise<AccountInstance>;
+    get address(): XyoAddress;
+    get addressBytes(): ArrayBufferLike;
+    get previousHash(): Hash | undefined;
+    set previousHash(_value: Hash | undefined);
+    get previousHashBytes(): ArrayBufferLike | undefined;
+    set previousHashBytes(_value: ArrayBufferLike | undefined);
+    get publicKey(): ArrayBufferLike;
+    loadPreviousHash(previousHash?: ArrayBufferLike | string): Promise<this>;
+    sign(hash: ArrayBufferLike, previousHash?: ArrayBufferLike): Promise<[ArrayBufferLike, Hash?]>;
+    signJwt(_options: SignJwtOptions): Promise<SignJwtResult>;
+    verify(msg: ArrayBufferLike, signature: ArrayBufferLike): Promise<boolean>;
+    verifyUniqueAddress(): AccountInstance;
+}

package/dist/_pkg/sdk-protocol/_pkg/quant-account/neutral/index.d.ts

@@ -0,0 +1,2 @@
+import './register.ts';
+export * from './QuantAccount.ts';

package/dist/_pkg/sdk-protocol/_pkg/quant-account/neutral/index.mjs

@@ -0,0 +1,172 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/register.ts
+import { addressTo20Bytes, registerVerifier } from "../../account-model/neutral/index.mjs";
+import { MlDsa } from "../../pqc/neutral/index.mjs";
+function buffersEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  const a1 = new Uint8Array(a);
+  const a2 = new Uint8Array(b);
+  for (let i = 0; i < a1.byteLength; i++) {
+    if (a1[i] !== a2[i]) return false;
+  }
+  return true;
+}
+registerVerifier("ml-dsa-65", async (address, hash, signatureBundle) => {
+  const { publicKey, signature } = MlDsa.unbundle(signatureBundle);
+  const expectedAddress = addressTo20Bytes(address);
+  const derivedAddress = MlDsa.addressFromPublicKey(publicKey);
+  if (!buffersEqual(expectedAddress, derivedAddress)) {
+    return false;
+  }
+  return await Promise.resolve(MlDsa.verify(publicKey, hash, signature));
+});
+
+// src/QuantAccount.ts
+import {
+  asHash,
+  assertEx,
+  isDefined,
+  isHash,
+  staticImplements,
+  toArrayBuffer,
+  toHex,
+  toUint8Array
+} from "@xylabs/sdk";
+import { hrpForAlgorithm, isPrivateKeyInitializationConfig } from "../../account-model/neutral/index.mjs";
+import { encodeQuantAddress, tryDecodeQuantAddress } from "../../address/neutral/index.mjs";
+import { MlDsa as MlDsa2 } from "../../pqc/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+var QuantAccount = class {
+  _address;
+  _addressBytes;
+  _signingMutex = new Mutex();
+  _previousHash;
+  _publicKey;
+  _secretKey;
+  algorithm = "ml-dsa-65";
+  constructor(key, secretKey, publicKey) {
+    assertEx(key === QuantAccount._protectedConstructorKey, () => "Do not call this protected constructor");
+    this._secretKey = secretKey;
+    this._publicKey = publicKey;
+    this._addressBytes = MlDsa2.addressFromPublicKey(publicKey.buffer);
+    const hrp = assertEx(hrpForAlgorithm("ml-dsa-65"), () => "No HRP registered for algorithm [ml-dsa-65]");
+    this._address = encodeQuantAddress(hrp, this._addressBytes);
+  }
+  static async create(opts) {
+    let seed;
+    if (opts && isPrivateKeyInitializationConfig(opts)) {
+      seed = toUint8Array(opts.privateKey, 32).buffer;
+    }
+    const keyPair = MlDsa2.keygen(seed);
+    const account = new QuantAccount(this._protectedConstructorKey, keyPair.secretKey, keyPair.publicKey);
+    await account.loadPreviousHash(opts?.previousHash);
+    return account.verifyUniqueAddress();
+  }
+  static async fromPrivateKey(key) {
+    const privateKey = toUint8Array(key, 32).buffer;
+    return await this.create({ privateKey });
+  }
+  static isAddress(address) {
+    return tryDecodeQuantAddress(address)?.hrp === hrpForAlgorithm("ml-dsa-65");
+  }
+  static async random() {
+    return await this.create();
+  }
+  get address() {
+    return this._address;
+  }
+  get addressBytes() {
+    return this._addressBytes;
+  }
+  get previousHash() {
+    return this.previousHashBytes ? toHex(this.previousHashBytes, { prefix: false }).toLowerCase() : void 0;
+  }
+  set previousHash(_value) {
+  }
+  get previousHashBytes() {
+    return this._previousHash;
+  }
+  set previousHashBytes(_value) {
+  }
+  get publicKey() {
+    return this._publicKey.buffer;
+  }
+  async loadPreviousHash(previousHash) {
+    return await this._signingMutex.runExclusive(async () => {
+      if (isDefined(previousHash)) {
+        this._previousHash = toUint8Array(previousHash, 32).buffer;
+      } else {
+        const storeValue = await QuantAccount.previousHashStore?.getItem(this.address);
+        if (isHash(storeValue)) {
+          this._previousHash = toUint8Array(storeValue, 32).buffer;
+        }
+      }
+      return this;
+    });
+  }
+  async sign(hash, previousHash) {
+    return await this._signingMutex.runExclusive(async () => {
+      if (QuantAccount.previousHashStore) {
+        const stored = await QuantAccount.previousHashStore.getItem(this.address);
+        this._previousHash = isHash(stored) ? toArrayBuffer(stored, 32) : void 0;
+      }
+      const currentPreviousHash = this.previousHash;
+      const passedCurrentHash = previousHash === void 0 ? this.previousHash : toHex(previousHash, { prefix: false });
+      assertEx(
+        currentPreviousHash === passedCurrentHash,
+        () => `Used and current previous hashes do not match [${currentPreviousHash} !== ${passedCurrentHash}]`
+      );
+      const rawSig = MlDsa2.sign(this._secretKey.buffer, hash);
+      const bundle = MlDsa2.bundle(this._publicKey.buffer, rawSig);
+      const newPreviousHash = toUint8Array(hash, 32).buffer;
+      this._previousHash = newPreviousHash;
+      if (QuantAccount.previousHashStore) {
+        await QuantAccount.previousHashStore.setItem(this.address, asHash(toHex(newPreviousHash, { prefix: false }), true));
+      }
+      return [bundle, currentPreviousHash];
+    });
+  }
+  async signJwt(_options) {
+    return await Promise.reject(new Error("JWT signing is not implemented for ml-dsa-65 (no standard IANA JOSE alg yet)"));
+  }
+  async verify(msg, signature) {
+    if (signature.byteLength === MlDsa2.bundleLength) {
+      const { publicKey, signature: sig } = MlDsa2.unbundle(signature);
+      return await Promise.resolve(MlDsa2.verify(publicKey, msg, sig));
+    }
+    if (signature.byteLength === MlDsa2.signatureLength) {
+      return await Promise.resolve(MlDsa2.verify(this._publicKey.buffer, msg, signature));
+    }
+    return await Promise.resolve(false);
+  }
+  verifyUniqueAddress() {
+    const address = this.address;
+    const existing = QuantAccount._addressMap[address]?.deref();
+    if (existing === void 0) {
+      QuantAccount._addressMap[address] = new WeakRef(this);
+      return this;
+    }
+    return existing;
+  }
+};
+__publicField(QuantAccount, "previousHashStore");
+__publicField(QuantAccount, "_addressMap", {});
+__publicField(QuantAccount, "_protectedConstructorKey", /* @__PURE__ */ Symbol());
+QuantAccount = __decorateClass([
+  staticImplements()
+], QuantAccount);
+export {
+  QuantAccount
+};

package/dist/_pkg/sdk-protocol/_pkg/quant-account/neutral/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_pkg/sdk-protocol/_pkg/query-payload-plugin/neutral/Payload.d.ts

@@ -0,0 +1,42 @@
+import * as z from 'zod/mini';
+export declare const QueryPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.query" & {
+        readonly __schema: true;
+    }>;
+    query: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
+}, z.core.$strip>;
+export type QueryPayload = z.infer<typeof QueryPayloadZod>;
+export declare const isQueryPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.query" & {
+        readonly __schema: true;
+    };
+    query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+};
+export declare const asQueryPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    };
+};
+export declare const toQueryPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    };
+};

package/dist/_pkg/sdk-protocol/_pkg/query-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,6 @@
+export declare const QueryPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
+    schema: "network.xyo.query" & {
+        readonly __schema: true;
+    };
+    query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+}>;

package/dist/_pkg/sdk-protocol/_pkg/query-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,4 @@
+export declare const QuerySchema: "network.xyo.query" & {
+    readonly __schema: true;
+};
+export type QuerySchema = typeof QuerySchema;

package/dist/_pkg/sdk-protocol/_pkg/query-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,2 @@
+import type { QueryPayload } from './Payload.ts';
+export declare const queryPayloadTemplate: () => QueryPayload;

package/dist/_pkg/sdk-protocol/_pkg/query-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Payload.ts';
+export { QueryPayloadPlugin as default, QueryPayloadPlugin } from './Plugin.ts';
+export * from './Schema.ts';
+export * from './Template.ts';

package/dist/_pkg/sdk-protocol/_pkg/query-payload-plugin/neutral/index.mjs

@@ -0,0 +1,43 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema, SchemaZod } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var QuerySchema = asSchema("network.xyo.query", true);
+
+// src/Payload.ts
+var QueryPayloadZod = z.extend(PayloadZodOfSchema(QuerySchema), { query: SchemaZod });
+var isQueryPayload = zodIsFactory(QueryPayloadZod);
+var asQueryPayload = zodAsFactory(QueryPayloadZod, "asQueryPayload");
+var toQueryPayload = zodToFactory(QueryPayloadZod, "toQueryPayload");
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var queryPayloadTemplate = () => ({
+  query: "",
+  schema: QuerySchema
+});
+
+// src/Plugin.ts
+var QueryPayloadPlugin = () => createPayloadPlugin({
+  schema: QuerySchema,
+  template: queryPayloadTemplate
+});
+export {
+  QueryPayloadPlugin,
+  QueryPayloadZod,
+  QuerySchema,
+  asQueryPayload,
+  QueryPayloadPlugin as default,
+  isQueryPayload,
+  queryPayloadTemplate,
+  toQueryPayload
+};

package/dist/_pkg/sdk-protocol/_pkg/schema-cache/neutral/Debounce.d.ts

@@ -0,0 +1,4 @@
+export declare class Debounce<TKey = string> {
+    private map;
+    one<T>(key: TKey, closure: () => Promise<T>, timeout?: number): Promise<T>;
+}

package/dist/_pkg/sdk-protocol/_pkg/schema-cache/neutral/SchemaCache.d.ts

@@ -0,0 +1,42 @@
+import type { SchemaResolution, SchemaResolutionSource } from '../../domain-payload-plugin/neutral/index.ts';
+import type { FetchedPayload } from '../../huri/neutral/index.ts';
+import type { SchemaPayload } from '../../schema-payload-plugin/neutral/index.ts';
+import type { SchemaNameToValidatorMap } from './SchemaNameToValidatorMap.ts';
+export interface SchemaCacheEntry extends FetchedPayload<SchemaPayload> {
+    /** Provenance of the schema definition when resolved via the domain schema authority */
+    source?: SchemaResolutionSource;
+}
+export declare class SchemaCache<T extends SchemaNameToValidatorMap = SchemaNameToValidatorMap> {
+    /**
+     * Object representing `null` since LRU Cache types
+     * only allow for types that derive from object
+     */
+    protected static readonly NULL: SchemaCacheEntry;
+    private static _instance?;
+    private _cache;
+    private _resolutions;
+    private _validators;
+    private getDebounce;
+    onSchemaCached?: (name: string, entry: SchemaCacheEntry) => void;
+    proxy?: string;
+    private constructor();
+    static get instance(): SchemaCache<SchemaNameToValidatorMap>;
+    private cacheSchemaIfValid;
+    private cacheSchemas;
+    private fetchSchema;
+    /**
+     * A map of cached schema (by name) to payload validators for the schema. A schema
+     * must be cached via `get('schema.name')` before it's validator can be used as
+     * they are compiled dynamically at runtime upon retrieval.
+     */
+    get validators(): T;
+    get(schema?: string): Promise<SchemaCacheEntry | undefined | null>;
+    /**
+     * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
+     * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
+     * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
+     * their validators compiled, exactly as with get(). 'unreachable' results are
+     * retryable: they are not cached as permanent negatives.
+     */
+    resolve(schema?: string): Promise<SchemaResolution | undefined>;
+}

package/dist/_pkg/sdk-protocol/_pkg/schema-cache/neutral/SchemaNameToValidatorMap.d.ts

@@ -0,0 +1,11 @@
+import type { Payload } from '../../payload-model/neutral/index.ts';
+/**
+ * Used in conjunction with schema validation to support compile time type assertion
+ * for known schema types.
+ */
+export type NarrowPayload<T extends Payload = Payload> = ((x: Payload) => x is T) | undefined;
+/**
+ * Used to map known schemas (byt their string name) to the validators which assert their types
+ */
+export interface SchemaNameToValidatorMap {
+}

package/dist/_pkg/sdk-protocol/_pkg/schema-cache/neutral/TtlLruCache.d.ts

@@ -0,0 +1,12 @@
+export interface TtlLruCacheOpts {
+    max: number;
+    ttl: number;
+}
+export declare class TtlLruCache<K, V> {
+    private readonly map;
+    private readonly max;
+    private readonly ttl;
+    constructor(opts: TtlLruCacheOpts);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+}

package/dist/_pkg/sdk-protocol/_pkg/schema-cache/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Debounce.ts';
+export * from './SchemaCache.ts';
+export * from './SchemaNameToValidatorMap.ts';
+export * from './TtlLruCache.ts';