@reventlessdev/reventless-local 3.0.0-alpha.318 → 3.0.0-alpha.320

package/src/adapter/CommandOutcomeLog/CommandOutcomeLogStorage_Sqlite.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+
+let table = "reventless_command_outcomes";
+
+function ensureSchema(db) {
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE TABLE IF NOT EXISTS ` + table + ` (seq INTEGER PRIMARY KEY AUTOINCREMENT, flow TEXT, msg_id TEXT NOT NULL, item TEXT NOT NULL)`);
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE INDEX IF NOT EXISTS ` + table + `_flow ON ` + table + ` (flow, seq)`);
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE INDEX IF NOT EXISTS ` + table + `_msg ON ` + table + ` (msg_id)`);
+}
+
+function str(prim) {
+  return prim;
+}
+
+function append(db, e) {
+  SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, `INSERT INTO ` + table + ` (flow, msg_id, item) VALUES (?, ?, ?)`), [
+    Stdlib_Option.mapOr(e.flow, null, str),
+    e.msgId,
+    JSON.stringify(e.item)
+  ]);
+}
+
+function entryOfRow(row) {
+  let s = k => Stdlib_Option.flatMap(row[k], Stdlib_JSON.Decode.string);
+  let match = Stdlib_Option.flatMap(row["seq"], Stdlib_JSON.Decode.float);
+  let match$1 = s("msg_id");
+  let match$2 = Stdlib_Option.flatMap(s("item"), i => {
+    try {
+      return JSON.parse(i);
+    } catch (exn) {
+      return;
+    }
+  });
+  if (match !== undefined && match$1 !== undefined && match$2 !== undefined) {
+    return {
+      seq: match | 0,
+      flow: s("flow"),
+      msgId: match$1,
+      item: match$2
+    };
+  }
+}
+
+function read(db, filter, before, first) {
+  let where = [];
+  let params = [];
+  let add = (clause, value) => {
+    where.push(clause);
+    params.push(value);
+  };
+  Stdlib_Option.forEach(filter.correlationId, c => add("flow = ?", c));
+  Stdlib_Option.forEach(filter.msgId, m => add("msg_id = ?", m));
+  Stdlib_Option.forEach(before, b => add("seq < ?", b));
+  let sql = `SELECT seq, flow, msg_id, item FROM ` + table + (
+    Primitive_object.equal(where, []) ? "" : " WHERE " + where.join(" AND ")
+  ) + ` ORDER BY seq DESC LIMIT ?`;
+  params.push(first);
+  return Stdlib_Array.filterMap(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, sql), params), entryOfRow);
+}
+
+export {
+  table,
+  ensureSchema,
+  str,
+  append,
+  entryOfRow,
+  read,
+}
+/* SqliteDriver-ReventlessLocal Not a pure module */

package/src/adapter/CommandOutcomeLog/LocalCommandOutcomeLog.res

@@ -0,0 +1,88 @@
+// What became of every command the local platform handled, kept and read back by flow or by
+// the command's message id: a tool that missed an outcome live reads it here. Stored as the
+// row changes are (`LocalViewChangeLog`), each as the tap's `commandOutcome` line.
+
+module Outcome = ReventlessCore.CommandTopic_Helpers
+
+type page = LocalViewChangeLog.page
+
+let sqliteReady = ref(None)
+
+/** The SQLite store when the platform runs on one, its table made once. */
+let sqlite = () =>
+  switch BackendState.getSqliteDb() {
+  | Some(db) =>
+    if sqliteReady.contents !== Some(db) {
+      CommandOutcomeLogStorage_Sqlite.ensureSchema(db)
+      sqliteReady := Some(db)
+    }
+    Some(db)
+  | None => None
+  }
+
+let nextSeq = ref(0)
+
+let record = (r: Outcome.commandOutcomeReport) => {
+  let entry: CommandOutcomeLogEntry.t = {
+    seq: 0,
+    flow: ?r.correlationId,
+    msgId: r.reference,
+    item: LocalTapLines.outcomeLine(r)->JSON.parseOrThrow,
+  }
+  switch sqlite() {
+  | Some(db) => CommandOutcomeLogStorage_Sqlite.append(db, entry)
+  | None =>
+    nextSeq := nextSeq.contents + 1
+    CommandOutcomeLogStorage_InMemory.append({...entry, seq: nextSeq.contents})
+  }
+}
+
+/** A page of the outcomes matching the filter, newest first; `after` is a page's `endCursor`. */
+let read = (~filter: CommandOutcomeLogEntry.filter, ~first=100, ~after: option<string>=?): page => {
+  let before = after->Option.flatMap(a => Int.fromString(a))
+  // One more than asked, to know whether there is a next page.
+  let rows = switch sqlite() {
+  | Some(db) => CommandOutcomeLogStorage_Sqlite.read(db, ~filter, ~before, ~first=first + 1)
+  | None => CommandOutcomeLogStorage_InMemory.read(~filter, ~before, ~first=first + 1)
+  }
+  let shown = rows->Array.slice(~start=0, ~end=first)
+  let hasNextPage = rows->Array.length > first
+  {
+    records: shown->Array.map(e => {LocalViewChangeLog.item: e.item, cursor: e.seq->Int.toString}),
+    hasNextPage,
+    endCursor: ?(hasNextPage ? shown->Array.at(-1)->Option.map(e => e.seq->Int.toString) : None),
+  }
+}
+
+let removal: ref<option<unit => unit>> = ref(None)
+
+/** Starts keeping every outcome, once per process. One that cannot be kept is logged and passed
+    over: the command is already decided. */
+let install = () =>
+  if removal.contents->Option.isNone {
+    let log = ReventlessCore.Logger.fromEnv()
+    removal :=
+      Some(
+        Outcome.registerCommandOutcome(r =>
+          try record(r) catch {
+          | exn =>
+            log.warn(
+              ~comp="CommandOutcomeLog",
+              `the outcome of ${r.reference} was not kept: ${exn
+                ->JsExn.fromException
+                ->Option.flatMap(JsExn.message)
+                ->Option.getOr("unknown")}`,
+            )
+          }
+        ),
+      )
+  }
+
+/** Test seam: stops keeping them and forgets the in-memory ones. */
+let resetForTests = () => {
+  removal.contents->Option.forEach(remove => remove())
+  removal := None
+  CommandOutcomeLogStorage_InMemory.clear()
+  nextSeq := 0
+  sqliteReady := None
+}

package/src/adapter/CommandOutcomeLog/LocalCommandOutcomeLog.res.mjs

@@ -0,0 +1,112 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as LocalTapLines$ReventlessLocal from "../LocalTapLines.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as CommandOutcomeLogStorage_Sqlite$ReventlessLocal from "./CommandOutcomeLogStorage_Sqlite.res.mjs";
+import * as CommandOutcomeLogStorage_InMemory$ReventlessLocal from "./CommandOutcomeLogStorage_InMemory.res.mjs";
+
+let sqliteReady = {
+  contents: undefined
+};
+
+function sqlite() {
+  let db = BackendState$ReventlessLocal.getSqliteDb();
+  if (db === undefined) {
+    return;
+  }
+  let db$1 = Primitive_option.valFromOption(db);
+  if (sqliteReady.contents !== Primitive_option.some(db$1)) {
+    CommandOutcomeLogStorage_Sqlite$ReventlessLocal.ensureSchema(db$1);
+    sqliteReady.contents = Primitive_option.some(db$1);
+  }
+  return Primitive_option.some(db$1);
+}
+
+let nextSeq = {
+  contents: 0
+};
+
+function record(r) {
+  let entry_flow = r.correlationId;
+  let entry_msgId = r.reference;
+  let entry_item = JSON.parse(LocalTapLines$ReventlessLocal.outcomeLine(r));
+  let entry = {
+    seq: 0,
+    flow: entry_flow,
+    msgId: entry_msgId,
+    item: entry_item
+  };
+  let db = sqlite();
+  if (db !== undefined) {
+    return CommandOutcomeLogStorage_Sqlite$ReventlessLocal.append(Primitive_option.valFromOption(db), entry);
+  }
+  nextSeq.contents = nextSeq.contents + 1 | 0;
+  let newrecord = {...entry};
+  CommandOutcomeLogStorage_InMemory$ReventlessLocal.append((newrecord.seq = nextSeq.contents, newrecord));
+}
+
+function read(filter, firstOpt, after) {
+  let first = firstOpt !== undefined ? firstOpt : 100;
+  let before = Stdlib_Option.flatMap(after, a => Stdlib_Int.fromString(a, undefined));
+  let db = sqlite();
+  let rows = db !== undefined ? CommandOutcomeLogStorage_Sqlite$ReventlessLocal.read(Primitive_option.valFromOption(db), filter, before, first + 1 | 0) : CommandOutcomeLogStorage_InMemory$ReventlessLocal.read(filter, before, first + 1 | 0);
+  let shown = rows.slice(0, first);
+  let hasNextPage = rows.length > first;
+  return {
+    records: shown.map(e => ({
+      item: e.item,
+      cursor: e.seq.toString()
+    })),
+    hasNextPage: hasNextPage,
+    endCursor: hasNextPage ? Stdlib_Option.map(shown.at(-1), e => e.seq.toString()) : undefined
+  };
+}
+
+let removal = {
+  contents: undefined
+};
+
+function install() {
+  if (!Stdlib_Option.isNone(removal.contents)) {
+    return;
+  }
+  let log = Logger$ReventlessCore.fromEnv();
+  removal.contents = CommandTopic_Helpers$ReventlessCore.registerCommandOutcome(r => {
+    try {
+      return record(r);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return log.warn("CommandOutcomeLog", undefined, `the outcome of ` + r.reference + ` was not kept: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown"));
+    }
+  });
+}
+
+function resetForTests() {
+  Stdlib_Option.forEach(removal.contents, remove => remove());
+  removal.contents = undefined;
+  CommandOutcomeLogStorage_InMemory$ReventlessLocal.clear();
+  nextSeq.contents = 0;
+  sqliteReady.contents = undefined;
+}
+
+let Outcome;
+
+export {
+  Outcome,
+  sqliteReady,
+  sqlite,
+  nextSeq,
+  record,
+  read,
+  removal,
+  install,
+  resetForTests,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/adapter/DomainGraphQL_Server.res

@@ -739,12 +739,13 @@ let start = (~port: int=4000, ~contextFactory as _: option<YG.contextFactory>=?,
     warn: a => log.warn(~comp="GraphQL:Domain", YG.logArgToString(a)),
     error: a => log.error(~comp="GraphQL:Domain", YG.logArgToString(a)),
   }
-  let yoga = YG.createYogaWithContext({
+  let yoga = YG.createYogaWithPlugins({
     "schema": schema,
     "graphiql": true,
     "logging": yogaLogging,
     "maskedErrors": !debug,
     "context": buildAuthContext,
+    "plugins": [LocalRequestLog.plugin()],
   })
   // Custom HTTP handler: serves /sdl + /__inmemory/{login,logout}, else yoga.
   let getSdl = () =>

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -18,6 +18,7 @@ import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/
 import * as Api_Ids$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Ids.res.mjs";
 import * as LocalAuth$ReventlessLocal from "./Auth/LocalAuth.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as LocalRequestLog$ReventlessLocal from "./LocalRequestLog.res.mjs";
 import * as LocalObjectStore$ReventlessLocal from "./ObjectStore/LocalObjectStore.res.mjs";
 import * as LocalEvents_Server$ReventlessLocal from "./Api/LocalEvents_Server.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
@@ -610,7 +611,8 @@ function start(portOpt, param, param$1) {
     graphiql: true,
     logging: yogaLogging,
     maskedErrors: !debug,
-    context: Auth_GraphqlContext$ReventlessLocal.buildAuthContext
+    context: Auth_GraphqlContext$ReventlessLocal.buildAuthContext,
+    plugins: [LocalRequestLog$ReventlessLocal.plugin()]
   });
   let getSdl = () => {
     let s = activeSchema.contents;

package/src/adapter/LocalFeed.res

@@ -335,8 +335,22 @@ let newListener = (sink: sink, phase: phase): listener => {
 let accept = (feed: t, socket: NodeNet.socket) => {
   let l = newListener(socketSink(socket), Waiting)
   socket->NodeNet.setEncoding("utf8")
-  socket->NodeNet.onSocketError(_ => drop(feed, l))
-  socket->NodeNet.onSocketClose(() => drop(feed, l))
+  // A connection is someone watching the platform, until its socket closes.
+  LocalIdleExit.connected()
+  let gone = ref(false)
+  let leave = () =>
+    if !gone.contents {
+      gone := true
+      LocalIdleExit.disconnected()
+    }
+  socket->NodeNet.onSocketError(_ => {
+    drop(feed, l)
+    leave()
+  })
+  socket->NodeNet.onSocketClose(() => {
+    drop(feed, l)
+    leave()
+  })
   socket->NodeNet.onSocketData(chunk =>
     if !isLive(l) {
       l.inbound = l.inbound ++ chunk

package/src/adapter/LocalFeed.res.mjs

@@ -9,6 +9,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as LocalIdleExit$ReventlessLocal from "./LocalIdleExit.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -290,8 +291,24 @@ function newListener(sink, phase) {
 function accept(feed, socket) {
   let l = newListener(socketSink(socket), "Waiting");
   socket.setEncoding("utf8");
-  socket.on("error", param => drop(feed, l));
-  socket.on("close", () => drop(feed, l));
+  LocalIdleExit$ReventlessLocal.connected();
+  let gone = {
+    contents: false
+  };
+  let leave = () => {
+    if (!gone.contents) {
+      gone.contents = true;
+      return LocalIdleExit$ReventlessLocal.disconnected();
+    }
+  };
+  socket.on("error", param => {
+    drop(feed, l);
+    leave();
+  });
+  socket.on("close", () => {
+    drop(feed, l);
+    leave();
+  });
   socket.on("data", chunk => {
     if (isLive(l)) {
       return;

package/src/adapter/LocalIdleExit.res

@@ -0,0 +1,71 @@
+// A platform started for an editor, and left running across the editor's reload, stops on its
+// own once nothing has watched it for a while: `REVENTLESS_IDLE_EXIT=<seconds>` turns it on.
+// Watching is a connection to the log feed or the event tap, which an editor holds while it is
+// open; a reload reconnects within seconds, quitting the editor never does. The platform then
+// stops the way a SIGTERM stops it, its registry entry removed on the way out.
+
+let log = ReventlessCore.Logger.fromEnv()
+
+let envVar = "REVENTLESS_IDLE_EXIT"
+
+/** The idle time allowed, in milliseconds; none when the variable is unset, empty or not a
+    positive number. */
+let graceOf = (value: option<string>): option<int> =>
+  value
+  ->Option.flatMap(v => Int.fromString(v->String.trim))
+  ->Option.flatMap(s => s > 0 ? Some(s * 1000) : None)
+
+let grace: ref<option<int>> = ref(None)
+let watchers = ref(0)
+let timer: ref<option<timeoutId>> = ref(None)
+
+/** What happens when the time runs out; replaced by tests. */
+let onIdle: ref<unit => unit> = ref(() => NodeProcess.killWithSignal(NodeProcess.pid, "SIGTERM"))
+
+let disarm = () => {
+  timer.contents->Option.forEach(clearTimeout)
+  timer := None
+}
+
+let arm = () =>
+  grace.contents->Option.forEach(ms => {
+    disarm()
+    timer := Some(setTimeout(() => {
+          timer := None
+          log.info(
+            ~comp="Platform",
+            `nothing watched this platform for ${(ms / 1000)->Int.toString} s — stopping`,
+          )
+          onIdle.contents()
+        }, ms))
+  })
+
+/** Starts counting idle time, when the environment asks for it: from now until the first
+    watcher connects. */
+let start = (~env: dict<string>) => {
+  grace := graceOf(env->Dict.get(envVar))
+  if watchers.contents == 0 {
+    arm()
+  }
+}
+
+/** A watcher connected: the platform is watched again. */
+let connected = () => {
+  watchers := watchers.contents + 1
+  disarm()
+}
+
+/** A watcher went away; the last one leaving starts the idle time. */
+let disconnected = () => {
+  watchers := Math.Int.max(0, watchers.contents - 1)
+  if watchers.contents == 0 {
+    arm()
+  }
+}
+
+/** Back to nothing counted: for tests. */
+let reset = () => {
+  disarm()
+  grace := None
+  watchers := 0
+}

package/src/adapter/LocalIdleExit.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let envVar = "REVENTLESS_IDLE_EXIT";
+
+function graceOf(value) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(value, v => Stdlib_Int.fromString(v.trim(), undefined)), s => {
+    if (s > 0) {
+      return s * 1000 | 0;
+    }
+  });
+}
+
+let grace = {
+  contents: undefined
+};
+
+let watchers = {
+  contents: 0
+};
+
+let timer = {
+  contents: undefined
+};
+
+let onIdle = {
+  contents: () => {
+    process.kill(process.pid, "SIGTERM");
+  }
+};
+
+function disarm() {
+  Stdlib_Option.forEach(timer.contents, prim => {
+    clearTimeout(prim);
+  });
+  timer.contents = undefined;
+}
+
+function arm() {
+  Stdlib_Option.forEach(grace.contents, ms => {
+    disarm();
+    timer.contents = Primitive_option.some(setTimeout(() => {
+      timer.contents = undefined;
+      log.info("Platform", undefined, `nothing watched this platform for ` + (ms / 1000 | 0).toString() + ` s — stopping`);
+      onIdle.contents();
+    }, ms));
+  });
+}
+
+function start(env) {
+  grace.contents = graceOf(env[envVar]);
+  if (watchers.contents === 0) {
+    return arm();
+  }
+}
+
+function connected() {
+  watchers.contents = watchers.contents + 1 | 0;
+  disarm();
+}
+
+function disconnected() {
+  watchers.contents = Math.max(0, watchers.contents - 1 | 0);
+  if (watchers.contents === 0) {
+    return arm();
+  }
+}
+
+function reset() {
+  disarm();
+  grace.contents = undefined;
+  watchers.contents = 0;
+}
+
+export {
+  log,
+  envVar,
+  graceOf,
+  grace,
+  watchers,
+  timer,
+  onIdle,
+  disarm,
+  arm,
+  start,
+  connected,
+  disconnected,
+  reset,
+}
+/* log Not a pure module */

package/src/adapter/LocalMetrics.res

@@ -0,0 +1,29 @@
+// The local platform's metrics: counted in memory rather than written to the
+// output, where nothing collects them locally, and served on the platform API
+// (`Platform_Metrics`) and the MCP server (`platform/metrics`).
+
+module Metrics = ReventlessCore.Metrics
+
+let counts = Metrics.Counts.make()
+
+/** Counts every metric from now on; installed when the platform module loads. */
+let install = () => Metrics.Sink.install(Metrics.Counts.sink(counts))
+
+let snapshotJson = (s: Metrics.Counts.snapshot): JSON.t =>
+  Dict.fromArray([
+    ("metric", JSON.Encode.string(s.metric)),
+    ("plugin", JSON.Encode.string(s.plugin)),
+    ("slice", JSON.Encode.string(s.slice)),
+    ("unit", JSON.Encode.string(s.unit)),
+    ("count", JSON.Encode.int(s.count)),
+    ("sum", JSON.Encode.float(s.sum)),
+    ("lastAt", JSON.Encode.string(s.lastAt->Date.fromTime->Date.toISOString)),
+    ("perMinute", s.perMinute->Array.map(JSON.Encode.int)->JSON.Encode.array),
+  ])->JSON.Encode.object
+
+/** The counts now, of the given plugins or of every one. */
+let read = (~plugins: option<array<string>>=?): JSON.t =>
+  counts
+  ->Metrics.Counts.read(~now=Date.now(), ~plugins?)
+  ->Array.map(snapshotJson)
+  ->JSON.Encode.array

package/src/adapter/LocalMetrics.res.mjs

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Metrics$ReventlessCore from "@reventlessdev/reventless-core/src/util/Metrics.res.mjs";
+
+let counts = Metrics$ReventlessCore.Counts.make();
+
+function install() {
+  Metrics$ReventlessCore.Sink.install(Metrics$ReventlessCore.Counts.sink(counts));
+}
+
+function snapshotJson(s) {
+  return Object.fromEntries([
+    [
+      "metric",
+      s.metric
+    ],
+    [
+      "plugin",
+      s.plugin
+    ],
+    [
+      "slice",
+      s.slice
+    ],
+    [
+      "unit",
+      s.unit
+    ],
+    [
+      "count",
+      s.count
+    ],
+    [
+      "sum",
+      s.sum
+    ],
+    [
+      "lastAt",
+      new Date(s.lastAt).toISOString()
+    ],
+    [
+      "perMinute",
+      s.perMinute.map(prim => prim)
+    ]
+  ]);
+}
+
+function read(plugins) {
+  return Metrics$ReventlessCore.Counts.read(counts, Date.now(), plugins).map(snapshotJson);
+}
+
+let Metrics;
+
+export {
+  Metrics,
+  counts,
+  install,
+  snapshotJson,
+  read,
+}
+/* counts Not a pure module */