@milaboratories/pl-drivers 1.2.16 → 1.2.18

package/dist/index.mjs

@@ -0,0 +1,4627 @@
+var ze = Object.defineProperty;
+var xe = (s, e, t) => e in s ? ze(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var d = (s, e, t) => xe(s, typeof e != "symbol" ? e + "" : e, t);
+import * as w from "node:fs/promises";
+import { addRTypeToMetadata as T, valErr as Me, getField as He, isNullResourceId as je, bigintToResourceId as Q, stringifyWithResourceId as B, isNotNullResourceId as Ge } from "@milaboratories/pl-client";
+import { ServiceType as v, stackIntercept as y } from "@protobuf-ts/runtime-rpc";
+import { MessageType as g, reflectionMergePartial as f, UnknownFieldHandler as u, WireType as h, PbLong as I, typeofJsonValue as ge } from "@protobuf-ts/runtime";
+import { request as fe } from "undici";
+import { notEmpty as O, mapGet as oe, mapEntries as Ve, TaskProcessor as X, CallersCounter as D, asyncPool as Y, assertNever as qe } from "@milaboratories/ts-helpers";
+import { Readable as K, Writable as ee, Transform as Ze } from "node:stream";
+import * as E from "node:fs";
+import * as m from "node:path";
+import { Computable as b, ChangeSource as S, PollingComputableHooks as me } from "@milaboratories/computable";
+import { scheduler as te } from "node:timers/promises";
+import * as Je from "node:readline/promises";
+import Qe from "denque";
+import * as se from "node:os";
+import { randomUUID as k, createHash as Xe } from "node:crypto";
+import { buffer as we } from "node:stream/consumers";
+import { rsSchema as ye, treeEntryToResourceInfo as N, isPlTreeEntry as be, makeResourceSnapshot as Te } from "@milaboratories/pl-tree";
+import { z as L } from "zod";
+import * as Ye from "node:zlib";
+import * as Ke from "tar-fs";
+class et extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new et();
+class tt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.Init", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new tt();
+class rt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.Init.Request", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const nt = new rt();
+class ot extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.Init.Response", [
+      {
+        no: 1,
+        name: "parts_count",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "uploaded_parts",
+        kind: "scalar",
+        repeat: 1,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.partsCount = 0n, t.uploadedParts = [], e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 parts_count */
+        1:
+          o.partsCount = e.uint64().toBigInt();
+          break;
+        case /* repeated uint64 uploaded_parts */
+        2:
+          if (l === h.LengthDelimited)
+            for (let P = e.int32() + e.pos; e.pos < P; )
+              o.uploadedParts.push(e.uint64().toBigInt());
+          else o.uploadedParts.push(e.uint64().toBigInt());
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    if (e.partsCount !== 0n && t.tag(1, h.Varint).uint64(e.partsCount), e.uploadedParts.length) {
+      t.tag(2, h.LengthDelimited).fork();
+      for (let o = 0; o < e.uploadedParts.length; o++)
+        t.uint64(e.uploadedParts[o]);
+      t.join();
+    }
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const st = new ot();
+class it extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.UpdateProgress", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new it();
+class at extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.UpdateProgress.Request", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "bytes_processed",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.bytesProcessed = 0n, e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* int64 bytes_processed */
+        2:
+          o.bytesProcessed = e.int64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.bytesProcessed !== 0n && t.tag(2, h.Varint).int64(e.bytesProcessed);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const lt = new at();
+class ct extends g {
+  constructor() {
+    super(
+      "MiLaboratories.Controller.Shared.uploadapi.UpdateProgress.Response",
+      []
+    );
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const dt = new ct();
+class ht extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.GetPartURL", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new ht();
+class ut extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.GetPartURL.Request", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "part_number",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "uploaded_part_size",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.partNumber = 0n, t.uploadedPartSize = 0n, e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* uint64 part_number */
+        2:
+          o.partNumber = e.uint64().toBigInt();
+          break;
+        case /* uint64 uploaded_part_size */
+        3:
+          o.uploadedPartSize = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.partNumber !== 0n && t.tag(2, h.Varint).uint64(e.partNumber), e.uploadedPartSize !== 0n && t.tag(3, h.Varint).uint64(e.uploadedPartSize);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const pt = new ut();
+class gt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.GetPartURL.HTTPHeader", [
+      {
+        no: 1,
+        name: "Name",
+        kind: "scalar",
+        jsonName: "Name",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "Value",
+        kind: "scalar",
+        jsonName: "Value",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.name = "", t.value = "", e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* string Name = 1 [json_name = "Name"];*/
+        1:
+          o.name = e.string();
+          break;
+        case /* string Value = 2 [json_name = "Value"];*/
+        2:
+          o.value = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.name !== "" && t.tag(1, h.LengthDelimited).string(e.name), e.value !== "" && t.tag(2, h.LengthDelimited).string(e.value);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const F = new gt();
+class ft extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.GetPartURL.Response", [
+      {
+        no: 1,
+        name: "upload_url",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "method",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "headers",
+        kind: "message",
+        repeat: 1,
+        T: () => F
+      },
+      {
+        no: 4,
+        name: "chunk_start",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "chunk_end",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.uploadUrl = "", t.method = "", t.headers = [], t.chunkStart = 0n, t.chunkEnd = 0n, e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* string upload_url */
+        1:
+          o.uploadUrl = e.string();
+          break;
+        case /* string method */
+        2:
+          o.method = e.string();
+          break;
+        case /* repeated MiLaboratories.Controller.Shared.uploadapi.GetPartURL.HTTPHeader headers */
+        3:
+          o.headers.push(
+            F.internalBinaryRead(
+              e,
+              e.uint32(),
+              n
+            )
+          );
+          break;
+        case /* uint64 chunk_start */
+        4:
+          o.chunkStart = e.uint64().toBigInt();
+          break;
+        case /* uint64 chunk_end */
+        5:
+          o.chunkEnd = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.uploadUrl !== "" && t.tag(1, h.LengthDelimited).string(e.uploadUrl), e.method !== "" && t.tag(2, h.LengthDelimited).string(e.method);
+    for (let o = 0; o < e.headers.length; o++)
+      F.internalBinaryWrite(
+        e.headers[o],
+        t.tag(3, h.LengthDelimited).fork(),
+        n
+      ).join();
+    e.chunkStart !== 0n && t.tag(4, h.Varint).uint64(e.chunkStart), e.chunkEnd !== 0n && t.tag(5, h.Varint).uint64(e.chunkEnd);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const mt = new ft();
+class wt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.Finalize", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new wt();
+class yt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.Finalize.Request", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const bt = new yt();
+class Tt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.uploadapi.Finalize.Response", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const kt = new Tt(), W = new v(
+  "MiLaboratories.Controller.Shared.Upload",
+  [
+    {
+      name: "Init",
+      options: {},
+      I: nt,
+      O: st
+    },
+    {
+      name: "GetPartURL",
+      options: {},
+      I: pt,
+      O: mt
+    },
+    {
+      name: "UpdateProgress",
+      options: {},
+      I: lt,
+      O: dt
+    },
+    {
+      name: "Finalize",
+      options: {},
+      I: bt,
+      O: kt
+    }
+  ]
+);
+class Lt {
+  constructor(e) {
+    d(this, "typeName", W.typeName);
+    d(this, "methods", W.methods);
+    d(this, "options", W.options);
+    this._transport = e;
+  }
+  /**
+   *
+   * Init upload, making controller to do all required preparation steps.
+   *
+   *
+   * @generated from protobuf rpc: Init(MiLaboratories.Controller.Shared.uploadapi.Init.Request) returns (MiLaboratories.Controller.Shared.uploadapi.Init.Response);
+   */
+  init(e, t) {
+    const n = this.methods[0], r = this._transport.mergeOptions(t);
+    return y(
+      "unary",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+  /**
+   *
+   * GetPartURL provides URL for uploading chunk of the data.
+   * Clients are expected to put their data directly to the given location.
+   *
+   *
+   * @generated from protobuf rpc: GetPartURL(MiLaboratories.Controller.Shared.uploadapi.GetPartURL.Request) returns (MiLaboratories.Controller.Shared.uploadapi.GetPartURL.Response);
+   */
+  getPartURL(e, t) {
+    const n = this.methods[1], r = this._transport.mergeOptions(t);
+    return y("unary", this._transport, n, r, e);
+  }
+  /**
+   *
+   * UpdateProgress of the upload, so other clients can see how it is going.
+   *
+   *
+   * @generated from protobuf rpc: UpdateProgress(MiLaboratories.Controller.Shared.uploadapi.UpdateProgress.Request) returns (MiLaboratories.Controller.Shared.uploadapi.UpdateProgress.Response);
+   */
+  updateProgress(e, t) {
+    const n = this.methods[2], r = this._transport.mergeOptions(t);
+    return y("unary", this._transport, n, r, e);
+  }
+  /**
+   *
+   * Finalize informs Controller that the upload process is done.
+   * Returns an error, if the total size of all uploaded chunks is not equal to
+   * size of the upload given in Init.
+   *
+   *
+   * @generated from protobuf rpc: Finalize(MiLaboratories.Controller.Shared.uploadapi.Finalize.Request) returns (MiLaboratories.Controller.Shared.uploadapi.Finalize.Response);
+   */
+  finalize(e, t) {
+    const n = this.methods[3], r = this._transport.mergeOptions(t);
+    return y("unary", this._transport, n, r, e);
+  }
+}
+class ke extends Error {
+}
+class Le extends Error {
+}
+class Pt extends Error {
+}
+class Pe extends Error {
+}
+class It {
+  constructor(e, t, n, r) {
+    d(this, "grpcClient");
+    this.grpcTransport = e, this.httpClient = t, this.logger = r, this.grpcClient = new Lt(this.grpcTransport);
+  }
+  close() {
+  }
+  async initUpload({ id: e, type: t }, n) {
+    const r = await this.grpcClient.init(
+      { resourceId: e },
+      T(t, n)
+    );
+    return this.partsToUpload(r.response);
+  }
+  async partUpload({ id: e, type: t }, n, r, o, c, i) {
+    const l = await this.grpcClient.getPartURL(
+      {
+        resourceId: e,
+        partNumber: r,
+        uploadedPartSize: 0n
+        // we update progress as a separate call later.
+      },
+      T(t, i)
+    ).response, { chunk: a, mTime: p } = await this.readChunk(
+      n,
+      l.chunkStart,
+      l.chunkEnd
+    );
+    if (p > c)
+      throw new ke(
+        "file was modified, expected mtime: " + c + ", got: " + p + "."
+      );
+    const P = await fe(
+      l.uploadUrl,
+      this.prepareUploadOpts(l, a)
+    ), ne = await (await P.body.blob()).text();
+    if (this.logger.info(
+      `uploaded chunk ${r} from ${o} of resource: ${e}, response: '${ne.toString()}', status code: ${P.statusCode}`
+    ), P.statusCode != 200)
+      throw new Pt(
+        `response is not ok, status code: ${P.statusCode}, body: ${ne}, headers: ${P.headers}, url: ${l.uploadUrl}`
+      );
+    await this.grpcClient.updateProgress(
+      {
+        resourceId: e,
+        bytesProcessed: l.chunkEnd - l.chunkStart
+      },
+      T(t, i)
+    );
+  }
+  async finalizeUpload({ id: e, type: t }, n) {
+    return await this.grpcClient.finalize(
+      { resourceId: e },
+      T(t, n)
+    );
+  }
+  async readChunk(e, t, n) {
+    let r;
+    try {
+      r = await w.open(e);
+      const o = Number(n - t), c = Number(t), i = Buffer.alloc(o), l = await this.readBytesFromPosition(r, i, o, c), a = await w.stat(e);
+      return {
+        chunk: i.subarray(0, l),
+        mTime: BigInt(Math.floor(a.mtimeMs / 1e3))
+      };
+    } catch (o) {
+      throw o.code == "ENOENT" ? new Pe(`there is no file ${e} for uploading`) : o;
+    } finally {
+      r == null || r.close();
+    }
+  }
+  /** Read len bytes from a given position. The reason the method exists
+      is that FileHandle.read can read less bytes than it's needed. */
+  async readBytesFromPosition(e, t, n, r) {
+    let o = 0;
+    for (; o < n; ) {
+      const { bytesRead: c } = await e.read(
+        t,
+        o,
+        n - o,
+        r + o
+      );
+      if (c === 0)
+        throw new Le("file ended earlier than expected.");
+      o += c;
+    }
+    return o;
+  }
+  /** Calculates parts that need to be uploaded from the parts that were
+   * already uploaded. */
+  partsToUpload(e) {
+    const t = [], n = new Set(e.uploadedParts);
+    for (let r = 1n; r <= e.partsCount; r++)
+      n.has(r) || t.push(r);
+    return t;
+  }
+  prepareUploadOpts(e, t) {
+    const n = e.headers.map(({ name: r, value: o }) => [r, o]);
+    return {
+      dispatcher: this.httpClient,
+      body: t,
+      headers: Object.fromEntries(n),
+      method: e.method.toUpperCase()
+    };
+  }
+}
+class Nt extends g {
+  constructor() {
+    super("google.protobuf.Duration", [
+      {
+        no: 1,
+        name: "seconds",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "nanos",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  /**
+   * Encode `Duration` to JSON string like "3.000001s".
+   */
+  internalJsonWrite(e, t) {
+    let n = I.from(e.seconds).toNumber();
+    if (n > 315576e6 || n < -315576e6)
+      throw new Error("Duration value out of range.");
+    let r = e.seconds.toString();
+    if (n === 0 && e.nanos < 0 && (r = "-" + r), e.nanos !== 0) {
+      let o = Math.abs(e.nanos).toString();
+      o = "0".repeat(9 - o.length) + o, o.substring(3) === "000000" ? o = o.substring(0, 3) : o.substring(6) === "000" && (o = o.substring(0, 6)), r += "." + o;
+    }
+    return r + "s";
+  }
+  /**
+   * Decode `Duration` from JSON string like "3.000001s"
+   */
+  internalJsonRead(e, t, n) {
+    if (typeof e != "string")
+      throw new Error(
+        "Unable to parse Duration from JSON " + ge(e) + ". Expected string."
+      );
+    let r = e.match(/^(-?)([0-9]+)(?:\.([0-9]+))?s/);
+    if (r === null)
+      throw new Error(
+        "Unable to parse Duration from JSON string. Invalid format."
+      );
+    n || (n = this.create());
+    let [, o, c, i] = r, l = I.from(o + c);
+    if (l.toNumber() > 315576e6 || l.toNumber() < -315576e6)
+      throw new Error(
+        "Unable to parse Duration from JSON string. Value out of range."
+      );
+    if (n.seconds = l.toBigInt(), typeof i == "string") {
+      let a = o + i + "0".repeat(9 - i.length);
+      n.nanos = parseInt(a);
+    }
+    return n;
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.seconds = 0n, t.nanos = 0, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* int64 seconds */
+        1:
+          o.seconds = e.int64().toBigInt();
+          break;
+        case /* int32 nanos */
+        2:
+          o.nanos = e.int32();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.seconds !== 0n && t.tag(1, h.Varint).int64(e.seconds), e.nanos !== 0 && t.tag(2, h.Varint).int32(e.nanos);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const _ = new Nt();
+class Rt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.ProgressAPI", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new Rt();
+class St extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.ProgressAPI.Report", [
+      {
+        no: 1,
+        name: "progress",
+        kind: "scalar",
+        T: 2
+        /*ScalarType.FLOAT*/
+      },
+      {
+        no: 2,
+        name: "bytes_processed",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "bytes_total",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 4,
+        name: "done",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 5,
+        name: "name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.progress = 0, t.bytesProcessed = 0n, t.bytesTotal = 0n, t.done = !1, t.name = "", e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* float progress */
+        1:
+          o.progress = e.float();
+          break;
+        case /* uint64 bytes_processed */
+        2:
+          o.bytesProcessed = e.uint64().toBigInt();
+          break;
+        case /* uint64 bytes_total */
+        3:
+          o.bytesTotal = e.uint64().toBigInt();
+          break;
+        case /* bool done */
+        4:
+          o.done = e.bool();
+          break;
+        case /* string name */
+        5:
+          o.name = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.progress !== 0 && t.tag(1, h.Bit32).float(e.progress), e.bytesProcessed !== 0n && t.tag(2, h.Varint).uint64(e.bytesProcessed), e.bytesTotal !== 0n && t.tag(3, h.Varint).uint64(e.bytesTotal), e.done !== !1 && t.tag(4, h.Varint).bool(e.done), e.name !== "" && t.tag(5, h.LengthDelimited).string(e.name);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const R = new St();
+class Ut extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.ProgressAPI.GetStatus", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new Ut();
+class Bt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.ProgressAPI.GetStatus.Request", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const vt = new Bt();
+class Dt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.ProgressAPI.GetStatus.Response", [
+      { no: 1, name: "report", kind: "message", T: () => R }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* MiLaboratories.Controller.Shared.ProgressAPI.Report report */
+        1:
+          o.report = R.internalBinaryRead(
+            e,
+            e.uint32(),
+            n,
+            o.report
+          );
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.report && R.internalBinaryWrite(
+      e.report,
+      t.tag(1, h.LengthDelimited).fork(),
+      n
+    ).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const _t = new Dt();
+class $t extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.ProgressAPI.RealtimeStatus", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new $t();
+class Ct extends g {
+  constructor() {
+    super(
+      "MiLaboratories.Controller.Shared.ProgressAPI.RealtimeStatus.Request",
+      [
+        {
+          no: 1,
+          name: "resource_id",
+          kind: "scalar",
+          T: 4,
+          L: 0
+          /*LongType.BIGINT*/
+        },
+        { no: 2, name: "update_interval", kind: "message", T: () => _ }
+      ]
+    );
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* google.protobuf.Duration update_interval */
+        2:
+          o.updateInterval = _.internalBinaryRead(
+            e,
+            e.uint32(),
+            n,
+            o.updateInterval
+          );
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.updateInterval && _.internalBinaryWrite(
+      e.updateInterval,
+      t.tag(2, h.LengthDelimited).fork(),
+      n
+    ).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const Ot = new Ct();
+class Et extends g {
+  constructor() {
+    super(
+      "MiLaboratories.Controller.Shared.ProgressAPI.RealtimeStatus.Response",
+      [{ no: 1, name: "report", kind: "message", T: () => R }]
+    );
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* MiLaboratories.Controller.Shared.ProgressAPI.Report report */
+        1:
+          o.report = R.internalBinaryRead(
+            e,
+            e.uint32(),
+            n,
+            o.report
+          );
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.report && R.internalBinaryWrite(
+      e.report,
+      t.tag(1, h.LengthDelimited).fork(),
+      n
+    ).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const Ft = new Et(), A = new v(
+  "MiLaboratories.Controller.Shared.Progress",
+  [
+    {
+      name: "GetStatus",
+      options: {
+        "google.api.http": { get: "/resources/{resource_id}/get-progress" }
+      },
+      I: vt,
+      O: _t
+    },
+    {
+      name: "RealtimeStatus",
+      serverStreaming: !0,
+      options: {},
+      I: Ot,
+      O: Ft
+    }
+  ]
+);
+class Wt {
+  constructor(e) {
+    d(this, "typeName", A.typeName);
+    d(this, "methods", A.methods);
+    d(this, "options", A.options);
+    this._transport = e;
+  }
+  /**
+   * @generated from protobuf rpc: GetStatus(MiLaboratories.Controller.Shared.ProgressAPI.GetStatus.Request) returns (MiLaboratories.Controller.Shared.ProgressAPI.GetStatus.Response);
+   */
+  getStatus(e, t) {
+    const n = this.methods[0], r = this._transport.mergeOptions(t);
+    return y("unary", this._transport, n, r, e);
+  }
+  /**
+   * @generated from protobuf rpc: RealtimeStatus(MiLaboratories.Controller.Shared.ProgressAPI.RealtimeStatus.Request) returns (stream MiLaboratories.Controller.Shared.ProgressAPI.RealtimeStatus.Response);
+   */
+  realtimeStatus(e, t) {
+    const n = this.methods[1], r = this._transport.mergeOptions(t);
+    return y("serverStreaming", this._transport, n, r, e);
+  }
+}
+class At {
+  constructor(e, t, n, r) {
+    d(this, "grpcClient");
+    this.grpcTransport = e, this.client = n, this.logger = r, this.grpcClient = new Wt(this.grpcTransport);
+  }
+  close() {
+  }
+  /** getStatus gets a progress status by given rId and rType. */
+  async getStatus({ id: e, type: t }, n) {
+    const r = await this.grpcClient.getStatus(
+      { resourceId: e },
+      T(t, n)
+    ), o = O(r.response.report);
+    return {
+      done: o.done,
+      progress: o.progress,
+      bytesProcessed: String(o.bytesProcessed),
+      bytesTotal: String(o.bytesTotal)
+    };
+  }
+  // realtimeStatus returns a async generator that takes statuses from
+  // GRPC stream every updateIntervalMs milliseconds.
+  async *realtimeStatus({ id: e, type: t }, n = 100, r) {
+    r = T(t, r);
+    const o = Math.floor(n / 1e3), c = (n - o * 1e3) * 1e6, i = _.create({
+      seconds: BigInt(o),
+      nanos: c
+    });
+    try {
+      const { responses: l } = this.grpcClient.realtimeStatus(
+        {
+          resourceId: e,
+          updateInterval: i
+        },
+        r
+      );
+      yield* l;
+    } catch (l) {
+      throw this.logger.warn("Failed to get realtime status" + l), l;
+    }
+  }
+}
+class zt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.DownloadAPI", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new zt();
+class xt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new xt();
+class Mt extends g {
+  constructor() {
+    super(
+      "MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Request",
+      [
+        {
+          no: 1,
+          name: "resource_id",
+          kind: "scalar",
+          T: 4,
+          L: 0
+          /*LongType.BIGINT*/
+        }
+      ]
+    );
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const Ht = new Mt();
+class jt extends g {
+  constructor() {
+    super(
+      "MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.HTTPHeader",
+      [
+        {
+          no: 1,
+          name: "Name",
+          kind: "scalar",
+          jsonName: "Name",
+          T: 9
+          /*ScalarType.STRING*/
+        },
+        {
+          no: 2,
+          name: "Value",
+          kind: "scalar",
+          jsonName: "Value",
+          T: 9
+          /*ScalarType.STRING*/
+        }
+      ]
+    );
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.name = "", t.value = "", e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* string Name = 1 [json_name = "Name"];*/
+        1:
+          o.name = e.string();
+          break;
+        case /* string Value = 2 [json_name = "Value"];*/
+        2:
+          o.value = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.name !== "" && t.tag(1, h.LengthDelimited).string(e.name), e.value !== "" && t.tag(2, h.LengthDelimited).string(e.value);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const z = new jt();
+class Gt extends g {
+  constructor() {
+    super(
+      "MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Response",
+      [
+        {
+          no: 1,
+          name: "download_url",
+          kind: "scalar",
+          T: 9
+          /*ScalarType.STRING*/
+        },
+        {
+          no: 2,
+          name: "headers",
+          kind: "message",
+          repeat: 1,
+          T: () => z
+        }
+      ]
+    );
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.downloadUrl = "", t.headers = [], e !== void 0 && f(
+      this,
+      t,
+      e
+    ), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* string download_url */
+        1:
+          o.downloadUrl = e.string();
+          break;
+        case /* repeated MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.HTTPHeader headers */
+        2:
+          o.headers.push(
+            z.internalBinaryRead(
+              e,
+              e.uint32(),
+              n
+            )
+          );
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.downloadUrl !== "" && t.tag(1, h.LengthDelimited).string(e.downloadUrl);
+    for (let o = 0; o < e.headers.length; o++)
+      z.internalBinaryWrite(
+        e.headers[o],
+        t.tag(2, h.LengthDelimited).fork(),
+        n
+      ).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const Vt = new Gt(), x = new v(
+  "MiLaboratories.Controller.Shared.Download",
+  [
+    {
+      name: "GetDownloadURL",
+      options: {
+        "google.api.http": { get: "/resources/{resource_id}/get-download-url" }
+      },
+      I: Ht,
+      O: Vt
+    }
+  ]
+);
+class qt {
+  constructor(e) {
+    d(this, "typeName", x.typeName);
+    d(this, "methods", x.methods);
+    d(this, "options", x.options);
+    this._transport = e;
+  }
+  /**
+   * @generated from protobuf rpc: GetDownloadURL(MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Request) returns (MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Response);
+   */
+  getDownloadURL(e, t) {
+    const n = this.methods[0], r = this._transport.mergeOptions(t);
+    return y("unary", this._transport, n, r, e);
+  }
+}
+class re extends Error {
+}
+class Ie {
+  constructor(e) {
+    this.httpClient = e;
+  }
+  async downloadRemoteFile(e, t, n) {
+    const { statusCode: r, body: o, headers: c } = await fe(e, {
+      dispatcher: this.httpClient,
+      headers: t,
+      signal: n
+    });
+    if (400 <= r && r < 500)
+      throw new re(
+        `Http error: statusCode: ${r} url: ${e.toString()}`
+      );
+    if (r != 200)
+      throw Error(
+        `Http error: statusCode: ${r} url: ${e.toString()}`
+      );
+    return {
+      content: K.toWeb(o),
+      size: Number(c["content-length"])
+    };
+  }
+}
+const Zt = "storage://", ie = /storage:\/\/(?<storageId>.*?)\/(?<localPath>.*)/;
+class Ne extends Error {
+}
+class Re extends Error {
+}
+class Jt {
+  constructor(e, t, n, r) {
+    d(this, "grpcClient");
+    d(this, "downloadHelper");
+    d(this, "isLocal", (e) => e.startsWith(Zt));
+    this.grpcTransport = e, this.httpClient = t, this.logger = n, this.localStorageIdsToRoot = r, this.grpcClient = new qt(this.grpcTransport), this.downloadHelper = new Ie(t);
+  }
+  close() {
+  }
+  async getUrl({ id: e, type: t }, n, r) {
+    const o = n ?? {};
+    return o.abort = r, await this.grpcClient.getDownloadURL(
+      { resourceId: e },
+      T(t, o)
+    ).response;
+  }
+  async downloadBlob(e, t, n) {
+    const { downloadUrl: r, headers: o } = await this.getUrl(e, t, n);
+    return this.logger.info(`download from url ${r}`), this.isLocal(r) ? await this.readLocalFile(r) : await this.downloadHelper.downloadRemoteFile(
+      r,
+      Qt(o),
+      n
+    );
+  }
+  async readLocalFile(e) {
+    const t = e.match(ie);
+    if (t === null || t.length != 3)
+      throw new Re(
+        `url for local filepath ${e} does not match regex ${ie}, parsed: ${t}`
+      );
+    const [n, r, o] = t;
+    if (this.localStorageIdsToRoot[r] == null)
+      throw new Ne(`Unknown storage location: ${r}`);
+    const c = this.localStorageIdsToRoot[r], i = m.join(c, o), a = (await w.stat(i)).size;
+    return {
+      content: K.toWeb(E.createReadStream(i)),
+      size: a
+    };
+  }
+}
+function Qt(s) {
+  return Object.fromEntries(s.map(({ name: e, value: t }) => [e, t]));
+}
+class Xt extends g {
+  constructor() {
+    super("google.protobuf.Timestamp", [
+      {
+        no: 1,
+        name: "seconds",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "nanos",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  /**
+   * Creates a new `Timestamp` for the current time.
+   */
+  now() {
+    const e = this.create(), t = Date.now();
+    return e.seconds = I.from(Math.floor(t / 1e3)).toBigInt(), e.nanos = t % 1e3 * 1e6, e;
+  }
+  /**
+   * Converts a `Timestamp` to a JavaScript Date.
+   */
+  toDate(e) {
+    return new Date(
+      I.from(e.seconds).toNumber() * 1e3 + Math.ceil(e.nanos / 1e6)
+    );
+  }
+  /**
+   * Converts a JavaScript Date to a `Timestamp`.
+   */
+  fromDate(e) {
+    const t = this.create(), n = e.getTime();
+    return t.seconds = I.from(Math.floor(n / 1e3)).toBigInt(), t.nanos = n % 1e3 * 1e6, t;
+  }
+  /**
+   * In JSON format, the `Timestamp` type is encoded as a string
+   * in the RFC 3339 format.
+   */
+  internalJsonWrite(e, t) {
+    let n = I.from(e.seconds).toNumber() * 1e3;
+    if (n < Date.parse("0001-01-01T00:00:00Z") || n > Date.parse("9999-12-31T23:59:59Z"))
+      throw new Error(
+        "Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."
+      );
+    if (e.nanos < 0)
+      throw new Error(
+        "Unable to encode invalid Timestamp to JSON. Nanos must not be negative."
+      );
+    let r = "Z";
+    if (e.nanos > 0) {
+      let o = (e.nanos + 1e9).toString().substring(1);
+      o.substring(3) === "000000" ? r = "." + o.substring(0, 3) + "Z" : o.substring(6) === "000" ? r = "." + o.substring(0, 6) + "Z" : r = "." + o + "Z";
+    }
+    return new Date(n).toISOString().replace(".000Z", r);
+  }
+  /**
+   * In JSON format, the `Timestamp` type is encoded as a string
+   * in the RFC 3339 format.
+   */
+  internalJsonRead(e, t, n) {
+    if (typeof e != "string")
+      throw new Error(
+        "Unable to parse Timestamp from JSON " + ge(e) + "."
+      );
+    let r = e.match(
+      /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/
+    );
+    if (!r)
+      throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
+    let o = Date.parse(
+      r[1] + "-" + r[2] + "-" + r[3] + "T" + r[4] + ":" + r[5] + ":" + r[6] + (r[8] ? r[8] : "Z")
+    );
+    if (Number.isNaN(o))
+      throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
+    if (o < Date.parse("0001-01-01T00:00:00Z") || o > Date.parse("9999-12-31T23:59:59Z"))
+      throw new globalThis.Error(
+        "Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."
+      );
+    return n || (n = this.create()), n.seconds = I.from(o / 1e3).toBigInt(), n.nanos = 0, r[7] && (n.nanos = parseInt("1" + r[7] + "0".repeat(9 - r[7].length)) - 1e9), n;
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.seconds = 0n, t.nanos = 0, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* int64 seconds */
+        1:
+          o.seconds = e.int64().toBigInt();
+          break;
+        case /* int32 nanos */
+        2:
+          o.nanos = e.int32();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.seconds !== 0n && t.tag(1, h.Varint).int64(e.seconds), e.nanos !== 0 && t.tag(2, h.Varint).int32(e.nanos);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const M = new Xt();
+class Yt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.LsAPI", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new Yt();
+class Kt extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.LsAPI.ListItem", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "size",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "is_dir",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 10,
+        name: "full_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 11,
+        name: "directory",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 12, name: "last_modified", kind: "message", T: () => M },
+      {
+        no: 13,
+        name: "version",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.name = "", t.size = 0n, t.isDir = !1, t.fullName = "", t.directory = "", t.version = "", e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* string name */
+        1:
+          o.name = e.string();
+          break;
+        case /* uint64 size */
+        2:
+          o.size = e.uint64().toBigInt();
+          break;
+        case /* bool is_dir */
+        3:
+          o.isDir = e.bool();
+          break;
+        case /* string full_name */
+        10:
+          o.fullName = e.string();
+          break;
+        case /* string directory */
+        11:
+          o.directory = e.string();
+          break;
+        case /* google.protobuf.Timestamp last_modified */
+        12:
+          o.lastModified = M.internalBinaryRead(
+            e,
+            e.uint32(),
+            n,
+            o.lastModified
+          );
+          break;
+        case /* string version */
+        13:
+          o.version = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.name !== "" && t.tag(1, h.LengthDelimited).string(e.name), e.size !== 0n && t.tag(2, h.Varint).uint64(e.size), e.isDir !== !1 && t.tag(3, h.Varint).bool(e.isDir), e.fullName !== "" && t.tag(10, h.LengthDelimited).string(e.fullName), e.directory !== "" && t.tag(11, h.LengthDelimited).string(e.directory), e.lastModified && M.internalBinaryWrite(
+      e.lastModified,
+      t.tag(12, h.LengthDelimited).fork(),
+      n
+    ).join(), e.version !== "" && t.tag(13, h.LengthDelimited).string(e.version);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const H = new Kt();
+class er extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.LsAPI.List", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new er();
+class tr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.LsAPI.List.Request", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "location",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.location = "", e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* string location */
+        2:
+          o.location = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.location !== "" && t.tag(2, h.LengthDelimited).string(e.location);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const rr = new tr();
+class nr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.LsAPI.List.Response", [
+      {
+        no: 1,
+        name: "items",
+        kind: "message",
+        repeat: 1,
+        T: () => H
+      },
+      {
+        no: 2,
+        name: "delimiter",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.items = [], t.delimiter = "", e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* repeated MiLaboratories.Controller.Shared.LsAPI.ListItem items */
+        1:
+          o.items.push(
+            H.internalBinaryRead(e, e.uint32(), n)
+          );
+          break;
+        case /* string delimiter */
+        2:
+          o.delimiter = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    for (let o = 0; o < e.items.length; o++)
+      H.internalBinaryWrite(
+        e.items[o],
+        t.tag(1, h.LengthDelimited).fork(),
+        n
+      ).join();
+    e.delimiter !== "" && t.tag(2, h.LengthDelimited).string(e.delimiter);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const or = new nr(), j = new v("MiLaboratories.Controller.Shared.LS", [
+  { name: "List", options: {}, I: rr, O: or }
+]);
+class sr {
+  constructor(e) {
+    d(this, "typeName", j.typeName);
+    d(this, "methods", j.methods);
+    d(this, "options", j.options);
+    this._transport = e;
+  }
+  /**
+   * @generated from protobuf rpc: List(MiLaboratories.Controller.Shared.LsAPI.List.Request) returns (MiLaboratories.Controller.Shared.LsAPI.List.Response);
+   */
+  list(e, t) {
+    const n = this.methods[0], r = this._transport.mergeOptions(t);
+    return y(
+      "unary",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+}
+class ir {
+  constructor(e, t) {
+    d(this, "grpcClient");
+    this.logger = t, this.grpcClient = new sr(e);
+  }
+  close() {
+  }
+  async list(e, t, n) {
+    return await this.grpcClient.list(
+      {
+        resourceId: e.id,
+        location: t
+      },
+      T(e.type, n)
+    ).response;
+  }
+}
+class ar extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI", []);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    return r ?? this.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+new ar();
+class lr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI.StreamBinary", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "offset",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 11,
+        name: "chunk_size",
+        kind: "scalar",
+        opt: !0,
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 20,
+        name: "read_limit",
+        kind: "scalar",
+        opt: !0,
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.offset = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* int64 offset */
+        2:
+          o.offset = e.int64().toBigInt();
+          break;
+        case /* optional uint32 chunk_size */
+        11:
+          o.chunkSize = e.uint32();
+          break;
+        case /* optional int64 read_limit */
+        20:
+          o.readLimit = e.int64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.offset !== 0n && t.tag(2, h.Varint).int64(e.offset), e.chunkSize !== void 0 && t.tag(11, h.Varint).uint32(e.chunkSize), e.readLimit !== void 0 && t.tag(20, h.Varint).int64(e.readLimit);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const cr = new lr();
+class dr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI.ReadBinary", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "offset",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 11,
+        name: "chunk_size",
+        kind: "scalar",
+        opt: !0,
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.offset = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* int64 offset */
+        2:
+          o.offset = e.int64().toBigInt();
+          break;
+        case /* optional uint32 chunk_size */
+        11:
+          o.chunkSize = e.uint32();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.offset !== 0n && t.tag(2, h.Varint).int64(e.offset), e.chunkSize !== void 0 && t.tag(11, h.Varint).uint32(e.chunkSize);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const hr = new dr();
+class ur extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI.StreamText", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "offset",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 20,
+        name: "read_limit",
+        kind: "scalar",
+        opt: !0,
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 21,
+        name: "search",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 22,
+        name: "search_re",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.offset = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* int64 offset */
+        2:
+          o.offset = e.int64().toBigInt();
+          break;
+        case /* optional int64 read_limit */
+        20:
+          o.readLimit = e.int64().toBigInt();
+          break;
+        case /* optional string search */
+        21:
+          o.search = e.string();
+          break;
+        case /* optional string search_re */
+        22:
+          o.searchRe = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.offset !== 0n && t.tag(2, h.Varint).int64(e.offset), e.readLimit !== void 0 && t.tag(20, h.Varint).int64(e.readLimit), e.search !== void 0 && t.tag(21, h.LengthDelimited).string(e.search), e.searchRe !== void 0 && t.tag(22, h.LengthDelimited).string(e.searchRe);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const pr = new ur();
+class gr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI.ReadText", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "offset",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 20,
+        name: "read_limit",
+        kind: "scalar",
+        opt: !0,
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 21,
+        name: "search",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 22,
+        name: "search_re",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, t.offset = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* int64 offset */
+        2:
+          o.offset = e.int64().toBigInt();
+          break;
+        case /* optional int64 read_limit */
+        20:
+          o.readLimit = e.int64().toBigInt();
+          break;
+        case /* optional string search */
+        21:
+          o.search = e.string();
+          break;
+        case /* optional string search_re */
+        22:
+          o.searchRe = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.offset !== 0n && t.tag(2, h.Varint).int64(e.offset), e.readLimit !== void 0 && t.tag(20, h.Varint).int64(e.readLimit), e.search !== void 0 && t.tag(21, h.LengthDelimited).string(e.search), e.searchRe !== void 0 && t.tag(22, h.LengthDelimited).string(e.searchRe);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const fr = new gr();
+class mr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI.LastLines", [
+      {
+        no: 1,
+        name: "resource_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "offset",
+        kind: "scalar",
+        opt: !0,
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "line_count",
+        kind: "scalar",
+        opt: !0,
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 21,
+        name: "search",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 22,
+        name: "search_re",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.resourceId = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* uint64 resource_id */
+        1:
+          o.resourceId = e.uint64().toBigInt();
+          break;
+        case /* optional int64 offset */
+        2:
+          o.offset = e.int64().toBigInt();
+          break;
+        case /* optional int32 line_count */
+        3:
+          o.lineCount = e.int32();
+          break;
+        case /* optional string search */
+        21:
+          o.search = e.string();
+          break;
+        case /* optional string search_re */
+        22:
+          o.searchRe = e.string();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.resourceId !== 0n && t.tag(1, h.Varint).uint64(e.resourceId), e.offset !== void 0 && t.tag(2, h.Varint).int64(e.offset), e.lineCount !== void 0 && t.tag(3, h.Varint).int32(e.lineCount), e.search !== void 0 && t.tag(21, h.LengthDelimited).string(e.search), e.searchRe !== void 0 && t.tag(22, h.LengthDelimited).string(e.searchRe);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const wr = new mr();
+class yr extends g {
+  constructor() {
+    super("MiLaboratories.Controller.Shared.StreamingAPI.Response", [
+      {
+        no: 1,
+        name: "data",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 2,
+        name: "size",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "new_offset",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.data = new Uint8Array(0), t.size = 0n, t.newOffset = 0n, e !== void 0 && f(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let o = r ?? this.create(), c = e.pos + t;
+    for (; e.pos < c; ) {
+      let [i, l] = e.tag();
+      switch (i) {
+        case /* bytes data */
+        1:
+          o.data = e.bytes();
+          break;
+        case /* uint64 size */
+        2:
+          o.size = e.uint64().toBigInt();
+          break;
+        case /* uint64 new_offset */
+        3:
+          o.newOffset = e.uint64().toBigInt();
+          break;
+        default:
+          let a = n.readUnknownField;
+          if (a === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${i} (wire type ${l}) for ${this.typeName}`
+            );
+          let p = e.skip(l);
+          a !== !1 && (a === !0 ? u.onRead : a)(
+            this.typeName,
+            o,
+            i,
+            l,
+            p
+          );
+      }
+    }
+    return o;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.data.length && t.tag(1, h.LengthDelimited).bytes(e.data), e.size !== 0n && t.tag(2, h.Varint).uint64(e.size), e.newOffset !== 0n && t.tag(3, h.Varint).uint64(e.newOffset);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? u.onWrite : r)(
+      this.typeName,
+      e,
+      t
+    ), t;
+  }
+}
+const U = new yr(), G = new v(
+  "MiLaboratories.Controller.Shared.Streaming",
+  [
+    {
+      name: "StreamBinary",
+      serverStreaming: !0,
+      options: {},
+      I: cr,
+      O: U
+    },
+    {
+      name: "ReadBinary",
+      options: {},
+      I: hr,
+      O: U
+    },
+    {
+      name: "StreamText",
+      serverStreaming: !0,
+      options: {},
+      I: pr,
+      O: U
+    },
+    {
+      name: "ReadText",
+      options: {},
+      I: fr,
+      O: U
+    },
+    {
+      name: "LastLines",
+      options: {},
+      I: wr,
+      O: U
+    }
+  ]
+);
+class br {
+  constructor(e) {
+    d(this, "typeName", G.typeName);
+    d(this, "methods", G.methods);
+    d(this, "options", G.options);
+    this._transport = e;
+  }
+  /**
+   * StreamBinary provides stream of binary file. Each response message keeps
+   * one single chunk of binary data from data source. See StreamingAPI.Binary message
+   * for more info on available options.
+   *
+   * @generated from protobuf rpc: StreamBinary(MiLaboratories.Controller.Shared.StreamingAPI.StreamBinary) returns (stream MiLaboratories.Controller.Shared.StreamingAPI.Response);
+   */
+  streamBinary(e, t) {
+    const n = this.methods[0], r = this._transport.mergeOptions(t);
+    return y(
+      "serverStreaming",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+  /**
+   * ReadBinary allows to read remote item in chunks using stream-like API.
+   * The difference to StreamBinary is that the client receives single response for each
+   * call and has to send new calls to the server to get fresh data from remote item.
+   * Each response (each chunk from server) keeps not more than 3.9MiB of data.
+   *
+   * @generated from protobuf rpc: ReadBinary(MiLaboratories.Controller.Shared.StreamingAPI.ReadBinary) returns (MiLaboratories.Controller.Shared.StreamingAPI.Response);
+   */
+  readBinary(e, t) {
+    const n = this.methods[1], r = this._transport.mergeOptions(t);
+    return y(
+      "unary",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+  /**
+   * StreamText provides stream of textual file, splitting the data by newline symbol.
+   * Each response message keeps one single line of text from data source.
+   *
+   * @generated from protobuf rpc: StreamText(MiLaboratories.Controller.Shared.StreamingAPI.StreamText) returns (stream MiLaboratories.Controller.Shared.StreamingAPI.Response);
+   */
+  streamText(e, t) {
+    const n = this.methods[2], r = this._transport.mergeOptions(t);
+    return y(
+      "serverStreaming",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+  /**
+   * ReadBinary allows to read remote item in chunks using stream-like API.
+   * The difference to StreamBinary is that the client receives single response for each
+   * call and has to send new calls to the server to get fresh data from remote item.
+   * Each response (each chunk from server) keeps not more than 3.9MiB of data.
+   *
+   * @generated from protobuf rpc: ReadText(MiLaboratories.Controller.Shared.StreamingAPI.ReadText) returns (MiLaboratories.Controller.Shared.StreamingAPI.Response);
+   */
+  readText(e, t) {
+    const n = this.methods[3], r = this._transport.mergeOptions(t);
+    return y(
+      "unary",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+  /**
+   * LastLines provides single message with the last lines from data source.
+   * When search pattern is specified, the last lines matching the given pattern are returned.
+   * The lines are returned in reversed order, as server reads data source from the end.
+   * Consider it as equivalent to 'tac <file> | grep <search> | head -n <line_count>'
+   * The <new_offset> returned in the response points to the _beginning_ of the last
+   * line found, so client can continue reading the file backwards in subsequent calls.
+   * This means, that use of this <new_offset> in ReadText() will return you the same line
+   * returned last in LastLines() data.
+   *
+   * @generated from protobuf rpc: LastLines(MiLaboratories.Controller.Shared.StreamingAPI.LastLines) returns (MiLaboratories.Controller.Shared.StreamingAPI.Response);
+   */
+  lastLines(e, t) {
+    const n = this.methods[4], r = this._transport.mergeOptions(t);
+    return y(
+      "unary",
+      this._transport,
+      n,
+      r,
+      e
+    );
+  }
+}
+class Tr {
+  constructor(e, t, n) {
+    d(this, "grpcClient");
+    this.grpcTransport = e, this.httpClient = t, this.logger = n, this.grpcClient = new br(this.grpcTransport);
+  }
+  close() {
+  }
+  /** Reads text back and returns the text,
+   * the new offset
+   * and the total size of the (currently existing) file. */
+  async lastLines({ id: e, type: t }, n, r = 0n, o, c) {
+    return (await this.grpcClient.lastLines(
+      {
+        resourceId: e,
+        lineCount: n,
+        offset: r,
+        search: o
+      },
+      T(t, c)
+    )).response;
+  }
+  /** Reads the file forward and returns the text,
+   * the new offset
+   * and the total size of the (currently existing) file. */
+  async readText({ id: e, type: t }, n, r = 0n, o, c) {
+    return (await this.grpcClient.readText(
+      {
+        resourceId: O(e),
+        readLimit: BigInt(n),
+        offset: r,
+        search: o
+      },
+      T(t, c)
+    )).response;
+  }
+}
+const kr = process.env.PL_STORAGE_TO_PATH ? Object.fromEntries(
+  process.env.PL_STORAGE_TO_PATH.split(";").map((s) => s.split(":"))
+) : {};
+function Pn(s, e, t) {
+  return t === void 0 && (t = kr), e.getDriver({
+    name: "DownloadBlob",
+    init: (r, o, c) => new Jt(
+      o,
+      c,
+      s,
+      t
+    )
+  });
+}
+function In(s, e) {
+  return s.getDriver({
+    name: "StreamLogs",
+    init: (t, n, r) => new Tr(n, r, e)
+  });
+}
+function Nn(s, e) {
+  return s.getDriver({
+    name: "UploadProgress",
+    init: (t, n, r) => new At(n, r, s, e)
+  });
+}
+function Rn(s, e) {
+  return s.getDriver({
+    name: "UploadBlob",
+    init: (t, n, r) => new It(n, r, s, e)
+  });
+}
+function Sn(s, e) {
+  return s.getDriver({
+    name: "LsFiles",
+    init: (t, n, r) => new ir(n, e)
+  });
+}
+class Un {
+  constructor(e, t) {
+    d(this, "updater");
+    d(this, "schedule", () => this.updater.schedule());
+    this.onUpdate = e, this.sleepMs = t, this.updater = new Se(async () => {
+      for (; ; ) {
+        if (await this.onUpdate()) return;
+        await te.wait(this.sleepMs);
+      }
+    });
+  }
+}
+class Se {
+  constructor(e) {
+    d(this, "updating");
+    this.onUpdate = e;
+  }
+  schedule() {
+    this.updating == null && (this.updating = (async () => {
+      try {
+        await this.onUpdate();
+      } catch (e) {
+        console.log(`error while updating in Updater: ${e}`);
+      } finally {
+        this.updating = void 0;
+      }
+    })());
+  }
+}
+async function Bn(s, e) {
+  return s.withReadTx("LogsDriverGetStream", async (t) => {
+    const n = await t.getResourceData(e, !0), r = await Me(t, He(n, "stream"));
+    if (r.error != "")
+      throw new Error(`while getting stream: ${r.error}`);
+    if (!je(r.valueId))
+      return await t.getResourceData(r.valueId, !1);
+  });
+}
+const Ue = "8C7#F1328%9E089B3D22", Lr = /(?<stage>.*):\s*(?<progress>[\d.]+%)\s.*(?<eta>ETA:.*)/g;
+function Pr(s) {
+  const t = s.replace(Ue, "").match(Lr);
+  if (t == null || t.length != 4)
+    return;
+  const [n, r, o, c] = t;
+  return {
+    stage: r,
+    // For example, 'Building pre-clones from tag groups'
+    progress: o,
+    // 35.3%
+    eta: c
+    // ETA: 00:00:07
+  };
+}
+async function vn(s, e, t) {
+  const n = await e.lastLines(
+    s,
+    1,
+    0n,
+    Ue,
+    t
+  );
+  if (n.data == null || n.data.length == 0)
+    return { found: !1 };
+  const r = n.data.toString().split(/\r?\n/)[0];
+  if (r == null)
+    return { found: !1 };
+  const o = Pr(r);
+  return o === void 0 ? { found: !1 } : { found: !0, ...o };
+}
+class Be {
+  constructor(e) {
+    d(this, "cache", /* @__PURE__ */ new Map());
+    d(this, "totalSizeBytes", 0);
+    this.softSizeBytes = e;
+  }
+  existsFile(e) {
+    return this.cache.get(e) != null;
+  }
+  getFile(e, t) {
+    const n = this.cache.get(e);
+    return n != null && n.counter.inc(t), n;
+  }
+  /** Decrements a counter in a cache and if we exceeds
+   * a soft limit, removes files with zero counters. */
+  removeFile(e, t) {
+    return oe(this.cache, e).counter.dec(t), this.toDelete();
+  }
+  /** Returns what results should be deleted to comply with the soft limit. */
+  toDelete() {
+    if (this.totalSizeBytes <= this.softSizeBytes) return [];
+    const e = [];
+    let t = 0;
+    return Ve(this.cache).filter(([n, r]) => r.counter.isZero()).forEach(([n, r]) => {
+      if (this.totalSizeBytes - t <= this.softSizeBytes) return;
+      const o = oe(this.cache, n);
+      t += o.sizeBytes, e.push(o);
+    }), e;
+  }
+  addCache(e, t) {
+    const n = this.cache.get(e.path) == null;
+    if (this.cache.set(e.path, e), e.counter.inc(t), e.sizeBytes < 0) throw new Error(`empty sizeBytes: ${e}`);
+    n && (this.totalSizeBytes += e.sizeBytes);
+  }
+  removeCache(e) {
+    this.cache.delete(e.path), this.totalSizeBytes -= e.sizeBytes;
+  }
+}
+class Dn {
+  constructor(e, t) {
+    this.logsStreamDriver = e, this.downloadDriver = t;
+  }
+  getLastLogs(e, t, n) {
+    if (n === void 0)
+      return b.make((o) => this.getLastLogs(e, t, o));
+    const r = q(n, e);
+    if (r === void 0) {
+      n.markUnstable("no stream in stream manager");
+      return;
+    }
+    if (V(r))
+      return this.downloadDriver.getLastLogs(r, t, n);
+    try {
+      return this.logsStreamDriver.getLastLogs(r, t, n);
+    } catch (o) {
+      if (o.name == "RpcError" && o.code == "NOT_FOUND") {
+        n.markUnstable(
+          `NOT_FOUND in logs stream driver while getting last logs: ${o}`
+        );
+        return;
+      }
+      throw o;
+    }
+  }
+  getProgressLog(e, t, n) {
+    if (n === void 0)
+      return b.make(
+        (o) => this.getProgressLog(e, t, o)
+      );
+    const r = q(n, e);
+    if (r === void 0) {
+      n.markUnstable("no stream in stream manager");
+      return;
+    }
+    if (V(r))
+      return this.downloadDriver.getProgressLog(r, t, n);
+    try {
+      return this.logsStreamDriver.getProgressLog(r, t, n);
+    } catch (o) {
+      if (o.name == "RpcError" && o.code == "NOT_FOUND") {
+        n.markUnstable(
+          `NOT_FOUND in logs stream driver while getting a progress log: ${o}`
+        );
+        return;
+      }
+      throw o;
+    }
+  }
+  getLogHandle(e, t) {
+    if (t === void 0)
+      return b.make((r) => this.getLogHandle(e, r));
+    const n = q(t, e);
+    if (n === void 0) {
+      t.markUnstable("no stream in stream manager");
+      return;
+    }
+    return V(n) ? this.downloadDriver.getLogHandle(n, t) : this.logsStreamDriver.getLogHandle(n, t);
+  }
+  async lastLines(e, t, n, r) {
+    return C(e) ? await this.logsStreamDriver.lastLines(
+      e,
+      t,
+      n,
+      r
+    ) : await this.downloadDriver.lastLines(
+      e,
+      t,
+      n,
+      r
+    );
+  }
+  async readText(e, t, n, r) {
+    return C(e) ? await this.logsStreamDriver.readText(
+      e,
+      t,
+      n,
+      r
+    ) : await this.downloadDriver.readText(
+      e,
+      t,
+      n,
+      r
+    );
+  }
+}
+function V(s) {
+  return !s.type.name.startsWith("StreamWorkdir");
+}
+function q(s, e) {
+  var t;
+  return (t = s.accessor(e).node().traverse("stream")) == null ? void 0 : t.resourceInfo;
+}
+function $(s) {
+  let e;
+  if (C(s))
+    e = s.match(De);
+  else if (Ir(s))
+    e = s.match(_e);
+  else throw new Error(`Log handle is malformed: ${s}`);
+  if (e == null) throw new Error(`Log handle wasn't parsed: ${s}`);
+  const { resourceType: t, resourceVersion: n, resourceId: r } = e.groups;
+  return {
+    id: Q(BigInt(r)),
+    type: { name: t, version: n }
+  };
+}
+function ve(s, e) {
+  return s ? `log+live://log/${e.type.name}/${e.type.version}/${BigInt(e.id)}` : `log+ready://log/${e.type.name}/${e.type.version}/${BigInt(e.id)}`;
+}
+const De = /^log\+live:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
+function C(s) {
+  return De.test(s);
+}
+const _e = /^log\+ready:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
+function Ir(s) {
+  return _e.test(s);
+}
+const Nr = ye({
+  kv: {
+    "ctl/file/blobInfo": L.object({
+      sizeBytes: L.coerce.number()
+    })
+  }
+});
+class _n {
+  constructor(e, t, n, r, o, c) {
+    /** Represents a Resource Id to the path of a blob as a map. */
+    d(this, "idToDownload", /* @__PURE__ */ new Map());
+    /** Writes and removes files to a hard drive and holds a counter for every
+     * file that should be kept. */
+    d(this, "cache");
+    /** Downloads files and writes them to the local dir. */
+    d(this, "downloadQueue");
+    d(this, "idToOnDemand", /* @__PURE__ */ new Map());
+    d(this, "idToLastLines", /* @__PURE__ */ new Map());
+    d(this, "idToProgressLog", /* @__PURE__ */ new Map());
+    d(this, "saveDir");
+    this.logger = e, this.clientDownload = t, this.clientLogs = n, this.signer = o, this.cache = new Be(c.cacheSoftSizeBytes), this.downloadQueue = new X(
+      this.logger,
+      c.nConcurrentDownloads
+    ), this.saveDir = m.resolve(r);
+  }
+  getDownloadedBlob(e, t) {
+    if (t === void 0)
+      return b.make((c) => this.getDownloadedBlob(e, c));
+    const n = N(e, t), r = k();
+    t.addOnDestroy(() => this.releaseBlob(n.id, r));
+    const o = this.getDownloadedBlobNoCtx(
+      t.watcher,
+      n,
+      r
+    );
+    return o == null && t.markUnstable("download blob is still undefined"), o;
+  }
+  getOnDemandBlob(e, t) {
+    if (t === void 0)
+      return b.make((c) => this.getOnDemandBlob(e, c));
+    const n = be(e) ? Te(e, Nr, t) : e, r = k();
+    return t.addOnDestroy(() => this.releaseOnDemandBlob(n.id, r)), this.getOnDemandBlobNoCtx(t.watcher, n, r);
+  }
+  getLocalPath(e) {
+    return Z(e, this.signer);
+  }
+  async getContent(e) {
+    if (vr(e)) return await Sr(this.getLocalPath(e));
+    if (!_r(e)) throw new Error("Malformed remote handle");
+    const t = $r(e, this.signer), { content: n } = await this.clientDownload.downloadBlob(t);
+    return await we(n);
+  }
+  getDownloadedBlobNoCtx(e, t, n) {
+    let r = this.idToDownload.get(t.id);
+    if (r === void 0) {
+      const c = this.setNewDownloadTask(e, t, n);
+      this.downloadQueue.push({
+        fn: () => this.downloadBlob(c, n),
+        recoverableErrorPredicate: (i) => !0
+      }), r = c;
+    }
+    r.attach(e, n);
+    const o = r.getBlob();
+    if (o !== void 0) {
+      if (o.ok) return o.value;
+      throw o.error;
+    }
+  }
+  setNewDownloadTask(e, t, n) {
+    const r = this.getFilePath(t.id), o = new Br(
+      this.clientDownload,
+      t,
+      r,
+      Dr(r, this.signer)
+    );
+    return this.idToDownload.set(t.id, o), o;
+  }
+  async downloadBlob(e, t) {
+    var n;
+    await e.download(), (n = e.getBlob()) != null && n.ok && this.cache.addCache(e, t);
+  }
+  getOnDemandBlobNoCtx(e, t, n) {
+    let r = this.idToOnDemand.get(t.id);
+    return r === void 0 && (r = new Rr(
+      t.kv["ctl/file/blobInfo"].sizeBytes,
+      Cr(t, this.signer)
+    ), this.idToOnDemand.set(t.id, r)), r.attach(e, n), r.getHandle();
+  }
+  getLastLogs(e, t, n) {
+    if (n == null)
+      return b.make((i) => this.getLastLogs(e, t, i));
+    const r = N(e, n), o = k();
+    n.addOnDestroy(() => this.releaseBlob(r.id, o));
+    const c = this.getLastLogsNoCtx(
+      n.watcher,
+      r,
+      t,
+      o
+    );
+    return c == null && n.markUnstable("either a file was not downloaded or logs was not read"), c;
+  }
+  getLastLogsNoCtx(e, t, n, r) {
+    const o = this.getDownloadedBlobNoCtx(e, t, r);
+    if (o == null) return;
+    const c = Z(o.handle, this.signer);
+    let i = this.idToLastLines.get(t.id);
+    if (i == null) {
+      const a = new ae(c, n);
+      this.idToLastLines.set(t.id, a), i = a;
+    }
+    const l = i.getOrSchedule(e);
+    if (l.error) throw l.error;
+    return l.log;
+  }
+  getProgressLog(e, t, n) {
+    if (n == null)
+      return b.make(
+        (i) => this.getProgressLog(e, t, i)
+      );
+    const r = N(e, n), o = k();
+    n.addOnDestroy(() => this.releaseBlob(r.id, o));
+    const c = this.getProgressLogNoCtx(
+      n.watcher,
+      r,
+      t,
+      o
+    );
+    return c === void 0 && n.markUnstable(
+      "either a file was not downloaded or a progress log was not read"
+    ), c;
+  }
+  getProgressLogNoCtx(e, t, n, r) {
+    const o = this.getDownloadedBlobNoCtx(e, t, r);
+    if (o == null) return;
+    const c = Z(o.handle, this.signer);
+    let i = this.idToProgressLog.get(t.id);
+    if (i == null) {
+      const a = new ae(c, 1, n);
+      this.idToProgressLog.set(t.id, a), i = a;
+    }
+    const l = i.getOrSchedule(e);
+    if (l.error) throw l.error;
+    return l.log;
+  }
+  getLogHandle(e, t) {
+    if (t == null)
+      return b.make((r) => this.getLogHandle(e, r));
+    const n = N(e, t);
+    return this.getLogHandleNoCtx(n);
+  }
+  getLogHandleNoCtx(e) {
+    return ve(!1, e);
+  }
+  async lastLines(e, t, n, r) {
+    const o = await this.clientLogs.lastLines(
+      $(e),
+      t,
+      BigInt(n ?? 0),
+      r
+    );
+    return {
+      live: !1,
+      shouldUpdateHandle: !1,
+      data: o.data,
+      size: Number(o.size),
+      newOffset: Number(o.newOffset)
+    };
+  }
+  async readText(e, t, n, r) {
+    const o = await this.clientLogs.readText(
+      $(e),
+      t,
+      BigInt(n ?? 0),
+      r
+    );
+    return {
+      live: !1,
+      shouldUpdateHandle: !1,
+      data: o.data,
+      size: Number(o.size),
+      newOffset: Number(o.newOffset)
+    };
+  }
+  async releaseBlob(e, t) {
+    const n = this.idToDownload.get(e);
+    if (n != null)
+      if (this.cache.existsFile(n.path)) {
+        const r = this.cache.removeFile(n.path, t);
+        await Promise.all(
+          r.map(async (o) => {
+            await w.rm(o.path), this.cache.removeCache(o), this.removeTask(
+              o,
+              `the task ${o.path} was removedfrom cache along with ${r.map((c) => c.path)}`
+            );
+          })
+        );
+      } else
+        n.counter.dec(t) && this.removeTask(n, `the task ${n.path} was removed from cache`);
+  }
+  removeTask(e, t) {
+    e.abort(t), e.change.markChanged(), this.idToDownload.delete(e.rInfo.id), this.idToLastLines.delete(e.rInfo.id), this.idToProgressLog.delete(e.rInfo.id);
+  }
+  async releaseOnDemandBlob(e, t) {
+    var r;
+    (((r = this.idToOnDemand.get(e)) == null ? void 0 : r.release(t)) ?? !1) && this.idToOnDemand.delete(e);
+  }
+  /** Removes all files from a hard drive. */
+  async releaseAll() {
+    this.downloadQueue.stop(), this.idToDownload.forEach((e, t) => {
+      this.idToDownload.delete(t), e.change.markChanged();
+    });
+  }
+  getFilePath(e) {
+    return m.resolve(m.join(this.saveDir, String(BigInt(e))));
+  }
+}
+class Rr {
+  constructor(e, t) {
+    d(this, "change", new S());
+    d(this, "counter", new D());
+    this.size = e, this.handle = t;
+  }
+  getHandle() {
+    return { handle: this.handle, size: this.size };
+  }
+  attach(e, t) {
+    this.counter.inc(t), this.change.attachWatcher(e);
+  }
+  release(e) {
+    return this.counter.dec(e);
+  }
+}
+class ae {
+  constructor(e, t, n) {
+    d(this, "updater");
+    d(this, "log");
+    d(this, "change", new S());
+    d(this, "error");
+    this.path = e, this.lines = t, this.patternToSearch = n, this.updater = new Se(async () => this.update());
+  }
+  getOrSchedule(e) {
+    return this.change.attachWatcher(e), this.updater.schedule(), {
+      log: this.log,
+      error: this.error
+    };
+  }
+  async update() {
+    try {
+      const e = await Ur(
+        this.path,
+        this.lines,
+        this.patternToSearch
+      );
+      this.log != e && this.change.markChanged(), this.log = e;
+    } catch (e) {
+      if (e.name == "RpcError" && e.code == "NOT_FOUND") {
+        this.log = "", this.error = e, this.change.markChanged();
+        return;
+      }
+      throw e;
+    }
+  }
+}
+async function le(s) {
+  try {
+    return await w.access(s), !0;
+  } catch {
+    return !1;
+  }
+}
+async function Sr(s) {
+  return await we(K.toWeb(E.createReadStream(s)));
+}
+function Ur(s, e, t) {
+  const n = E.createReadStream(s), r = new ee();
+  return new Promise((o, c) => {
+    const i = Je.createInterface(n, r), l = new Qe();
+    i.on("line", function(a) {
+      t != null && !a.includes(t) || (l.push(a), l.length > e && l.shift());
+    }), i.on("error", c), i.on("close", function() {
+      o(l.toArray().join(se.EOL) + se.EOL);
+    });
+  });
+}
+let Br = class {
+  constructor(e, t, n, r) {
+    d(this, "counter", new D());
+    d(this, "change", new S());
+    d(this, "signalCtl", new AbortController());
+    d(this, "error");
+    d(this, "done", !1);
+    d(this, "sizeBytes", 0);
+    this.clientDownload = e, this.rInfo = t, this.path = n, this.handle = r;
+  }
+  attach(e, t) {
+    this.counter.inc(t), this.done || this.change.attachWatcher(e);
+  }
+  async download() {
+    try {
+      const { content: e, size: t } = await this.clientDownload.downloadBlob(
+        this.rInfo
+      );
+      if (await le(m.dirname(this.path)) || w.mkdir(m.dirname(this.path), { recursive: !0 }), !await le(this.path)) {
+        const n = ee.toWeb(E.createWriteStream(this.path));
+        await e.pipeTo(n);
+      }
+      this.setDone(t);
+    } catch (e) {
+      if (e instanceof ce || e instanceof re || e instanceof Ne || e instanceof Re || e.code == "ENOENT") {
+        this.setError(e), await w.rm(this.path);
+        return;
+      }
+      throw e;
+    }
+  }
+  getBlob() {
+    if (this.done)
+      return {
+        ok: !0,
+        value: {
+          handle: this.handle,
+          size: this.sizeBytes
+        }
+      };
+    if (this.error)
+      return {
+        ok: !1,
+        error: this.error
+      };
+  }
+  setDone(e) {
+    this.done = !0, this.sizeBytes = e, this.change.markChanged();
+  }
+  abort(e) {
+    this.signalCtl.abort(new ce(e));
+  }
+  setError(e) {
+    this.error = e, this.change.markChanged();
+  }
+};
+class ce extends Error {
+}
+const $e = /^blob\+local:\/\/download\/(?<path>.*)#(?<signature>.*)$/;
+function vr(s) {
+  return !!s.match($e);
+}
+function Z(s, e) {
+  const t = s.match($e);
+  if (t === null)
+    throw new Error(`Local handle is malformed: ${s}, matches: ${t}`);
+  const { path: n, signature: r } = t.groups;
+  return e.verify(
+    n,
+    r,
+    `Signature verification failed for: ${s}`
+  ), n;
+}
+function Dr(s, e) {
+  return `blob+local://download/${s}#${e.sign(s)}`;
+}
+const Ce = /^blob\+remote:\/\/download\/(?<content>(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*))#(?<signature>.*)$/;
+function _r(s) {
+  return !!s.match(Ce);
+}
+function $r(s, e) {
+  const t = s.match(Ce);
+  if (t === null)
+    throw new Error(
+      `Remote handle is malformed: ${s}, matches: ${t}`
+    );
+  const { content: n, resourceType: r, resourceVersion: o, resourceId: c, signature: i } = t.groups;
+  return e.verify(
+    n,
+    i,
+    `Signature verification failed for ${s}`
+  ), {
+    id: Q(BigInt(c)),
+    type: { name: r, version: o }
+  };
+}
+function Cr(s, e) {
+  const t = `${s.type.name}/${s.type.version}/${BigInt(s.id)}`;
+  return `blob+remote://download/${t}#${e.sign(t)}`;
+}
+const Or = L.object({
+  localPath: L.string(),
+  pathSignature: L.string(),
+  modificationTime: L.string()
+}), Er = L.union([Or, L.object({})]), Fr = ye({
+  data: Er,
+  fields: {
+    blob: !1,
+    // for BlobUpload
+    incarnation: !1
+    // for BlobIndex
+  }
+});
+class Cn {
+  constructor(e, t, n, r, o = {
+    nConcurrentPartUploads: 10,
+    nConcurrentGetProgresses: 10,
+    pollingInterval: 1e3,
+    stopPollingDelay: 1e3
+  }) {
+    d(this, "idToProgress", /* @__PURE__ */ new Map());
+    /** Holds a queue that upload blobs. */
+    d(this, "uploadQueue");
+    d(this, "hooks");
+    d(this, "scheduledOnNextState", []);
+    /** If true, main loop will continue polling pl state. */
+    d(this, "keepRunning", !1);
+    /** Actual state of main loop. */
+    d(this, "currentLoop");
+    this.logger = e, this.signer = t, this.clientBlob = n, this.clientProgress = r, this.opts = o, this.uploadQueue = new X(this.logger, 1, {
+      type: "exponentialWithMaxDelayBackoff",
+      initialDelay: 20,
+      maxDelay: 15e3,
+      // 15 seconds
+      backoffMultiplier: 1.5,
+      jitter: 0.5
+    }), this.hooks = new me(
+      () => this.startUpdating(),
+      () => this.stopUpdating(),
+      { stopDebounce: o.stopPollingDelay },
+      (c, i) => this.scheduleOnNextState(c, i)
+    );
+  }
+  getProgressId(e, t) {
+    if (t == null)
+      return b.make((c) => this.getProgressId(e, c));
+    const n = be(e) ? Te(e, Fr, t) : e, r = k();
+    t.attacheHooks(this.hooks), t.addOnDestroy(() => this.release(n.id, r));
+    const o = this.getProgressIdNoCtx(t.watcher, n, r);
+    return de(o) || t.markUnstable(
+      `upload/index progress was got, but it's not stable: ${o}`
+    ), o;
+  }
+  getProgressIdNoCtx(e, t, n) {
+    const r = t.fields.blob != null || t.fields.incarnation != null, o = this.idToProgress.get(t.id);
+    if (o != null)
+      return o.attach(e, n), o.mustGetProgress(r);
+    const c = new Wr(
+      this.logger,
+      this.clientBlob,
+      this.clientProgress,
+      this.opts.nConcurrentPartUploads,
+      this.signer,
+      t
+    );
+    return this.idToProgress.set(t.id, c), c.attach(e, n), c.progress.isUpload && c.progress.isUploadSignMatch && this.uploadQueue.push({
+      fn: () => c.uploadBlobTask(),
+      recoverableErrorPredicate: (i) => !Oe(i)
+    }), c.mustGetProgress(r);
+  }
+  /** Decrement counters for the file and remove an uploading if counter == 0. */
+  async release(e, t) {
+    const n = this.idToProgress.get(e);
+    if (n === void 0) return;
+    n.decCounter(t) && this.idToProgress.delete(e);
+  }
+  /** Must be called when the driver is closing. */
+  async releaseAll() {
+    this.uploadQueue.stop();
+  }
+  scheduleOnNextState(e, t) {
+    this.scheduledOnNextState.push({ resolve: e, reject: t });
+  }
+  /** Called from observer */
+  startUpdating() {
+    this.keepRunning = !0, this.currentLoop === void 0 && (this.currentLoop = this.mainLoop());
+  }
+  /** Called from observer */
+  stopUpdating() {
+    this.keepRunning = !1;
+  }
+  async mainLoop() {
+    for (; this.keepRunning; ) {
+      const e = this.scheduledOnNextState;
+      this.scheduledOnNextState = [];
+      try {
+        await Y(
+          this.opts.nConcurrentGetProgresses,
+          this.getAllNotDoneProgresses().map(
+            (t) => async () => await t.updateStatus()
+          )
+        ), e.forEach((t) => t.resolve());
+      } catch (t) {
+        console.error(t), e.forEach((n) => n.reject(t));
+      }
+      if (!this.keepRunning) break;
+      await te.wait(this.opts.pollingInterval);
+    }
+    this.currentLoop = void 0;
+  }
+  getAllNotDoneProgresses() {
+    return Array.from(this.idToProgress.entries()).filter(([e, t]) => !de(t.progress)).map(([e, t]) => t);
+  }
+}
+class Wr {
+  constructor(e, t, n, r, o, c) {
+    d(this, "change", new S());
+    d(this, "counter", new D());
+    d(this, "progress");
+    d(this, "uploadOpts");
+    d(this, "uploadingTerminallyFailed");
+    this.logger = e, this.clientBlob = t, this.clientProgress = n, this.nConcurrentPartsUpload = r, this.res = c;
+    const i = c.type.name.startsWith("BlobUpload");
+    let l;
+    i && (this.uploadOpts = Ar(c), l = xr(
+      o,
+      this.uploadOpts.localPath,
+      this.uploadOpts.pathSignature
+    )), this.progress = {
+      done: !1,
+      status: void 0,
+      isUpload: i,
+      isUploadSignMatch: l,
+      lastError: void 0
+    };
+  }
+  mustGetProgress(e) {
+    if (e)
+      return this.setDone(e), this.progress;
+    if (this.uploadingTerminallyFailed)
+      throw this.logger.error(
+        `Uploading terminally failed: ${this.progress.lastError}`
+      ), new Error(this.progress.lastError);
+    return this.progress;
+  }
+  attach(e, t) {
+    this.change.attachWatcher(e), this.counter.inc(t);
+  }
+  decCounter(e) {
+    return this.counter.dec(e);
+  }
+  /** Uploads a blob if it's not BlobIndex. */
+  async uploadBlobTask() {
+    try {
+      await this.uploadBlob();
+    } catch (e) {
+      if (this.setLastError(e), he(e)) {
+        this.logger.warn(`resource was deleted while uploading a blob: ${e}`), this.change.markChanged(), this.setDone(!0);
+        return;
+      }
+      throw this.logger.error(`error while uploading a blob: ${e}`), this.change.markChanged(), Oe(e) && this.terminateWithError(e), e;
+    }
+  }
+  /** Uploads a blob using client. */
+  async uploadBlob() {
+    if (this.counter.isZero()) return;
+    const e = await this.clientBlob.initUpload(this.res);
+    this.logger.info(
+      `start to upload blob ${this.res.id}, parts count: ${e.length}`
+    );
+    const t = (n) => async () => {
+      this.counter.isZero() || await this.clientBlob.partUpload(
+        this.res,
+        this.uploadOpts.localPath,
+        n,
+        e.length,
+        BigInt(this.uploadOpts.modificationTime)
+      );
+    };
+    await Y(this.nConcurrentPartsUpload, e.map(t)), !this.counter.isZero() && (await this.clientBlob.finalizeUpload(this.res), this.logger.info(`uploading of resource ${this.res.id} finished.`), this.change.markChanged());
+  }
+  terminateWithError(e) {
+    this.progress.lastError = String(e), this.progress.done = !1, this.uploadingTerminallyFailed = !0;
+  }
+  setLastError(e) {
+    this.progress.lastError = String(e);
+  }
+  setDone(e) {
+    this.progress.done = e;
+  }
+  async updateStatus() {
+    try {
+      const e = await this.clientProgress.getStatus(this.res), t = this.progress.status;
+      this.progress.status = zr(e), this.setDone(e.done), (e.done || e.progress != (t == null ? void 0 : t.progress)) && this.change.markChanged();
+    } catch (e) {
+      if (this.setLastError(e), e.name == "RpcError" && e.code == "DEADLINE_EXCEEDED") {
+        this.logger.warn(
+          "deadline exceeded while getting a status of BlobImport"
+        );
+        return;
+      }
+      if (he(e)) {
+        this.logger.warn(
+          `resource was not found while updating a status of BlobImport: ${e}, ${B(this.res)}`
+        ), this.change.markChanged(), this.setDone(!0);
+        return;
+      }
+      this.logger.error(`error while updating a status of BlobImport: ${e}`), this.change.markChanged(), this.terminateWithError(e);
+    }
+  }
+}
+function de(s) {
+  return s.done && s.status !== void 0 && s.status !== null && s.status.progress >= 1;
+}
+function Ar(s) {
+  if (s.data == null || !("modificationTime" in s.data))
+    throw new Error(
+      "no upload options in BlobUpload resource data: " + B(s.data)
+    );
+  const e = s.data;
+  if (e.modificationTime === void 0)
+    throw new Error(
+      "no modification time in data: " + B(s.data)
+    );
+  if (e.localPath === void 0)
+    throw new Error(
+      "no local path in data: " + B(s.data)
+    );
+  if (e.pathSignature === void 0)
+    throw new Error(
+      "no path signature in data: " + B(s.data)
+    );
+  return {
+    modificationTime: e.modificationTime,
+    localPath: e.localPath,
+    pathSignature: e.pathSignature
+  };
+}
+function zr(s) {
+  return {
+    progress: s.progress ?? 0,
+    bytesProcessed: Number(s.bytesProcessed),
+    bytesTotal: Number(s.bytesTotal)
+  };
+}
+function xr(s, e, t) {
+  try {
+    return s.verify(e, t), !0;
+  } catch {
+    return !1;
+  }
+}
+function Oe(s) {
+  return s instanceof ke || s instanceof Le || s instanceof Pe;
+}
+function he(s) {
+  return s.name == "RpcError" && (s.code == "NOT_FOUND" || s.code == "ABORTED" || s.code == "ALREADY_EXISTS");
+}
+class On {
+  constructor(e, t = {
+    nConcurrentGetLogs: 10,
+    pollingInterval: 1e3,
+    stopPollingDelay: 1e3
+  }) {
+    /** Holds a map of StreamManager Resource Id to all logs of this stream. */
+    d(this, "idToLastLines", /* @__PURE__ */ new Map());
+    /** Holds a map of StreamManager Resource Id to the last log line of this stream. */
+    d(this, "idToProgressLog", /* @__PURE__ */ new Map());
+    /** Holds a map of StreamManager Resource Id to log id smart object. */
+    d(this, "hooks");
+    d(this, "scheduledOnNextState", []);
+    /** If true, main loop will continue polling pl state. */
+    d(this, "keepRunning", !1);
+    /** Actual state of main loop. */
+    d(this, "currentLoop");
+    this.clientLogs = e, this.opts = t, this.hooks = new me(
+      () => this.startUpdating(),
+      () => this.stopUpdating(),
+      { stopDebounce: t.stopPollingDelay },
+      (n, r) => this.scheduleOnNextState(n, r)
+    );
+  }
+  getLastLogs(e, t, n) {
+    if (n == null)
+      return b.make((i) => this.getLastLogs(e, t, i));
+    const r = N(e, n), o = k();
+    n.attacheHooks(this.hooks), n.addOnDestroy(() => this.releaseLastLogs(r.id, o));
+    const c = this.getLastLogsNoCtx(n.watcher, r, t, o);
+    return n.markUnstable(
+      "The logs are from stream, so we consider them unstable. Final values will be got from blobs."
+    ), c;
+  }
+  getLastLogsNoCtx(e, t, n, r) {
+    let o = this.idToLastLines.get(t.id);
+    if (o == null) {
+      const i = new ue(this.clientLogs, t, n);
+      this.idToLastLines.set(t.id, i), o = i;
+    }
+    o.attach(e, r);
+    const c = o.getLog();
+    if (c.error != null) throw c.error;
+    return c.log;
+  }
+  getProgressLog(e, t, n) {
+    if (n == null)
+      return b.make(
+        (i) => this.getProgressLog(e, t, i)
+      );
+    const r = N(e, n), o = k();
+    n.attacheHooks(this.hooks), n.addOnDestroy(() => this.releaseProgressLog(r.id, o));
+    const c = this.getProgressLogNoCtx(
+      n.watcher,
+      r,
+      t,
+      o
+    );
+    return n.markUnstable(
+      "The progress log is from the stream, so we consider it unstable. Final value will be got from blobs."
+    ), c;
+  }
+  getProgressLogNoCtx(e, t, n, r) {
+    let o = this.idToProgressLog.get(t.id);
+    if (o == null) {
+      const i = new ue(
+        this.clientLogs,
+        t,
+        1,
+        n
+      );
+      this.idToProgressLog.set(t.id, i), o = i;
+    }
+    o.attach(e, r);
+    const c = o.getLog();
+    if (c.error) throw c.error;
+    return c.log;
+  }
+  getLogHandle(e, t) {
+    if (t == null)
+      return b.make((o) => this.getLogHandle(e, o));
+    const n = N(e, t), r = this.getLogHandleNoCtx(n);
+    return t.markUnstable(), r;
+  }
+  getLogHandleNoCtx(e) {
+    return ve(!0, e);
+  }
+  async lastLines(e, t, n, r) {
+    return await this.tryWithNotFound(
+      e,
+      () => this.clientLogs.lastLines(
+        $(e),
+        t,
+        BigInt(n ?? 0),
+        r
+      )
+    );
+  }
+  async readText(e, t, n, r) {
+    return await this.tryWithNotFound(
+      e,
+      () => this.clientLogs.readText(
+        $(e),
+        t,
+        BigInt(n ?? 0),
+        r
+      )
+    );
+  }
+  async tryWithNotFound(e, t) {
+    if (!C(e))
+      throw new Error(
+        `Not live log handle was passed to live log driver, handle: ${e}`
+      );
+    try {
+      const n = await t();
+      return {
+        live: !0,
+        shouldUpdateHandle: !1,
+        data: n.data,
+        size: Number(n.size),
+        newOffset: Number(n.newOffset)
+      };
+    } catch (n) {
+      if (n.name == "RpcError" && n.code == "NOT_FOUND")
+        return { shouldUpdateHandle: !0 };
+      throw n;
+    }
+  }
+  async releaseLastLogs(e, t) {
+    var r;
+    ((r = this.idToLastLines.get(e)) == null ? void 0 : r.release(t)) && this.idToLastLines.delete(e);
+  }
+  async releaseProgressLog(e, t) {
+    var r;
+    ((r = this.idToProgressLog.get(e)) == null ? void 0 : r.release(t)) && this.idToProgressLog.delete(e);
+  }
+  async releaseAll() {
+  }
+  scheduleOnNextState(e, t) {
+    this.scheduledOnNextState.push({ resolve: e, reject: t });
+  }
+  /** Called from observer */
+  startUpdating() {
+    this.keepRunning = !0, this.currentLoop === void 0 && (this.currentLoop = this.mainLoop());
+  }
+  /** Called from observer */
+  stopUpdating() {
+    this.keepRunning = !1;
+  }
+  async mainLoop() {
+    for (; this.keepRunning; ) {
+      const e = this.scheduledOnNextState;
+      this.scheduledOnNextState = [];
+      try {
+        await Y(
+          this.opts.nConcurrentGetLogs,
+          this.getAllNotDoneLogs().map(
+            (t) => async () => await t.update()
+          )
+        ), e.forEach((t) => t.resolve());
+      } catch (t) {
+        console.error(t), e.forEach((n) => n.reject(t));
+      }
+      if (!this.keepRunning) break;
+      await te.wait(this.opts.pollingInterval);
+    }
+    this.currentLoop = void 0;
+  }
+  getAllNotDoneLogs() {
+    return Array.from(this.idToLastLines.entries()).concat(Array.from(this.idToProgressLog.entries())).filter(([e, t]) => !t.getLog().done).map(([e, t]) => t);
+  }
+}
+class ue {
+  constructor(e, t, n, r) {
+    d(this, "logs");
+    d(this, "error");
+    d(this, "done", !1);
+    d(this, "change", new S());
+    d(this, "counter", new D());
+    this.clientLogs = e, this.rInfo = t, this.lines = n, this.patternToSearch = r;
+  }
+  getLog() {
+    return {
+      log: this.logs,
+      error: this.error,
+      done: this.done
+    };
+  }
+  attach(e, t) {
+    this.change.attachWatcher(e), this.counter.inc(t);
+  }
+  release(e) {
+    return this.counter.dec(e);
+  }
+  async update() {
+    try {
+      const t = (await this.clientLogs.lastLines(
+        this.rInfo,
+        this.lines,
+        0n,
+        this.patternToSearch
+      )).data.toString();
+      this.logs != t && this.change.markChanged(), this.logs = t;
+      return;
+    } catch (e) {
+      if (e.name == "RpcError" && e.code == "NOT_FOUND") {
+        this.logs = "", this.error = e, this.done = !0, this.change.markChanged();
+        return;
+      }
+      throw e;
+    }
+  }
+}
+class En {
+  constructor(e, t, n, r = {
+    cacheSoftSizeBytes: 50 * 1024 * 1024,
+    withGunzip: !0,
+    nConcurrentDownloads: 50
+  }) {
+    d(this, "downloadHelper");
+    d(this, "urlToDownload", /* @__PURE__ */ new Map());
+    d(this, "downloadQueue");
+    /** Writes and removes files to a hard drive and holds a counter for every
+     * file that should be kept. */
+    d(this, "cache");
+    this.logger = e, this.saveDir = n, this.opts = r, this.downloadQueue = new X(
+      this.logger,
+      this.opts.nConcurrentDownloads
+    ), this.cache = new Be(this.opts.cacheSoftSizeBytes), this.downloadHelper = new Ie(t);
+  }
+  getPath(e, t) {
+    if (t === void 0) return b.make((o) => this.getPath(e, o));
+    const n = k();
+    t.addOnDestroy(() => this.releasePath(e, n));
+    const r = this.getPathNoCtx(e, t.watcher, n);
+    return (r == null ? void 0 : r.path) === void 0 && t.markUnstable(
+      `a path to the downloaded and untared archive might be undefined. The current result: ${r}`
+    ), r;
+  }
+  getPathNoCtx(e, t, n) {
+    const r = e.toString(), o = this.urlToDownload.get(r);
+    if (o != null)
+      return o.attach(t, n), o.getPath();
+    const c = this.setNewTask(t, e, n);
+    return this.downloadQueue.push({
+      fn: async () => this.downloadUrl(c, n),
+      recoverableErrorPredicate: (i) => !0
+    }), c.getPath();
+  }
+  /** Downloads and extracts a tar archive if it wasn't downloaded yet. */
+  async downloadUrl(e, t) {
+    var n;
+    await e.download(this.downloadHelper, this.opts.withGunzip), ((n = e.getPath()) == null ? void 0 : n.path) != null && this.cache.addCache(e, t);
+  }
+  /** Removes a directory and aborts a downloading task when all callers
+   * are not interested in it. */
+  async releasePath(e, t) {
+    const n = e.toString(), r = this.urlToDownload.get(n);
+    if (r != null)
+      if (this.cache.existsFile(r.path)) {
+        const o = this.cache.removeFile(r.path, t);
+        await Promise.all(
+          o.map(async (c) => {
+            await J(c.path), this.cache.removeCache(c), this.removeTask(
+              c,
+              `the task ${JSON.stringify(c)} was removedfrom cache along with ${JSON.stringify(o)}`
+            );
+          })
+        );
+      } else
+        r.counter.dec(t) && this.removeTask(
+          r,
+          `the task ${JSON.stringify(r)} was removed from cache`
+        );
+  }
+  /** Removes all files from a hard drive. */
+  async releaseAll() {
+    this.downloadQueue.stop(), await Promise.all(
+      Array.from(this.urlToDownload.entries()).map(async ([e, t]) => {
+        await J(t.path), this.cache.removeCache(t), this.removeTask(
+          t,
+          `the task ${t} was released when the driver was closed`
+        );
+      })
+    );
+  }
+  setNewTask(e, t, n) {
+    const r = new Mr(this.getFilePath(t), t);
+    return r.attach(e, n), this.urlToDownload.set(t.toString(), r), r;
+  }
+  removeTask(e, t) {
+    e.abort(t), e.change.markChanged(), this.urlToDownload.delete(e.url.toString());
+  }
+  getFilePath(e) {
+    const t = Xe("sha256").update(e.toString()).digest("hex");
+    return m.join(this.saveDir, t);
+  }
+}
+class Mr {
+  constructor(e, t) {
+    d(this, "counter", new D());
+    d(this, "change", new S());
+    d(this, "signalCtl", new AbortController());
+    d(this, "error");
+    d(this, "done", !1);
+    d(this, "sizeBytes", 0);
+    this.path = e, this.url = t;
+  }
+  attach(e, t) {
+    this.counter.inc(t), this.done || this.change.attachWatcher(e);
+  }
+  async download(e, t) {
+    try {
+      const n = await this.downloadAndUntar(
+        e,
+        t,
+        this.signalCtl.signal
+      );
+      this.setDone(n);
+    } catch (n) {
+      if (n instanceof pe || n instanceof re) {
+        this.setError(n), await J(this.path);
+        return;
+      }
+      throw n;
+    }
+  }
+  async downloadAndUntar(e, t, n) {
+    if (await Hr(this.path))
+      return await Ee(this.path);
+    const r = await e.downloadRemoteFile(
+      this.url.toString(),
+      {},
+      n
+    );
+    let o = r.content;
+    if (t) {
+      const i = Ze.toWeb(Ye.createGunzip());
+      o = o.pipeThrough(i, { signal: n });
+    }
+    const c = ee.toWeb(Ke.extract(this.path));
+    return await o.pipeTo(c, { signal: n }), r.size;
+  }
+  getPath() {
+    if (this.done) return { path: O(this.path) };
+    if (this.error) return { error: this.error };
+  }
+  setDone(e) {
+    this.done = !0, this.sizeBytes = e, this.change.markChanged();
+  }
+  abort(e) {
+    this.signalCtl.abort(new pe(e));
+  }
+  setError(e) {
+    this.error = String(e), this.change.markChanged();
+  }
+}
+class pe extends Error {
+}
+async function Hr(s) {
+  try {
+    return await w.access(s), !0;
+  } catch {
+    return !1;
+  }
+}
+async function Ee(s) {
+  const e = await w.readdir(s, { withFileTypes: !0 });
+  return (await Promise.all(
+    e.map(async (n) => {
+      const r = m.join(s, n.name);
+      return n.isDirectory() ? await Ee(r) : (await w.stat(r)).size;
+    })
+  )).reduce((n, r) => n + r, 0);
+}
+async function J(s) {
+  await w.rm(s, { recursive: !0, force: !0 });
+}
+function jr(s) {
+  var t;
+  return {
+    parent: s.list.items.length > 0 ? (t = s.list.items[0]) == null ? void 0 : t.directory : void 0,
+    entries: s.list.items.map((n) => Gr(n, s))
+  };
+}
+function Gr(s, e) {
+  return s.isDir ? {
+    type: "dir",
+    name: s.name,
+    fullPath: s.fullName
+  } : {
+    type: "file",
+    name: s.name,
+    fullPath: s.fullName,
+    handle: Vr({ item: s, ...e })
+  };
+}
+function Vr(s) {
+  return s.remote ? qr(s) : Fe(
+    s.item.fullName,
+    s.signer,
+    s.item.size,
+    O(s.item.lastModified).seconds
+  );
+}
+function qr(s) {
+  return `index://index/${encodeURIComponent(
+    JSON.stringify({
+      storageId: s.storageName,
+      path: s.item.fullName
+    })
+  )}`;
+}
+function Fe(s, e, t, n) {
+  const r = {
+    localPath: s,
+    pathSignature: e.sign(s),
+    sizeBytes: String(t),
+    modificationTime: String(n)
+  };
+  return `upload://upload/${encodeURIComponent(JSON.stringify(r))}`;
+}
+function Zr(s, e) {
+  if (!(e.dirent.isFile() || e.dirent.isDirectory())) {
+    s.warn(
+      `tried to get non-dir and non-file ${e.dirent.name}, skip it`
+    );
+    return;
+  }
+  return {
+    directory: e.directory,
+    isDir: e.dirent.isDirectory(),
+    name: e.dirent.name,
+    fullName: e.fullName,
+    lastModified: {
+      seconds: BigInt(Math.floor(e.stat.mtimeMs / 1e3)),
+      nanos: 0
+    },
+    size: BigInt(e.stat.size)
+  };
+}
+function Jr(s, e) {
+  const t = Object.entries(s).map(Xr), n = Object.entries(e).map(tn);
+  return t.concat(n);
+}
+function Qr(s) {
+  if (rn(s))
+    return on(s);
+  if (Yr(s))
+    return en(s);
+  qe(s);
+}
+function Xr([s, e]) {
+  return {
+    name: s,
+    handle: Kr(s, e),
+    initialFullPath: e
+  };
+}
+const We = /^local:\/\/(?<name>.*)\/(?<path>.*)$/;
+function Yr(s) {
+  return We.test(s);
+}
+function Kr(s, e) {
+  return `local://${s}/${encodeURIComponent(e)}`;
+}
+function en(s) {
+  const e = s.match(We);
+  if (e == null)
+    throw new Error(`Local list handle wasn't parsed: ${s}`);
+  const { name: t, path: n } = e.groups;
+  return {
+    path: decodeURIComponent(n),
+    name: t,
+    remote: !1
+  };
+}
+function tn([s, e]) {
+  return {
+    name: s,
+    handle: nn(s, e),
+    initialFullPath: ""
+  };
+}
+const Ae = /^remote:\/\/(?<name>.*)\/(?<resourceId>.*)$/;
+function rn(s) {
+  return Ae.test(s);
+}
+function nn(s, e) {
+  return `remote://${s}/${BigInt(e)}`;
+}
+function on(s) {
+  const e = s.match(Ae);
+  if (e == null)
+    throw new Error(`Remote list handle wasn't parsed: ${s}`);
+  const { name: t, resourceId: n } = e.groups;
+  return {
+    id: Q(BigInt(n)),
+    type: sn(t),
+    name: t,
+    remote: !0
+  };
+}
+function sn(s) {
+  return { name: `LS/${s}`, version: "1" };
+}
+class Fn {
+  constructor(e, t, n, r, o) {
+    d(this, "storageIdToResourceId");
+    this.logger = e, this.clientLs = t, this.client = n, this.signer = r, this.localStorageToPath = o;
+  }
+  async getLocalFileHandle(e) {
+    const t = await w.stat(e, { bigint: !0 });
+    return Fe(
+      e,
+      this.signer,
+      t.size,
+      t.mtimeMs / 1000n
+      // integer division
+    );
+  }
+  async getStorageList() {
+    return Jr(
+      this.localStorageToPath,
+      await this.getAvailableStorageIds()
+    );
+  }
+  async listFiles(e, t) {
+    const n = Qr(e);
+    let r;
+    return n.remote ? r = await this.clientLs.list(n, t) : r = await this.getLocalFiles(this.logger, n.path, t), jr({
+      storageName: n.name,
+      list: r,
+      signer: this.signer,
+      remote: n.remote
+    });
+  }
+  async getAvailableStorageIds() {
+    return this.storageIdToResourceId == null && (this.storageIdToResourceId = await an(this.client)), this.storageIdToResourceId;
+  }
+  async getLocalFiles(e, t, n) {
+    const r = m.resolve(t), o = m.isAbsolute(n) ? n : m.resolve(m.join(r, n)), c = await w.opendir(o), i = [];
+    for await (const a of c) {
+      const p = m.join(o, a.name);
+      i.push({
+        directory: o,
+        fullName: p,
+        dirent: a,
+        stat: await w.stat(p)
+      });
+    }
+    return {
+      delimiter: m.sep,
+      items: i.map((a) => Zr(e, a)).filter((a) => a != null).map((a) => a)
+    };
+  }
+}
+async function an(s) {
+  return s.withReadTx("GetAvailableStorageIds", async (e) => {
+    const t = await e.getResourceByName("LSProvider"), n = await e.getResourceData(t, !0);
+    return ln(n);
+  });
+}
+function ln(s) {
+  return Object.fromEntries(
+    s.fields.filter((e) => e.type == "Dynamic" && Ge(e.value)).map((e) => [e.name.substring(8), e.value])
+  );
+}
+export {
+  Jt as ClientDownload,
+  Tr as ClientLogs,
+  ir as ClientLs,
+  At as ClientProgress,
+  It as ClientUpload,
+  Br as Download,
+  _n as DownloadDriver,
+  En as DownloadUrlDriver,
+  Dn as LogsDriver,
+  On as LogsStreamDriver,
+  Un as LongUpdater,
+  Fn as LsDriver,
+  ke as MTimeError,
+  Pt as NetworkError,
+  Pe as NoFileForUploading,
+  Nr as OnDemandBlobResourceSnapshot,
+  kr as PL_STORAGE_TO_PATH,
+  Le as UnexpectedEOF,
+  Ne as UnknownStorageError,
+  Se as Updater,
+  Cn as UploadDriver,
+  Fr as UploadResourceSnapshot,
+  Re as WrongLocalFileUrl,
+  Pn as createDownloadClient,
+  In as createLogsClient,
+  Sn as createLsFilesClient,
+  Rn as createUploadBlobClient,
+  Nn as createUploadProgressClient,
+  ve as dataToHandle,
+  Bn as getStream,
+  $ as handleToData,
+  Qt as headersFromProto,
+  Ar as importToUploadOpts,
+  C as isLiveLogHandle,
+  Ir as isReadyLogHandle,
+  Pr as lineToProgress,
+  vn as mixcrProgressFromLogs
+};
+//# sourceMappingURL=index.mjs.map