@xyo-network/schema-cache 7.0.12 → 7.0.13

package/README.md

@@ -1,3 +1,49 @@
+[![logo][]](https://xyo.network)
+
 # @xyo-network/schema-cache
 
-Deprecated compatibility stub. Use `@xyo-network/sdk-protocol/schema-cache` instead.
+[![npm][npm-badge]][npm-link]
+[![license][license-badge]][license-link]
+
+> Primary SDK for using XYO Protocol 2.0
+
+## Install
+
+Using npm:
+
+```sh
+npm install {{name}}
+```
+
+Using yarn:
+
+```sh
+yarn add {{name}}
+```
+
+Using pnpm:
+
+```sh
+pnpm add {{name}}
+```
+
+Using bun:
+
+```sh
+bun add {{name}}
+```
+
+
+## License
+
+See the [LICENSE](LICENSE) file for license rights and limitations (LGPL-3.0-only).
+
+## Credits
+
+[Made with 🔥 and ❄️ by XYO Foundation](https://xyo.network)
+
+[npm-badge]: https://img.shields.io/npm/v/@xyo-network/schema-cache.svg
+[npm-link]: https://www.npmjs.com/package/@xyo-network/schema-cache
+[license-badge]: https://img.shields.io/npm/l/@xyo-network/schema-cache.svg
+[license-link]: https://github.com/xylabs/sdk-js/blob/main/LICENSE
+[logo]: https://cdn.xy.company/img/brand/XYO_full_colored.png

package/dist/neutral/Debounce.d.ts

@@ -0,0 +1,5 @@
+export declare class Debounce<TKey = string> {
+    private map;
+    one<T>(key: TKey, closure: () => Promise<T>, timeout?: number): Promise<T>;
+}
+//# sourceMappingURL=Debounce.d.ts.map

package/dist/neutral/Debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debounce.d.ts","sourceRoot":"","sources":["../../src/Debounce.ts"],"names":[],"mappings":"AAEA,qBAAa,QAAQ,CAAC,IAAI,GAAG,MAAM;IACjC,OAAO,CAAC,GAAG,CAA0B;IAE/B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,SAAS;CAiBpE"}

package/dist/neutral/SchemaCache.d.ts

@@ -0,0 +1,43 @@
+import type { SchemaResolution, SchemaResolutionSource } from '@xyo-network/domain-payload-plugin';
+import type { FetchedPayload } from '@xyo-network/huri';
+import type { SchemaPayload } from '@xyo-network/schema-payload-plugin';
+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>;
+}
+//# sourceMappingURL=SchemaCache.d.ts.map

package/dist/neutral/SchemaCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaCache.d.ts","sourceRoot":"","sources":["../../src/SchemaCache.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAA;AAElG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAMvE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAS7E,MAAM,WAAW,gBAAiB,SAAQ,cAAc,CAAC,aAAa,CAAC;IACrE,wFAAwF;IACxF,MAAM,CAAC,EAAE,sBAAsB,CAAA;CAChC;AAED,qBAAa,WAAW,CAAC,CAAC,SAAS,wBAAwB,GAAG,wBAAwB;IACpF;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAwD;IAExG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAa;IAEtC,OAAO,CAAC,MAAM,CAA8E;IAC5F,OAAO,CAAC,YAAY,CAA8E;IAClG,OAAO,CAAC,WAAW,CAAa;IAGhC,OAAO,CAAC,WAAW,CAAiB;IAEpC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAA;IAChE,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,OAAO;IAIP,MAAM,KAAK,QAAQ,0CAGlB;IAED,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,YAAY;YAMN,WAAW;IA6BzB;;;;OAIG;IACH,IAAI,UAAU,IAAI,CAAC,CAElB;IAEK,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,GAAG,IAAI,CAAC;IAcxE;;;;;;OAMG;IACG,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;CAetE"}

package/dist/neutral/SchemaNameToValidatorMap.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from '@xyo-network/payload-model';
+/**
+ * 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 {
+}
+//# sourceMappingURL=SchemaNameToValidatorMap.d.ts.map

package/dist/neutral/SchemaNameToValidatorMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaNameToValidatorMap.d.ts","sourceRoot":"","sources":["../../src/SchemaNameToValidatorMap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,4BAA4B,CAAA;AAGxE;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAA;AAE7F;;GAEG;AACH,MAAM,WAAW,wBAAwB;CAKxC"}

package/dist/neutral/TtlLruCache.d.ts

@@ -0,0 +1,13 @@
+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;
+}
+//# sourceMappingURL=TtlLruCache.d.ts.map

package/dist/neutral/TtlLruCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtlLruCache.d.ts","sourceRoot":"","sources":["../../src/TtlLruCache.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,qBAAa,WAAW,CAAC,CAAC,EAAE,CAAC;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA8C;IAClE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;gBAEhB,IAAI,EAAE,eAAe;IAKjC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAY1B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;CAQ5B"}

package/dist/neutral/index.d.ts

@@ -1,6 +1,5 @@
-/**
- * @deprecated Use `@xyo-network/sdk-protocol/schema-cache` instead.
- * `@xyo-network/schema-cache` is a backward-compatibility re-export stub.
- */
-export * from '@xyo-network/sdk-protocol/schema-cache';
+export * from './Debounce.ts';
+export * from './SchemaCache.ts';
+export * from './SchemaNameToValidatorMap.ts';
+export * from './TtlLruCache.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,wCAAwC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,kBAAkB,CAAA"}

package/dist/neutral/index.mjs

@@ -1,3 +1,178 @@
-// src/index.ts
-export * from "@xyo-network/sdk-protocol/schema-cache";
+// src/Debounce.ts
+import { delay, isDefined } from "@ariestools/sdk";
+var Debounce = class {
+  map = /* @__PURE__ */ new Map();
+  async one(key, closure, timeout = 1e4) {
+    const startTime = Date.now();
+    while (isDefined(this.map.get(key))) {
+      await delay(100);
+      if (Date.now() - startTime > timeout) {
+        throw new Error(`Debounce timed out [${String(key)}]`);
+      }
+    }
+    try {
+      this.map.set(key, 1);
+      return await closure();
+    } finally {
+      this.map.delete(key);
+    }
+  }
+};
+
+// src/SchemaCache.ts
+import {
+  FetchClientError,
+  handleError,
+  isDefined as isDefined2,
+  isString
+} from "@ariestools/sdk";
+import { DomainPayloadWrapper, DomainSchemaResolver } from "@xyo-network/domain-payload-plugin";
+import { SchemaSchema } from "@xyo-network/schema-payload-plugin";
+import { Ajv } from "ajv";
+
+// src/TtlLruCache.ts
+var TtlLruCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  ttl;
+  constructor(opts) {
+    this.max = opts.max;
+    this.ttl = opts.ttl;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (entry.expires <= Date.now()) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, { value, expires: Date.now() + this.ttl });
+    if (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+  }
+};
+
+// src/SchemaCache.ts
+var getSchemaNameFromSchema = (schema) => {
+  if (isString(schema.$id)) {
+    return schema.$id;
+  }
+};
+var SchemaCache = class _SchemaCache {
+  /**
+   * Object representing `null` since LRU Cache types
+   * only allow for types that derive from object
+   */
+  static NULL = { payload: { definition: {}, schema: SchemaSchema } };
+  static _instance;
+  _cache = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
+  _resolutions = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
+  _validators = {};
+  // prevents double discovery
+  getDebounce = new Debounce();
+  onSchemaCached;
+  proxy;
+  constructor(proxy) {
+    this.proxy = proxy;
+  }
+  static get instance() {
+    this._instance ??= new _SchemaCache();
+    return this._instance;
+  }
+  cacheSchemaIfValid(entry) {
+    if (!isDefined2(entry?.payload?.definition)) {
+      return;
+    }
+    const ajv = new Ajv({ strict: false });
+    const validator = ajv.compile(entry.payload.definition);
+    const schemaName = getSchemaNameFromSchema(entry.payload.definition);
+    if (isString(schemaName)) {
+      this._cache.set(schemaName, entry);
+      const key = schemaName;
+      this._validators[key] = validator;
+      this.onSchemaCached?.(schemaName, entry);
+    }
+  }
+  cacheSchemas(aliasEntries) {
+    for (const entry of aliasEntries?.filter((entry2) => entry2.payload.schema === SchemaSchema) ?? []) {
+      this.cacheSchemaIfValid(entry);
+    }
+  }
+  async fetchSchema(schema) {
+    try {
+      const resolution = await this.resolve(schema);
+      if (resolution?.status === "resolved") {
+        return;
+      }
+      const domain = await DomainPayloadWrapper.discover(schema, this.proxy);
+      await domain?.fetch();
+      this.cacheSchemas(domain?.aliases);
+      if (this._cache.get(schema) === void 0 && resolution?.status !== "unreachable") {
+        this._cache.set(schema, _SchemaCache.NULL);
+      }
+    } catch (error) {
+      if (error instanceof FetchClientError) {
+        console.log(`Fetch Url: ${error.config.url}`);
+      }
+      handleError(error, (error2) => {
+        console.error(`fetchSchema threw: ${error2.message}`);
+      });
+    }
+  }
+  /**
+   * 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() {
+    return this._validators;
+  }
+  async get(schema) {
+    if (isString(schema)) {
+      await this.getDebounce.one(schema, async () => {
+        if (this._cache.get(schema) === void 0) {
+          await this.fetchSchema(schema);
+        }
+      });
+      const value = this._cache.get(schema);
+      return value === _SchemaCache.NULL ? null : value;
+    }
+    return void 0;
+  }
+  /**
+   * 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.
+   */
+  async resolve(schema) {
+    if (!isString(schema)) return void 0;
+    await this.getDebounce.one(`resolve:${schema}`, async () => {
+      const existing = this._resolutions.get(schema);
+      if (existing === void 0 || existing.status === "unreachable") {
+        const resolver = new DomainSchemaResolver();
+        const resolution = await resolver.resolve(schema, { proxy: this.proxy });
+        this._resolutions.set(schema, resolution);
+        if (resolution.status === "resolved" && isDefined2(resolution.payload)) {
+          this.cacheSchemaIfValid({ payload: resolution.payload, source: resolution.source });
+        }
+      }
+    });
+    return this._resolutions.get(schema);
+  }
+};
+export {
+  Debounce,
+  SchemaCache,
+  TtlLruCache
+};
 //# sourceMappingURL=index.mjs.map

