@naced/llm-multi-rate-limiter 0.0.0-stage → 0.1.2

package/lib/status-rpc.js

@@ -0,0 +1,285 @@
+/**
+ * dsh-llm-multi-rate-limiter — status RPC channel (Host half).
+ *
+ * Exposes live rate-limiter statistics to the browser over the framework's
+ * generic Connection RPC channel. The framework supplies POST+JSON transport,
+ * the Host/Origin fence (403) and browser authentication (401); this module
+ * only answers endpoints and shapes envelopes.
+ *
+ * Two mounting paths exist, and both speak the *same* wire protocol so the
+ * browser half never needs to know which one is active:
+ *
+ *  1. `connection.rpc.handle(channel, handler)` — the framework's own generic
+ *     channel registry. Preferred: the framework owns the route, the request
+ *     validation, and the fiber-scoped withdrawal.
+ *
+ *  2. `createChannelRoute({ channel, handler, reject })` — a self-registered
+ *     prefix route for hosts where path 1 is broken. DSH 0.1.5-rc.3 changed
+ *     `@deepseek-ai/dsh-client-connection`'s own `inject` from
+ *     `["webServer", "credentials"]` to `["credentials"]` while
+ *     `HostConnectionService.register()` still dereferences
+ *     `owner.webServer`, so `rpc.handle` throws
+ *     `cannot get property "webServer" without inject`. This route is
+ *     registered on our own fiber (which *can* see `webServer`) and reuses the
+ *     connection service's public `requestRejection()` fence, so the 403/401
+ *     policy is still the framework's.
+ *
+ * Envelope contract (mirrors the Connection wire schema):
+ *   success: { ok: true,  value: <JSON-safe> }
+ *   failure: { ok: false, error: { code, message, details } }
+ *
+ * @module dsh-llm-multi-rate-limiter/status-rpc
+ */
+
+/**
+ * Channel name. Must satisfy the framework's `assertChannel` pattern
+ * `/^\/[A-Za-z0-9._~-]+$/` and must not be the reserved `/api` channel.
+ */
+const CHANNEL = "/llm-multi-rate-limiter";
+
+/**
+ * Endpoint grammar for one path segment, copied verbatim from the framework's
+ * `ENDPOINT_SEGMENT_PATTERN` in dsh-client-connection. Keeping it identical is
+ * what makes the self-registered route accept and reject exactly the same URLs
+ * as `rpc.handle` would.
+ */
+const ENDPOINT_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+
+/**
+ * Buffered-body cap for the self-registered route. Both endpoints are called
+ * with an empty payload, so this is a defensive memory bound rather than a
+ * real limit (the framework uses its own, much larger, carrier cap).
+ */
+const MAX_REQUEST_BODY_BYTES = 1024 * 1024;
+
+/**
+ * Correlation id echoed when the request envelope cannot be parsed at all —
+ * the same literal the framework uses (`INVALID_REQUEST_RPC_ID`).
+ */
+const INVALID_REQUEST_RPC_ID = "invalid-request";
+
+/**
+ * Build a failure envelope. Field-for-field the same shape the Connection
+ * host accepts, so callers can rely on `ok` discrimination alone.
+ * @param {string} code - stable machine-readable error code.
+ * @param {string} message - human-readable detail.
+ * @param {Record<string, unknown>} [details] - optional structured context.
+ * @returns {{ ok: false, error: { code: string, message: string, details: Record<string, unknown> } }}
+ */
+function failure(code, message, details = {}) {
+  return { ok: false, error: { code, message, details } };
+}
+
+/** Build a success envelope. */
+function success(value) {
+  return { ok: true, value };
+}
+
+/**
+ * Create the channel handler.
+ *
+ * @param {object} deps
+ * @param {() => object} deps.buildSnapshot - live snapshot builder.
+ * @param {() => void} deps.resetTotals - zero the counters (and bump `rev`).
+ * @returns {(endpoint: string, payload: unknown, signal?: AbortSignal) => Promise<object>}
+ */
+function createStatusChannel({ buildSnapshot, resetTotals }) {
+  return async function statusChannel(endpoint) {
+    if (endpoint === "snapshot") return success(buildSnapshot());
+    if (endpoint === "reset") {
+      resetTotals();
+      return success({});
+    }
+    return failure(
+      "llm-multi-rate-limiter/unknown-endpoint",
+      `unknown endpoint: ${String(endpoint)}`,
+    );
+  };
+}
+
+/* ── self-registered route (the DSH 0.1.5-rc.3 fallback) ───────────────── */
+
+/** Narrow an unknown JSON value to a plain object. */
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Extract the endpoint from a channel-relative pathname, mirroring the
+ * framework's `endpointFromPath`: a single `channel/<endpoint>` segment whose
+ * segments all satisfy {@link ENDPOINT_SEGMENT_PATTERN}.
+ *
+ * @param {string} channel - the channel prefix (e.g. `/llm-multi-rate-limiter`).
+ * @param {string} pathname - request pathname.
+ * @returns {string | undefined} the endpoint, or undefined when the URL is not
+ *   a well-formed member of this channel.
+ */
+function endpointFromPath(channel, pathname) {
+  if (!pathname.startsWith(`${channel}/`)) return undefined;
+  const endpoint = pathname.slice(channel.length + 1);
+  const segments = endpoint.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === ".." || !ENDPOINT_SEGMENT_PATTERN.test(segment))) return undefined;
+  return endpoint;
+}
+
+/**
+ * Read and decode the request body, refusing anything above `limit` bytes so a
+ * hostile caller cannot make the host buffer without bound.
+ *
+ * @param {import("node:http").IncomingMessage} req - node request stream.
+ * @param {number} limit - maximum accepted byte count.
+ * @returns {Promise<string>} the decoded UTF-8 body.
+ * @throws {Error & { code: "TOO_LARGE" }} when the body exceeds `limit`.
+ */
+async function readBody(req, limit) {
+  const chunks = [];
+  let received = 0;
+  for await (const chunk of req) {
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    received += buffer.byteLength;
+    if (received > limit) {
+      const error = new Error("request body too large");
+      error.code = "TOO_LARGE";
+      throw error;
+    }
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+/**
+ * Write one `server-response` envelope as JSON — byte-for-byte the shape
+ * `Response.json(...)` produces on the framework's own route.
+ *
+ * @param {import("node:http").ServerResponse} res - response to own.
+ * @param {string} rpcId - correlation id to echo.
+ * @param {object} result - the `{ ok, value }` / `{ ok, error }` envelope.
+ */
+function sendEnvelope(res, rpcId, result) {
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify({ type: "server-response", rpcId, result }));
+}
+
+/**
+ * Build a webserver prefix route that speaks the Connection RPC wire protocol.
+ *
+ * This is the fallback carrier for {@link createStatusChannel} on hosts where
+ * `connection.rpc.handle` throws. Every request-shape decision mirrors the
+ * framework's `rpcFetchHandler` so the browser half is byte-compatible with the
+ * preferred path:
+ *
+ * | condition | response |
+ * |---|---|
+ * | fence/auth rejected by `reject` | `403` (or `401`) + `forbidden`/`unauthorized` |
+ * | non-POST, or URL outside the channel | `404 not found` |
+ * | `content-type` not `application/json` | `415` |
+ * | body over {@link MAX_REQUEST_BODY_BYTES} | `413` |
+ * | body not JSON | `400 body is not JSON` |
+ * | envelope not a `client-request` | `gateway/bad-request` envelope |
+ * | `method` ≠ endpoint | `gateway/bad-request` envelope |
+ * | handler threw | `500 handler failure: ...` |
+ * | otherwise | `200` + `server-response` envelope |
+ *
+ * @param {object} deps
+ * @param {string} deps.channel - channel prefix to own (e.g. `/llm-multi-rate-limiter`).
+ * @param {(endpoint: string, payload: unknown, signal?: AbortSignal) => Promise<object>} deps.handler - endpoint dispatcher.
+ * @param {(req: import("node:http").IncomingMessage) => number | undefined} deps.reject - the framework's `connection.requestRejection` fence; returns an HTTP status to refuse with, or undefined to allow.
+ * @returns {{ kind: "prefix", path: string, handler: (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse) => Promise<void> }}
+ */
+function createChannelRoute({ channel, handler, reject }) {
+  return {
+    kind: "prefix",
+    path: channel,
+    handler: async (req, res) => {
+      // 1. The framework's own fence: Host/Origin trust (403) then browser
+      //    authentication (401). Reusing it keeps the security policy identical.
+      const rejection = reject(req);
+      if (rejection !== undefined) {
+        res.writeHead(rejection);
+        res.end(rejection === 401 ? "unauthorized" : "forbidden");
+        return;
+      }
+
+      // 2. POST-only, and only inside this channel (framework: 404 otherwise).
+      const url = new URL(req.url ?? "/", "http://dsh.internal");
+      const endpoint = endpointFromPath(channel, url.pathname);
+      if (req.method !== "POST" || endpoint === undefined) {
+        res.writeHead(404);
+        res.end("not found");
+        return;
+      }
+
+      // 3. JSON only (framework: 415).
+      const mediaType = String(req.headers["content-type"] ?? "").split(";", 1)[0].trim().toLowerCase();
+      if (mediaType !== "application/json") {
+        res.writeHead(415);
+        res.end("content type must be application/json");
+        return;
+      }
+
+      // 4. Buffer the body under a defensive cap, then parse it.
+      let raw;
+      try {
+        raw = await readBody(req, MAX_REQUEST_BODY_BYTES);
+      } catch (error) {
+        if (error?.code === "TOO_LARGE") {
+          res.writeHead(413, { connection: "close" });
+          res.end();
+          req.destroy?.();
+          return;
+        }
+        throw error;
+      }
+      let body;
+      try {
+        body = JSON.parse(raw);
+      } catch {
+        res.writeHead(400);
+        res.end("body is not JSON");
+        return;
+      }
+
+      // 5. Validate the client-request envelope; echo the correlation id
+      //    whenever it is a string, exactly like the framework does.
+      const rpcId = typeof body?.rpcId === "string" ? body.rpcId : INVALID_REQUEST_RPC_ID;
+      if (!isRecord(body) || body.type !== "client-request" || typeof body.rpcId !== "string" || typeof body.method !== "string") {
+        sendEnvelope(res, rpcId, failure("gateway/bad-request", "invalid client-request message", { issues: [] }));
+        return;
+      }
+      if (body.method !== endpoint) {
+        sendEnvelope(res, rpcId, failure(
+          "gateway/bad-request",
+          `method ${JSON.stringify(body.method)} does not match endpoint ${JSON.stringify(endpoint)}`,
+          { issues: [] },
+        ));
+        return;
+      }
+
+      // 6. Dispatch. Tie the signal to the response lifetime, as the framework's
+      //    http bridge does, so a dropped client can cancel the work.
+      const abort = new AbortController();
+      res.on?.("close", () => {
+        if (!res.writableEnded) abort.abort();
+      });
+      let result;
+      try {
+        result = await handler(endpoint, body.payload, abort.signal);
+      } catch (error) {
+        res.writeHead(500);
+        res.end(`handler failure: ${String(error)}`);
+        return;
+      }
+      sendEnvelope(res, rpcId, result);
+    },
+  };
+}
+
+export {
+  CHANNEL,
+  MAX_REQUEST_BODY_BYTES,
+  createChannelRoute,
+  createStatusChannel,
+  endpointFromPath,
+  failure,
+  success,
+};

package/lib/strategies/sliding-window.js

@@ -0,0 +1,174 @@
+/**
+ * Sliding-Window rate limiter strategy.
+ *
+ * Counts requests inside a rolling window of `windowMs` milliseconds.
+ * The window slides continuously: each request's timestamp is recorded,
+ * and the count is the number of timestamps inside the window.
+ *
+ * Concurrency is controlled separately (same as TokenBucketStrategy).
+ *
+ * @module dsh-llm-multi-rate-limiter/strategies/sliding-window
+ */
+
+export class SlidingWindowStrategy {
+  /** @type {{ windowMs: number, maxRpm: number, maxConcurrent: number }} */
+  #cfg;
+  #concurrent = 0;
+  /**
+   * Slots handed to a waiter that has not called `acquireSlot()` yet.
+   *
+   * `#drain()` wakes several waiters in one pass and each of them takes its
+   * concurrent slot only after the promise settles; counting reservations keeps
+   * one release from unlocking the entire queue past `maxConcurrent`.
+   */
+  #reserved = 0;
+  /** @type {number[]} — timestamps (Date.now()) inside the window */
+  #timestamps = [];
+  /** @type {Array<{ resolve: (r: { granted: boolean }) => void, abort: () => void }>} */
+  #waiters = [];
+  #timer;
+
+  /**
+   * @param {object} config — `{ windowMs, maxRpm, maxConcurrent }`
+   */
+  constructor(config) {
+    this.#cfg = { ...config };
+    // Prune stale timestamps every second.
+    this.#timer = setInterval(() => this.#prune(), 1_000);
+  }
+
+  /* ── public API ─────────────────────────────────────── */
+
+  acquire({ signal, timeoutMs }) {
+    const t0 = Date.now();
+
+    if (signal?.aborted) return Promise.resolve({ granted: false });
+
+    // Fast path: concurrency AND window capacity both available.
+    if (this.#concurrent < this.#cfg.maxConcurrent && this.#count() < this.#cfg.maxRpm) {
+      this.#timestamps.push(Date.now());
+      return Promise.resolve({ granted: true });
+    }
+
+    if (this.#cfg.maxConcurrent <= 0) return Promise.resolve({ granted: false });
+
+    return new Promise((resolve) => {
+      // A waiter can be granted by `#drain()` in the same tick its timeout
+      // fires; settling once keeps the window/slot accounting exact.
+      let settled = false;
+      const onDone = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        const idx = this.#waiters.indexOf(entry);
+        if (idx >= 0) this.#waiters.splice(idx, 1);
+        resolve({ ...result, waitMs: Date.now() - t0 });
+      };
+
+      const onAbort = () => onDone({ granted: false });
+      const timer = setTimeout(() => onDone({ granted: false }), timeoutMs);
+
+      const entry = {
+        resolve: () => onDone({ granted: true }),
+        abort: onAbort,
+      };
+
+      this.#waiters.push(entry);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+
+  /**
+   * Non-blocking acquisition: record the request in the window and take an
+   * implicit concurrent slot if both are available right now, without parking
+   * in the queue.
+   *
+   * Used by "reject" throttle mode, which must not wait, but must still count
+   * the request so the rate limit is enforced.
+   *
+   * @returns {{ granted: boolean }} — granted means the request was counted
+   *   and a concurrent slot taken; the caller MUST pair it with `releaseSlot()`.
+   */
+  acquireNonBlocking() {
+    if (this.#concurrent < this.#cfg.maxConcurrent && this.#count() < this.#cfg.maxRpm) {
+      this.#timestamps.push(Date.now());
+      this.#concurrent += 1;
+      return { granted: true };
+    }
+    return { granted: false };
+  }
+
+  /**
+   * Mark one concurrent slot as in-use (converting a `#drain()` reservation
+   * when there is one, so the slot is never counted twice).
+   */
+  acquireSlot() {
+    if (this.#reserved > 0) this.#reserved -= 1;
+    this.#concurrent += 1;
+  }
+
+  releaseSlot() {
+    this.#concurrent = Math.max(0, this.#concurrent - 1);
+    this.#drain();
+  }
+
+  getStatus() {
+    return {
+      strategy: "sliding-window",
+      windowMs: this.#cfg.windowMs,
+      countInWindow: this.#count(),
+      maxRpm: this.#cfg.maxRpm,
+      concurrent: this.#concurrent,
+      reserved: this.#reserved,
+      maxConcurrent: this.#cfg.maxConcurrent,
+      queued: this.#waiters.length,
+    };
+  }
+
+  update(config) {
+    Object.assign(this.#cfg, config);
+  }
+
+  dispose() {
+    clearInterval(this.#timer);
+    for (const w of this.#waiters) w.abort();
+    this.#waiters = [];
+  }
+
+  /* ── internals ─────────────────────────────────────── */
+
+  /** Number of timestamps inside the current window. */
+  #count() {
+    const cutoff = Date.now() - this.#cfg.windowMs;
+    // timestamps are pushed in order, so find the first that's still inside.
+    let i = 0;
+    while (i < this.#timestamps.length && this.#timestamps[i] <= cutoff) i += 1;
+    return this.#timestamps.length - i;
+  }
+
+  /** Remove timestamps that fell out of the window. */
+  #prune() {
+    const cutoff = Date.now() - this.#cfg.windowMs;
+    while (this.#timestamps.length > 0 && this.#timestamps[0] <= cutoff) {
+      this.#timestamps.shift();
+    }
+    this.#drain();
+  }
+
+  /** Drain waiters as long as capacity is available. */
+  #drain() {
+    while (
+      this.#waiters.length > 0
+      && this.#count() < this.#cfg.maxRpm
+      && this.#concurrent + this.#reserved < this.#cfg.maxConcurrent
+    ) {
+      this.#timestamps.push(Date.now());
+      // Reserve the concurrent slot for the waiter we are about to wake; it is
+      // converted into a live slot by `acquireSlot()` a microtask later.
+      this.#reserved += 1;
+      const waiter = this.#waiters.shift();
+      waiter?.resolve();
+    }
+  }
+}

package/lib/strategies/token-bucket.js

@@ -0,0 +1,196 @@
+/**
+ * Token-Bucket rate limiter strategy.
+ *
+ * Each model gets its own bucket.  A bucket has:
+ *  - `burstSize`  — maximum tokens the bucket can hold
+ *  - `refillRate` — tokens added per second
+ *  - a concurrent-slot counter (separate from tokens, so burst + concurrency are orthogonal)
+ *
+ * When the bucket is empty the request is queued (a promise resolver parked in
+ * `waiters[]`).  As tokens refill, waiters are drained in FIFO order.
+ *
+ * @module dsh-llm-multi-rate-limiter/strategies/token-bucket
+ */
+
+export class TokenBucketStrategy {
+  /** @type {{ burstSize: number, refillRate: number, maxConcurrent: number }} */
+  #cfg;
+  #tokens;
+  #lastRefill;
+  #concurrent = 0;
+  /**
+   * Slots handed to a waiter that has not called `acquireSlot()` yet.
+   *
+   * `#drain()` resolves several waiters in one pass, and each of them takes its
+   * concurrent slot only after the promise settles. Counting reservations keeps
+   * the drain loop from granting more waiters than `maxConcurrent` allows —
+   * without this, one `releaseSlot()` could release the whole queue at once.
+   */
+  #reserved = 0;
+  /** @type {Array<{ resolve: (r: { granted: boolean }) => void, abort: () => void }>} */
+  #waiters = [];
+  #timer;
+
+  /**
+   * @param {object} config — `{ burstSize, refillRate, maxConcurrent }`
+   */
+  constructor(config) {
+    this.#cfg = { ...config };
+    this.#tokens = config.burstSize;
+    this.#lastRefill = Date.now();
+    this.#startRefill();
+  }
+
+  /* ── public API ─────────────────────────────────────── */
+
+  /**
+   * Wait until a request is allowed.
+   * Resolves `{ granted: true }` immediately or after the queue drains.
+   * Resolves `{ granted: false }` on abort or timeout (timeout is the caller's
+   * responsibility — it races this promise against a timer).
+   *
+   * @param {{ signal?: AbortSignal, timeoutMs: number }} opts
+   * @returns {Promise<{ granted: boolean, waitMs?: number }>}
+   */
+  acquire({ signal, timeoutMs }) {
+    const t0 = Date.now();
+
+    // Already aborted — fail fast.
+    if (signal?.aborted) {
+      return Promise.resolve({ granted: false });
+    }
+
+    // Fast path: concurrency room AND a token available.
+    if (this.#concurrent < this.#cfg.maxConcurrent && this.#tokens >= 1) {
+      this.#tokens -= 1;
+      return Promise.resolve({ granted: true });
+    }
+
+    // Slow path: park in the waiter queue.
+    if (this.#cfg.maxConcurrent <= 0) {
+      return Promise.resolve({ granted: false });
+    }
+
+    return new Promise((resolve) => {
+      // A waiter can be granted by `#drain()` in the same tick its timeout
+      // fires; settling once keeps the token/slot accounting exact.
+      let settled = false;
+      const onDone = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        const idx = this.#waiters.indexOf(entry);
+        if (idx >= 0) this.#waiters.splice(idx, 1);
+        resolve({ ...result, waitMs: Date.now() - t0 });
+      };
+
+      const onAbort = () => onDone({ granted: false });
+
+      const timer = setTimeout(() => onDone({ granted: false }), timeoutMs);
+
+      const entry = {
+        resolve: () => {
+          // Token already deducted by _drain.
+          onDone({ granted: true });
+        },
+        abort: onAbort,
+      };
+
+      this.#waiters.push(entry);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+
+  /**
+   * Non-blocking acquisition: consume a token and an implicit concurrent slot
+   * if both are available right now, without parking in the queue.
+   *
+   * Used by "reject" throttle mode, which must not wait, but must still deduct
+   * tokens so the rate limit is enforced (otherwise only the concurrency cap
+   * would bite).
+   *
+   * @returns {{ granted: boolean }} — granted means a token was consumed and a
+   *   concurrent slot taken; the caller MUST pair it with `releaseSlot()`.
+   */
+  acquireNonBlocking() {
+    if (this.#concurrent < this.#cfg.maxConcurrent && this.#tokens >= 1) {
+      this.#tokens -= 1;
+      this.#concurrent += 1;
+      return { granted: true };
+    }
+    return { granted: false };
+  }
+
+  /**
+   * Mark one concurrent slot as in-use.
+   *
+   * When the slot was already reserved by `#drain()`, this converts the
+   * reservation into a live slot instead of taking a second one.
+   */
+  acquireSlot() {
+    if (this.#reserved > 0) this.#reserved -= 1;
+    this.#concurrent += 1;
+  }
+
+  /** Release one concurrent slot and try to drain waiters. */
+  releaseSlot() {
+    this.#concurrent = Math.max(0, this.#concurrent - 1);
+    this.#drain();
+  }
+
+  /** Live snapshot for the GUI. */
+  getStatus() {
+    return {
+      strategy: "token-bucket",
+      tokens: Math.round(this.#tokens * 100) / 100,
+      burstSize: this.#cfg.burstSize,
+      refillRate: this.#cfg.refillRate,
+      concurrent: this.#concurrent,
+      reserved: this.#reserved,
+      maxConcurrent: this.#cfg.maxConcurrent,
+      queued: this.#waiters.length,
+    };
+  }
+
+  /** Replace config at runtime (hot-reload). */
+  update(config) {
+    Object.assign(this.#cfg, config);
+  }
+
+  /** Dispose — release all waiters and stop the refill timer. */
+  dispose() {
+    clearInterval(this.#timer);
+    for (const w of this.#waiters) w.abort();
+    this.#waiters = [];
+  }
+
+  /* ── internals ─────────────────────────────────────── */
+
+  #startRefill() {
+    // Refill every 50 ms for smooth granularity.
+    this.#timer = setInterval(() => {
+      const now = Date.now();
+      const elapsed = (now - this.#lastRefill) / 1000;
+      this.#tokens = Math.min(this.#cfg.burstSize, this.#tokens + elapsed * this.#cfg.refillRate);
+      this.#lastRefill = now;
+      this.#drain();
+    }, 50);
+  }
+
+  /** Drain waiters as long as we have tokens and concurrency room. */
+  #drain() {
+    while (
+      this.#waiters.length > 0
+      && this.#tokens >= 1
+      && this.#concurrent + this.#reserved < this.#cfg.maxConcurrent
+    ) {
+      this.#tokens -= 1;
+      // Reserve the concurrent slot for the waiter we are about to wake; it is
+      // converted into a live slot by `acquireSlot()` a microtask later.
+      this.#reserved += 1;
+      const waiter = this.#waiters.shift();
+      waiter?.resolve();
+    }
+  }
+}