@agoric/internal 0.3.3-other-dev-8f8782b.0 → 0.3.3-other-dev-fbe72e7.0.fbe72e7

package/src/lib-nodejs/worker-protocol.js

@@ -0,0 +1,54 @@
+/* eslint-env node */
+import { Transform } from 'stream';
+
+// Transform objects which convert from hardened Arrays of JSON-serializable
+// data into Buffers suitable for netstring conversion.
+
+export function arrayEncoderStream() {
+  /**
+   * @param {any} object
+   * @param {BufferEncoding} encoding
+   * @param {any} callback
+   * @this {{ push: (b: Buffer) => void }}
+   */
+  function transform(object, encoding, callback) {
+    if (!Array.isArray(object)) {
+      throw Error('stream requires Arrays');
+    }
+    let err;
+    try {
+      this.push(Buffer.from(JSON.stringify(object)));
+    } catch (e) {
+      err = e;
+    }
+    callback(err);
+  }
+  // Array in, Buffer out, hence writableObjectMode
+  return new Transform({ transform, writableObjectMode: true });
+}
+
+export function arrayDecoderStream() {
+  /**
+   * @param {Buffer} buf
+   * @param {BufferEncoding} encoding
+   * @param {any} callback
+   * @this {{ push: (b: Buffer) => void }}
+   */
+  function transform(buf, encoding, callback) {
+    let err;
+    try {
+      if (!Buffer.isBuffer(buf)) {
+        throw Error('stream expects Buffers');
+      }
+      this.push(JSON.parse(buf.toString()));
+    } catch (e) {
+      err = e;
+    }
+    // this Transform is a one-to-one conversion of Buffer into Array, so we
+    // always consume the input each time we're called
+    callback(err);
+  }
+
+  // Buffer in, Array out, hence readableObjectMode
+  return new Transform({ transform, readableObjectMode: true });
+}

package/src/magic-cookie-test-only.js