package/dist/neutral/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../src/index.ts"],
-  "sourcesContent": ["/**\n * @deprecated Use `@xyo-network/sdk-protocol/schema-cache` instead.\n * `@xyo-network/schema-cache` is a backward-compatibility re-export stub.\n */\nexport * from '@xyo-network/sdk-protocol/schema-cache'\n"],
-  "mappings": ";AAIA,cAAc;",
-  "names": []
+  "sources": ["../../src/Debounce.ts", "../../src/SchemaCache.ts", "../../src/TtlLruCache.ts"],
+  "sourcesContent": ["import { delay, isDefined } from '@ariestools/sdk'\n\nexport class Debounce<TKey = string> {\n  private map = new Map<TKey, number>()\n\n  async one<T>(key: TKey, closure: () => Promise<T>, timeout = 10_000) {\n    const startTime = Date.now()\n    while (isDefined(this.map.get(key))) {\n      await delay(100)\n      if (Date.now() - startTime > timeout) {\n        throw new Error(`Debounce timed out [${String(key)}]`)\n      }\n    }\n    try {\n      this.map.set(key, 1)\n      return await closure()\n    } finally {\n      // delete (not set 0): isDefined(0) is true, so a leftover 0 would make every\n      // subsequent call with this key spin until timeout\n      this.map.delete(key)\n    }\n  }\n}\n", "import {\n  FetchClientError,\n  handleError, isDefined, isString,\n} from '@ariestools/sdk'\nimport type { SchemaResolution, SchemaResolutionSource } from '@xyo-network/domain-payload-plugin'\nimport { DomainPayloadWrapper, DomainSchemaResolver } from '@xyo-network/domain-payload-plugin'\nimport type { FetchedPayload } from '@xyo-network/huri'\nimport type { SchemaPayload } from '@xyo-network/schema-payload-plugin'\nimport { SchemaSchema } from '@xyo-network/schema-payload-plugin'\nimport type { SchemaObject } from 'ajv'\nimport { Ajv } from 'ajv'\n\nimport { Debounce } from './Debounce.ts'\nimport type { SchemaNameToValidatorMap } from './SchemaNameToValidatorMap.ts'\nimport { TtlLruCache } from './TtlLruCache.ts'\n\nconst getSchemaNameFromSchema = (schema: SchemaObject) => {\n  if (isString(schema.$id)) {\n    return schema.$id\n  }\n}\n\nexport interface SchemaCacheEntry extends FetchedPayload<SchemaPayload> {\n  /** Provenance of the schema definition when resolved via the domain schema authority */\n  source?: SchemaResolutionSource\n}\n\nexport class SchemaCache<T extends SchemaNameToValidatorMap = SchemaNameToValidatorMap> {\n  /**\n   * Object representing `null` since LRU Cache types\n   * only allow for types that derive from object\n   */\n  protected static readonly NULL: SchemaCacheEntry = { payload: { definition: {}, schema: SchemaSchema } }\n\n  private static _instance?: SchemaCache\n\n  private _cache = new TtlLruCache<string, SchemaCacheEntry>({ max: 500, ttl: 1000 * 60 * 5 })\n  private _resolutions = new TtlLruCache<string, SchemaResolution>({ max: 500, ttl: 1000 * 60 * 5 })\n  private _validators: T = {} as T\n\n  // prevents double discovery\n  private getDebounce = new Debounce()\n\n  onSchemaCached?: (name: string, entry: SchemaCacheEntry) => void\n  proxy?: string\n\n  private constructor(proxy?: string) {\n    this.proxy = proxy\n  }\n\n  static get instance() {\n    this._instance ??= new SchemaCache()\n    return this._instance\n  }\n\n  private cacheSchemaIfValid(entry: SchemaCacheEntry) {\n    if (!isDefined(entry?.payload?.definition)) {\n      return\n    }\n\n    const ajv = new Ajv({ strict: false })\n    // check if it is a valid schema def\n    const validator = ajv.compile(entry.payload.definition)\n    const schemaName = getSchemaNameFromSchema(entry.payload.definition)\n    if (isString(schemaName)) {\n      this._cache.set(schemaName, entry)\n      const key = schemaName as keyof T\n      this._validators[key] = validator as unknown as T[keyof T]\n      this.onSchemaCached?.(schemaName, entry)\n    }\n  }\n\n  private cacheSchemas(aliasEntries?: FetchedPayload[] | null) {\n    for (const entry of aliasEntries?.filter(entry => entry.payload.schema === SchemaSchema) ?? []) {\n      this.cacheSchemaIfValid(entry as SchemaCacheEntry)\n    }\n  }\n\n  private async fetchSchema(schema: string) {\n    try {\n      // domain schema authority resolution first (DNS records, xyo.json, xyo. subdomain)\n      const resolution = await this.resolve(schema)\n      if (resolution?.status === 'resolved') {\n        return\n      }\n\n      // legacy discovery fallback; also opportunistically warms sibling schemas\n      const domain = await DomainPayloadWrapper.discover(schema, this.proxy)\n      await domain?.fetch()\n      this.cacheSchemas(domain?.aliases)\n\n      // if it is still undefined, mark it as null (not found) \u2014 but never cache transport\n      // failures as permanent negatives; 'unreachable' stays undefined so it is retried\n      if (this._cache.get(schema) === undefined && resolution?.status !== 'unreachable') {\n        this._cache.set(schema, SchemaCache.NULL)\n      }\n    } catch (error) {\n      // transport failure: leave the entry undefined so a future get() retries\n      if (error instanceof FetchClientError) {\n        console.log(`Fetch Url: ${error.config.url}`)\n      }\n      handleError(error, (error) => {\n        console.error(`fetchSchema threw: ${error.message}`)\n      })\n    }\n  }\n\n  /**\n   * A map of cached schema (by name) to payload validators for the schema. A schema\n   * must be cached via `get('schema.name')` before it's validator can be used as\n   * they are compiled dynamically at runtime upon retrieval.\n   */\n  get validators(): T {\n    return this._validators\n  }\n\n  async get(schema?: string): Promise<SchemaCacheEntry | undefined | null> {\n    if (isString(schema)) {\n      await this.getDebounce.one(schema, async () => {\n        // If we've never looked for it before, it will be undefined\n        if (this._cache.get(schema) === undefined) {\n          await this.fetchSchema(schema)\n        }\n      })\n      const value = this._cache.get(schema)\n      return value === SchemaCache.NULL ? null : value\n    }\n    return undefined\n  }\n\n  /**\n   * Resolve a schema name to its domain-published authoritative definition (SPEC.md in\n   * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():\n   * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and\n   * their validators compiled, exactly as with get(). 'unreachable' results are\n   * retryable: they are not cached as permanent negatives.\n   */\n  async resolve(schema?: string): Promise<SchemaResolution | undefined> {\n    if (!isString(schema)) return undefined\n    await this.getDebounce.one(`resolve:${schema}`, async () => {\n      const existing = this._resolutions.get(schema)\n      if (existing === undefined || existing.status === 'unreachable') {\n        const resolver = new DomainSchemaResolver()\n        const resolution = await resolver.resolve(schema, { proxy: this.proxy })\n        this._resolutions.set(schema, resolution)\n        if (resolution.status === 'resolved' && isDefined(resolution.payload)) {\n          this.cacheSchemaIfValid({ payload: resolution.payload, source: resolution.source })\n        }\n      }\n    })\n    return this._resolutions.get(schema)\n  }\n}\n", "export interface TtlLruCacheOpts {\n  max: number\n  ttl: number\n}\n\nexport class TtlLruCache<K, V> {\n  private readonly map = new Map<K, { expires: number; value: V }>()\n  private readonly max: number\n  private readonly ttl: number\n\n  constructor(opts: TtlLruCacheOpts) {\n    this.max = opts.max\n    this.ttl = opts.ttl\n  }\n\n  get(key: K): V | undefined {\n    const entry = this.map.get(key)\n    if (entry === undefined) return undefined\n    if (entry.expires <= Date.now()) {\n      this.map.delete(key)\n      return undefined\n    }\n    this.map.delete(key)\n    this.map.set(key, entry)\n    return entry.value\n  }\n\n  set(key: K, value: V): void {\n    if (this.map.has(key)) this.map.delete(key)\n    this.map.set(key, { value, expires: Date.now() + this.ttl })\n    if (this.map.size > this.max) {\n      const oldest = this.map.keys().next().value\n      if (oldest !== undefined) this.map.delete(oldest)\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["isDefined", "isDefined", "entry", "error"]
 }

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@xyo-network/schema-cache",
-  "version": "7.0.12",
-  "description": "DEPRECATED - use @xyo-network/sdk-protocol/schema-cache. Backward-compatibility re-export stub for @xyo-network/schema-cache.",
-  "deprecated": "Use @xyo-network/sdk-protocol/schema-cache instead. @xyo-network/schema-cache is a backward-compatibility re-export stub and will not receive further updates.",
+  "version": "7.0.13",
+  "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
     "url": "git+https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues",
@@ -35,34 +34,52 @@
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/sdk-protocol": "~7.0.12"
+    "@xyo-network/domain-payload-plugin": "~7.0.13",
+    "@xyo-network/huri": "~7.0.13",
+    "@xyo-network/schema-payload-plugin": "~7.0.13",
+    "@xyo-network/payload-model": "~7.0.13"
   },
   "devDependencies": {
-    "@xylabs/toolchain": "~8.5.15",
-    "@xylabs/tsconfig": "~8.5.15",
-    "browserslist": "4.28.4",
-    "eslint": "^10.6.0",
-    "eslint-import-resolver-typescript": "^4.4.5",
-    "typescript": "~6.0.3"
+    "@ariestools/sdk": "~7.0.8",
+    "@bitauth/libauth": "~3.0.0",
+    "@opentelemetry/api": "~1.9.1",
+    "@opentelemetry/sdk-trace-base": "~2.9.0",
+    "@scure/base": "~2.2.0",
+    "@xylabs/threads": "~7.0.8",
+    "@xylabs/toolchain": "~8.6.2",
+    "@xylabs/tsconfig": "~8.6.2",
+    "@xylabs/tsconfig-dom": "~8.6.2",
+    "@xylabs/vitest-extended": "~7.0.8",
+    "ajv": "~8.20.0",
+    "async-mutex": "~0.5.0",
+    "browserslist": "~4.28.4",
+    "debug": "~4.4.3",
+    "eslint": "~10.6.0",
+    "eslint-import-resolver-typescript": "~4.4.5",
+    "ethers": "~6.17.0",
+    "hash-wasm": "~4.12.0",
+    "observable-fns": "~0.6.1",
+    "typescript": "~6.0.3",
+    "vite": "~8.1.3",
+    "vitest": "~4.1.9",
+    "zod": "~4.4.3",
+    "@xyo-network/network": "~7.0.13",
+    "@xyo-network/payload-builder": "~7.0.13"
   },
   "peerDependencies": {
-    "@ariestools/sdk": "^7.0.4",
-    "@bitauth/libauth": "~3.0",
-    "@noble/post-quantum": "~0.6.1",
-    "@opentelemetry/api": "^1.9",
-    "@opentelemetry/sdk-trace-base": "^2.7",
-    "@scure/base": "~2.2",
-    "@scure/bip39": "~2.2",
-    "@xylabs/geo": "^7.0",
-    "@xylabs/threads": "^7.0",
-    "ajv": "^8.20",
-    "async-mutex": "^0.5",
-    "debug": "^4.4",
-    "ethers": "^6.16",
-    "hash-wasm": "~4.12",
-    "idb": "^8.0",
-    "observable-fns": "^0.6",
-    "zod": "^4.4"
+    "@ariestools/sdk": "^7.0.8",
+    "@bitauth/libauth": "^3.0.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/sdk-trace-base": "^2.9.0",
+    "@scure/base": "^2.2.0",
+    "@xylabs/threads": "^7.0.8",
+    "ajv": "^8.20.0",
+    "async-mutex": "^0.5.0",
+    "debug": "^4.4.3",
+    "ethers": "^6.17.0",
+    "hash-wasm": "^4.12.0",
+    "observable-fns": "^0.6.1",
+    "zod": "^4.4.3"
   },
   "engines": {
     "node": "^24"