@@ -3,8 +3,8 @@
 const cookie = harden({});
 
 /**
- * Facilitate static analysis to prevent
- * demo/test facilities from being bundled in production.
+ * Facilitate static analysis to prevent demo/test facilities from being bundled
+ * in production.
  */
 export const notForProductionUse = () => {
   return cookie;

package/src/marshal.d.ts

@@ -0,0 +1,33 @@
+export function makeBoardRemote({ boardId, iface }: {
+    boardId: string | null;
+    iface?: string;
+}): BoardRemote;
+export function slotToBoardRemote(boardId: string, iface: string): BoardRemote;
+export function boardSlottingMarshaller(slotToVal?: (slot: string, iface: string) => any): Omit<import("@endo/marshal").Marshal<string | null>, "serialize" | "unserialize">;
+/**
+ * @type {TypedPattern<CapData<any>>}
+ */
+export const CapDataShape: TypedPattern<CapData<any>>;
+export function assertCapData(data: unknown): asserts data is CapData<unknown>;
+export function unmarshalFromVstorage(data: Map<string, string>, key: string, fromCapData: ReturnType<typeof import("@endo/marshal").makeMarshal>["fromCapData"], index: number): any;
+export function makeHistoryReviver(entries: [string, string][], slotToVal?: (slot: string, iface?: string) => any): {
+    getItem: (key: string) => any;
+    children: (prefix: string) => string[];
+    has: (k: string) => boolean;
+};
+export const pureDataMarshaller: {
+    toCapData: import("@endo/marshal").ToCapData<CapData<unknown>>;
+    fromCapData: import("@endo/marshal").FromCapData<CapData<unknown>>;
+    serialize: import("@endo/marshal").ToCapData<CapData<unknown>>;
+    unserialize: import("@endo/marshal").FromCapData<CapData<unknown>>;
+};
+/**
+ * Should be a union with Remotable, but that's `any`, making this type
+ * meaningless
+ */
+export type BoardRemote = {
+    getBoardId: () => string | null;
+};
+import type { CapData } from '@endo/marshal';
+import type { TypedPattern } from './types.js';
+//# sourceMappingURL=marshal.d.ts.map

package/src/marshal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marshal.d.ts","sourceRoot":"","sources":["marshal.js"],"names":[],"mappings":"AAuBO,oDAHI;IAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,WAAW,CAKvB;AAMM,2CAHI,MAAM,SACN,MAAM,eAGoB;AAqB9B,oDANI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,GAClC,IAAI,CAChB,OAAW,eAAe,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAClD,WAAe,GAAG,aAAa,CAC5B,CAMH;AAGD;;GAEG;AACH,2BAFU,aAAa,QAAQ,GAAG,CAAC,CAAC,CAE+B;AAS5D,oCAHI,OAAO,GACL,QAAQ,IAAI,IAAI,QAAQ,OAAO,CAAC,CAO5C;AAeM,4CATI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,OACnB,MAAM,eACN,UAAU,CACpB,cAAkB,eAAe,EAAE,WAAW,CAC3C,CAAC,aAAa,CAAC,SACR,MAAM,GAEJ,GAAG,CAwBf;AASM,4CAHI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,cAClB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,GAAG;mBAQlC,MAAM;uBAEN,MAAM;aAYN,MAAM;EAInB;AAID;;;;;EAEG;;;;;0BA1IU;IAAE,UAAU,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CAAE;6BARtB,eAAe;kCACV,YAAY"}

package/src/marshal.js

@@ -0,0 +1,156 @@
+// @ts-check
+import { Fail } from '@endo/errors';
+import { Far } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+import { M } from '@endo/patterns';
+import { isStreamCell } from './lib-chainStorage.js';
+
+/**
+ * @import {CapData} from '@endo/marshal';
+ * @import {TypedPattern} from './types.js';
+ */
+
+/**
+ * Should be a union with Remotable, but that's `any`, making this type
+ * meaningless
+ *
+ * @typedef {{ getBoardId: () => string | null }} BoardRemote
+ */
+
+/**
+ * @param {{ boardId: string | null; iface?: string }} slotInfo
+ * @returns {BoardRemote}
+ */
+export const makeBoardRemote = ({ boardId, iface }) => {
+  const nonalleged = iface ? iface.replace(/^Alleged: /, '') : '';
+  return Far(`BoardRemote${nonalleged}`, { getBoardId: () => boardId });
+};
+
+/**
+ * @param {string} boardId
+ * @param {string} iface
+ */
+export const slotToBoardRemote = (boardId, iface) =>
+  makeBoardRemote({ boardId, iface });
+
+/** @param {BoardRemote | object} val */
+const boardValToSlot = val => {
+  if ('getBoardId' in val) {
+    return val.getBoardId();
+  }
+  throw Fail`unknown obj in boardSlottingMarshaller.valToSlot ${val}`;
+};
+
+/**
+ * A marshaller which can serialize getBoardId() -bearing Remotables. This
+ * allows the caller to pick their slots. The deserializer is configurable: the
+ * default cannot handle Remotable-bearing data.
+ *
+ * @param {(slot: string, iface: string) => any} [slotToVal]
+ * @returns {Omit<
+ *   import('@endo/marshal').Marshal<string | null>,
+ *   'serialize' | 'unserialize'
+ * >}
+ */
+export const boardSlottingMarshaller = (slotToVal = undefined) => {
+  return makeMarshal(boardValToSlot, slotToVal, {
+    serializeBodyFormat: 'smallcaps',
+  });
+};
+
+// TODO move CapDataShape to Endo
+/**
+ * @type {TypedPattern<CapData<any>>}
+ */
+export const CapDataShape = { body: M.string(), slots: M.array() };
+harden(CapDataShape);
+
+/**
+ * Assert that this is CapData
+ *
+ * @param {unknown} data
+ * @returns {asserts data is CapData<unknown>}
+ */
+export const assertCapData = data => {
+  assert.typeof(data, 'object');
+  assert(data);
+  typeof data.body === 'string' || Fail`data has non-string .body ${data.body}`;
+  Array.isArray(data.slots) || Fail`data has non-Array slots ${data.slots}`;
+};
+harden(assertCapData);
+
+/**
+ * Read and unmarshal a value from a map representation of vstorage data
+ *
+ * @param {Map<string, string>} data
+ * @param {string} key
+ * @param {ReturnType<
+ *   typeof import('@endo/marshal').makeMarshal
+ * >['fromCapData']} fromCapData
+ * @param {number} index index of the desired value in a deserialized stream
+ *   cell
+ * @returns {any}
+ */
+export const unmarshalFromVstorage = (data, key, fromCapData, index) => {
+  const serialized = data.get(key) || Fail`no data for ${key}`;
+  assert.typeof(serialized, 'string');
+  assert.typeof(index, 'number');
+
+  const streamCell = JSON.parse(serialized);
+  if (!isStreamCell(streamCell)) {
+    throw Fail`not a StreamCell: ${streamCell}`;
+  }
+
+  const { values } = streamCell;
+  values.length > 0 || Fail`no StreamCell values: ${streamCell}`;
+
+  const marshalled = values.at(index);
+  assert.typeof(marshalled, 'string');
+
+  /** @type {import('@endo/marshal').CapData<string>} */
+  const capData = harden(JSON.parse(marshalled));
+  assertCapData(capData);
+
+  const unmarshalled = fromCapData(capData);
+  return unmarshalled;
+};
+harden(unmarshalFromVstorage);
+
+/**
+ * Provide access to object graphs serialized in vstorage.
+ *
+ * @param {[string, string][]} entries
+ * @param {(slot: string, iface?: string) => any} [slotToVal]
+ */
+export const makeHistoryReviver = (entries, slotToVal = undefined) => {
+  const board = boardSlottingMarshaller(slotToVal);
+  const vsMap = new Map(entries);
+  /** @param {...unknown} args } */
+  const fromCapData = (...args) =>
+    Reflect.apply(board.fromCapData, board, args);
+  /** @param {string} key } */
+  const getItem = key => unmarshalFromVstorage(vsMap, key, fromCapData, -1);
+  /** @param {string} prefix } */
+  const children = prefix => {
+    prefix.endsWith('.') || Fail`prefix must end with '.'`;
+    return harden([
+      ...new Set(
+        entries
+          .map(([k, _]) => k)
+          .filter(k => k.startsWith(prefix))
+          .map(k => k.slice(prefix.length).split('.')[0]),
+      ),
+    ]);
+  };
+  /** @param {string} k } */
+  const has = k => vsMap.get(k) !== undefined;
+
+  return harden({ getItem, children, has });
+};
+
+/** @param {import('@endo/marshal').CapData<unknown>} cap */
+const rejectOCap = cap => Fail`${cap} is not pure data`;
+export const pureDataMarshaller = makeMarshal(rejectOCap, rejectOCap, {
+  serializeBodyFormat: 'smallcaps',
+});
+harden(pureDataMarshaller);

package/src/method-tools.d.ts

@@ -1,3 +1,4 @@
 export function getMethodNames<K extends PropertyKey>(val: Record<K, any>): K[];
+export function getStringMethodNames<K extends PropertyKey>(val: Record<K, any>): string[];
 export function bindAllMethods<T extends Record<PropertyKey, any>>(obj: T): T;
 //# sourceMappingURL=method-tools.d.ts.map

package/src/method-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AAyCO,gFAoBN;AAgCM,8EAeJ"}
+{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AAmBO,+BAJoB,CAAC,SAAd,WAAY,OACf,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GACZ,CAAC,EAAE,CAG8B;AAUvC,qCAJoB,CAAC,SAAd,WAAY,OACf,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GACZ,MAAM,EAAE,CAKlB;AA+BI,+BAJiC,CAAC,SAA3B,MAAM,CAAC,WAAW,EAAE,GAAG,CAAE,OAC5B,CAAC,GACC,CAAC,CAiBX"}

package/src/method-tools.js

@@ -1,86 +1,57 @@
 // @ts-check
-import { isObject } from '@endo/marshal';
+import { getMethodNames as realGetMethodNames } from '@endo/eventual-send/utils.js';
 
 /**
- * @file method-tools use dynamic property lookup, which is not Jessie-compatible
+ * @file method-tools use dynamic property lookup, which is not
+ *   Jessie-compatible
  */
 
-const { getPrototypeOf, create, fromEntries, getOwnPropertyDescriptors } =
-  Object;
-const { ownKeys, apply } = Reflect;
+const { create, fromEntries } = Object;
+const { apply } = Reflect;
 
 /**
- * Prioritize symbols as earlier than strings.
+ * TODO Consolidate with the `getMethodNames` in `@endo/eventual-send`
  *
- * @param {string|symbol} a
- * @param {string|symbol} b
- * @returns {-1 | 0 | 1}
+ * @deprecated Use `getMethodNames` from `@endo/eventual-send/utils.js` instead.
+ * @template {PropertyKey} K
+ * @param {Record<K, any>} val
+ * @returns {K[]}
  */
-const compareStringified = (a, b) => {
-  if (typeof a === typeof b) {
-    const left = String(a);
-    const right = String(b);
-    // eslint-disable-next-line no-nested-ternary
-    return left < right ? -1 : left > right ? 1 : 0;
-  }
-  if (typeof a === 'symbol') {
-    assert(typeof b === 'string');
-    return -1;
-  }
-  assert(typeof a === 'string');
-  assert(typeof b === 'symbol');
-  return 1;
-};
+export const getMethodNames = val =>
+  /** @type {K[]} */ (realGetMethodNames(val));
+harden(getMethodNames);
 
 /**
- * TODO Consolidate with the `getMethodNames` in `@endo/eventual-send`
+ * The subset of `getMethodNames` containing only string names, without symbols
  *
  * @template {PropertyKey} K
  * @param {Record<K, any>} val
- * @returns {K[]}
+ * @returns {string[]}
  */
-export const getMethodNames = val => {
-  let layer = val;
-  const names = new Set(); // Set to deduplicate
-  while (layer !== null && layer !== Object.prototype) {
-    // be tolerant of non-objects
-    const descs = getOwnPropertyDescriptors(layer);
-    const ownNames = /** @type {K[]} */ (ownKeys(descs));
-    for (const name of ownNames) {
-      // In case a method is overridden by a non-method,
-      // test `val[name]` rather than `layer[name]`
-      if (typeof val[name] === 'function') {
-        names.add(name);
-      }
-    }
-    if (!isObject(val)) {
-      break;
-    }
-    layer = getPrototypeOf(layer);
-  }
-  return harden([...names].sort(compareStringified));
-};
-harden(getMethodNames);
+export const getStringMethodNames = val =>
+  /** @type {string[]} */ (
+    realGetMethodNames(val).filter(name => typeof name === 'string')
+  );
 
 /**
  * TODO This function exists only to ease the
  * https://github.com/Agoric/agoric-sdk/pull/5970 transition, from all methods
- * being own properties to methods being inherited from a common prototype.
- * This transition breaks two patterns used in prior code: autobinding,
- * and enumerating methods by enumerating own properties. For both, the
- * preferred repairs are
- *    * autobinding: Replace, for example,
- *      `foo(obj.method)` with `foo(arg => `obj.method(arg))`. IOW, stop relying
- *      on expressions like `obj.method` to extract a method still bound to the
- *      state of `obj` because, for virtual and durable objects,
- *      they no longer will after #5970.
- *    * method enumeration: Replace, for example
- *      `Reflect.ownKeys(obj)` with `getMethodNames(obj)`.
+ * being own properties to methods being inherited from a common prototype. This
+ * transition breaks two patterns used in prior code: autobinding, and
+ * enumerating methods by enumerating own properties. For both, the preferred
+ * repairs are
+ *
+ * - autobinding: Replace, for example, `foo(obj.method)` with `foo(arg =>
+ *   `obj.method(arg))`. IOW, stop relying on expressions like `obj.method`to
+ *   extract a method still bound to the state of`obj` because, for virtual and
+ *   durable objects, they no longer will after #5970.
+ * - method enumeration: Replace, for example `Reflect.ownKeys(obj)` with
+ *   `getMethodNames(obj)`.
  *
  * Once all problematic cases have been converted in this manner, this
  * `bindAllMethods` hack can and TODO should be deleted. However, we currently
- * have no reliable static way to track down and fix all autobinding sites.
- * For those objects that have not yet been fully repaired by the above two
+ * have no reliable static way to track down and fix all autobinding sites. For
+ * those objects that have not yet been fully repaired by the above two
  * techniques, `bindAllMethods` creates an object that acts much like the
  * pre-#5970 objects, with all their methods as instance-bound own properties.
  * It does this by making a new object inheriting from `obj` where the new
@@ -96,7 +67,7 @@ export const bindAllMethods = obj =>
     create(
       obj,
       fromEntries(
-        getMethodNames(obj).map(name => [
+        realGetMethodNames(obj).map(name => [
           name,
           {
             value: (/** @type {unknown[]} */ ...args) =>

package/src/metrics.d.ts

@@ -0,0 +1,183 @@
+export namespace HISTOGRAM_METRICS {
+    namespace swingset_crank_processing_time {
+        let description: "Processing time per crank (ms)";
+        let unit: "ms";
+        let boundaries: number[];
+    }
+    namespace swingset_block_processing_seconds {
+        let description_1: "Processing time per block";
+        export { description_1 as description };
+        let unit_1: "s";
+        export { unit_1 as unit };
+        export { HISTOGRAM_SECONDS_LATENCY_BOUNDARIES as boundaries };
+    }
+    namespace swingset_vat_startup {
+        let description_2: "Vat startup time (ms)";
+        export { description_2 as description };
+        let unit_2: "ms";
+        export { unit_2 as unit };
+        export { HISTOGRAM_MS_LATENCY_BOUNDARIES as boundaries };
+    }
+    namespace swingset_vat_delivery {
+        let description_3: "Vat delivery time (ms)";
+        export { description_3 as description };
+        let unit_3: "ms";
+        export { unit_3 as unit };
+        export { HISTOGRAM_MS_LATENCY_BOUNDARIES as boundaries };
+    }
+    namespace swingset_meter_usage {
+        let description_4: "Vat meter usage";
+        export { description_4 as description };
+        let unit_4: "ms";
+        export { unit_4 as unit };
+        export { HISTOGRAM_MS_LATENCY_BOUNDARIES as boundaries };
+    }
+}
+export namespace BLOCK_HISTOGRAM_METRICS {
+    namespace swingsetRunSeconds {
+        let unit_5: string;
+        export { unit_5 as unit };
+        export namespace advice {
+            let explicitBucketBoundaries: number[];
+        }
+        let description_5: "Per-block time spent executing SwingSet";
+        export { description_5 as description };
+    }
+    namespace swingsetChainSaveSeconds {
+        let unit_6: string;
+        export { unit_6 as unit };
+        export namespace advice_1 { }
+        export { advice_1 as advice };
+        let description_6: "Per-block time spent propagating SwingSet state into cosmos";
+        export { description_6 as description };
+    }
+    namespace swingsetCommitSeconds {
+        let unit_7: string;
+        export { unit_7 as unit };
+        export namespace advice_2 { }
+        export { advice_2 as advice };
+        let description_7: "Per-block time spent committing SwingSet state to host storage";
+        export { description_7 as description };
+    }
+    namespace cosmosCommitSeconds {
+        let unit_8: string;
+        export { unit_8 as unit };
+        export namespace advice_3 { }
+        export { advice_3 as advice };
+        let description_8: "Per-block time spent committing cosmos state";
+        export { description_8 as description };
+    }
+    namespace fullCommitSeconds {
+        let unit_9: string;
+        export { unit_9 as unit };
+        export namespace advice_4 { }
+        export { advice_4 as advice };
+        let description_9: "Per-block time spent committing state, inclusive of COMMIT_BLOCK processing plus time spent [outside of cosmic-swingset] before and after it";
+        export { description_9 as description };
+    }
+    namespace interBlockSeconds {
+        let unit_10: string;
+        export { unit_10 as unit };
+        export namespace advice_5 { }
+        export { advice_5 as advice };
+        let description_10: "Time spent idle between blocks";
+        export { description_10 as description };
+    }
+    namespace afterCommitHangoverSeconds {
+        let unit_11: string;
+        export { unit_11 as unit };
+        export namespace advice_6 { }
+        export { advice_6 as advice };
+        let description_11: "Per-block time spent waiting for previous-block afterCommit work";
+        export { description_11 as description };
+    }
+    namespace blockLagSeconds {
+        export namespace advice_7 {
+            let explicitBucketBoundaries_1: number[];
+            export { explicitBucketBoundaries_1 as explicitBucketBoundaries };
+        }
+        export { advice_7 as advice };
+        let unit_12: string;
+        export { unit_12 as unit };
+        let description_12: "The delay of each block from its expected begin time";
+        export { description_12 as description };
+    }
+}
+export type QueueMetricAspect = (typeof QueueMetricAspect)[keyof typeof QueueMetricAspect];
+export namespace QueueMetricAspect {
+    let Length: "length";
+    let IncrementCount: "increments";
+    let DecrementCount: "decrements";
+}
+export function makeQueueMetricsMeta(namePrefix: string, descPrefix: string): Record<QueueMetricAspect, {
+    name: string;
+    options: MetricAttributes;
+}>;
+export function makeQueueMetrics<QueueName extends string>({ otelMeter, namePrefix, descPrefix, console, }: {
+    otelMeter: OTelMeter;
+    namePrefix: string;
+    descPrefix: string;
+    console?: Pick<Console, "warn"> | undefined;
+}): QueueMetrics<QueueName>;
+/**
+ * @typedef KernelMetricMeta
+ * @property {string} key
+ * @property {string} name
+ * @property {{ dimension: string; value: string }} [sub]
+ * @property {string} description
+ * @property {boolean} [consensus]
+ * @property {MetricType} metricType
+ */
+/** @type {Omit<KernelMetricMeta, 'metricType'>[]} */
+export const KERNEL_STATS_SUM_METRICS: Omit<KernelMetricMeta, "metricType">[];
+/** @type {Omit<KernelMetricMeta, 'metricType'>[]} */
+export const KERNEL_STATS_UPDOWN_METRICS: Omit<KernelMetricMeta, "metricType">[];
+/** @type {KernelMetricMeta[]} */
+export const KERNEL_STATS_METRICS: KernelMetricMeta[];
+export type QueueMetrics<QueueName extends string> = {
+    /**
+     * must be
+     * called before any other function
+     */
+    initLengths: (lengths: Record<QueueName, number>) => void;
+    updateLengths: (lengths: Record<QueueName, number>) => void;
+    /**
+     * for a
+     * non-negative delta
+     */
+    incLength: (queue: QueueName, delta?: number) => void;
+    /**
+     * for a
+     * non-negative delta
+     */
+    decLength: (queue: QueueName, delta?: number) => void;
+};
+export type KernelMetricMeta = {
+    key: string;
+    name: string;
+    sub?: {
+        dimension: string;
+        value: string;
+    } | undefined;
+    description: string;
+    consensus?: boolean | undefined;
+    metricType: MetricType;
+};
+declare const HISTOGRAM_SECONDS_LATENCY_BOUNDARIES: number[];
+/**
+ * @import {Meter as OTelMeter, MetricAttributes} from '@opentelemetry/api';
+ * @import {TotalMap} from '@agoric/internal';
+ */
+declare const HISTOGRAM_MS_LATENCY_BOUNDARIES: number[];
+import type { MetricAttributes } from '@opentelemetry/api';
+import type { Meter as OTelMeter } from '@opentelemetry/api';
+/**
+ * MetricType
+ */
+type MetricType = (typeof MetricType)[keyof typeof MetricType];
+declare namespace MetricType {
+    let Counter: "counter";
+    let Gauge: "gauge";
+}
+export {};
+//# sourceMappingURL=metrics.d.ts.map

package/src/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["metrics.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAqH2C,MAAM,EAAE;;;;;;;;;;gCAQxC,CAAC,OAAO,iBAAiB,EAAE,MAAM,OAAO,iBAAiB,CAAC;;;;;;AAiB9D,iDAPI,MAAM,cACN,MAAM,GACJ,MAAM,CACd,iBAAiB,EACrB;IAAM,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,CAC5C,CAoBH;AA0BM,iCARe,SAAS,SAAlB,MAAQ,mDAElB;IAA0B,SAAS,EAA3B,SAAS;IACM,UAAU,EAAzB,MAAM;IACS,UAAU,EAAzB,MAAM;IACyB,OAAO;CAC9C,GAAU,YAAY,CAAC,SAAS,CAAC,CA8GnC;AAQD;;;;;;;;GAQG;AACH,qDAAqD;AACrD,uCADW,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,EAAE,CAkF/C;AAEF,qDAAqD;AACrD,0CADW,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,EAAE,CA4D/C;AAGF,iCAAiC;AACjC,mCADW,gBAAgB,EAAE,CAI1B;yBA3SmB,SAAS,SAAlB,MAAQ;;;;;iBAEP,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,IAAI;mBAE5C,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,IAAI;;;;;eAC5C,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI;;;;;eAE1C,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI;;;SAsI1C,MAAM;UACN,MAAM;;mBACO,MAAM;eAAS,MAAM;;iBAClC,MAAM;;gBAEN,UAAU;;AAnRxB,6DACuD;AApBvD;;;GAGG;AAEH,wDAaE;sCAjBqD,oBAAoB;wCAApB,oBAAoB;;;;kBAyRhE,CAAC,OAAO,UAAU,EAAE,MAAM,OAAO,UAAU,CAAC"}