bazis 0.96.1

package/core/grpc/GrpcServer.ts

@@ -0,0 +1,204 @@
+import { createServer, createSecureServer, type Http2Server, type Http2SecureServer, type ServerHttp2Session, type ServerHttp2Stream, type IncomingHttpHeaders } from "node:http2";
+import type { AddressInfo } from "node:net";
+import type { HostedService, ModuleOwnedProviderContribution, ServiceProvider } from "../di";
+import type { GrpcControllerDefinition, GrpcModuleOptions } from "./contracts";
+import { ServerCredentials } from "./ServerCredentials";
+import { GrpcStatus } from "./GrpcStatus";
+import { GrpcCall } from "./GrpcCall";
+import { GrpcTransport } from "./GrpcTransport";
+import { GrpcError } from "./GrpcError";
+import type { MethodDefinition } from "./serviceDefinition";
+import { modelValidatorAdapter } from "../../library/validation";
+import { getGrpcRequestBinding } from "./GrpcBinding.contract";
+import { GrpcRequestBinding } from "./GrpcRequest.binding";
+
+type Contribution = ModuleOwnedProviderContribution<GrpcControllerDefinition, object>;
+
+/** Kernel-managed gRPC server built exclusively on the runtime's HTTP/2 API. */
+export class GrpcServer implements HostedService {
+  readonly phase: number;
+  private readonly server: Http2Server | Http2SecureServer;
+  private readonly hostname: string;
+  private readonly listenPort: number;
+  private readonly receiveLimit: number;
+  private readonly sendLimit: number;
+  private readonly maxConcurrentCalls: number;
+  private readonly shutdownTimeoutMs: number;
+  private readonly routes = new Map<string, { entry: Contribution; method: MethodDefinition; name: string | symbol; binding?: GrpcRequestBinding }>();
+  private readonly sessions = new Set<ServerHttp2Session>();
+  private readonly active = new Map<GrpcCall, Promise<void>>();
+  private state: "idle" | "starting" | "running" | "stopping" | "stopped" = "idle";
+  private starting?: Promise<void>;
+  private abortStart?: (error: unknown) => void;
+  private stopping?: Promise<void>;
+  private boundPort?: number;
+
+  constructor(options: GrpcModuleOptions, private readonly provider: ServiceProvider, controllers: readonly Contribution[]) {
+    const address = options.address ?? "127.0.0.1:50051";
+    const match = typeof address === "string" && /^(?:\[([^\]]+)\]|([^:[\]\s]+)):(\d{1,5})$/.exec(address);
+    if (!match || Number(match[3]) > 65535 || options.address === null) throw new TypeError("gRPC address must be host:port or [IPv6]:port.");
+    this.hostname = match[1] ?? match[2]!;
+    this.listenPort = Number(match[3]);
+    this.phase = options.phase === undefined ? 10 : options.phase;
+    if (!Number.isSafeInteger(this.phase)) throw new TypeError("gRPC phase must be a safe integer.");
+    this.maxConcurrentCalls = positiveInteger(options.maxConcurrentCalls, 1024, "maxConcurrentCalls");
+    this.shutdownTimeoutMs = positiveInteger(options.shutdownTimeoutMs, 5000, "shutdownTimeoutMs");
+    if (this.shutdownTimeoutMs > 2_147_483_647) throw new TypeError("gRPC shutdownTimeoutMs exceeds the timer range.");
+    const settings = options.serverOptions;
+    if (settings !== undefined && (!settings || typeof settings !== "object" || Array.isArray(settings))) throw new TypeError("Invalid gRPC serverOptions.");
+    const allowed = new Set(["grpc.max_receive_message_length", "grpc.max_send_message_length", "grpc.max_concurrent_streams"]);
+    for (const key of Object.keys(settings ?? {})) {
+      if (!allowed.has(key)) throw new TypeError("Unsupported gRPC server option: " + key);
+    }
+    this.receiveLimit = messageLimit(settings?.["grpc.max_receive_message_length"]);
+    this.sendLimit = messageLimit(settings?.["grpc.max_send_message_length"]);
+    const maxStreams = positiveInteger(settings?.["grpc.max_concurrent_streams"], 1024, "max_concurrent_streams");
+    if (maxStreams > 0xffffffff) throw new TypeError("gRPC max_concurrent_streams exceeds HTTP/2 range.");
+    const credentials = options.credentials === undefined ? ServerCredentials.createInsecure() : options.credentials;
+    if (!(credentials instanceof ServerCredentials)) throw new TypeError("gRPC credentials must be Bazis ServerCredentials.");
+    const validator = options.validator === undefined ? modelValidatorAdapter : options.validator;
+    if (!validator || typeof validator.validate !== "function") throw new TypeError("gRPC validator must implement ModelValidator.");
+    for (const entry of controllers) {
+      for (const [key, name] of entry.payload.methods) {
+        const method = entry.payload.service[key]!;
+        if (this.routes.has(method.path)) throw new TypeError("Duplicate gRPC method: " + method.path + ".");
+        const explicit = entry.payload.requestModels?.get(name);
+        const generated = getGrpcRequestBinding(entry.payload.controller, name);
+        if (!explicit && generated && generated.requestStream !== method.requestStream) {
+          throw new TypeError(`gRPC request stream/DTO mismatch: ${method.path}.`);
+        }
+        const model = explicit ?? generated?.model;
+        this.routes.set(method.path, { entry, method, name, binding: model ? new GrpcRequestBinding(model, validator) : undefined });
+      }
+    }
+    const tls = credentials.http2Options();
+    const http2 = { settings: { maxConcurrentStreams: maxStreams, maxHeaderListSize: 8192 }, maxHeaderListPairs: 128 };
+    this.server = tls ? createSecureServer({ ...tls, ...http2 }) : createServer(http2);
+    this.server.on("error", () => {}); // start() observes bind failures; peer/session failures never crash the process.
+    this.server.on("session", (session) => {
+      this.sessions.add(session);
+      session.on("error", () => {});
+      session.once("close", () => this.sessions.delete(session));
+      if (this.state === "stopping" || this.state === "stopped") session.destroy();
+    });
+    this.server.on("stream", (stream, headers) => this.accept(stream as ServerHttp2Stream, headers));
+  }
+
+  get port(): number | undefined { return this.boundPort; }
+  get activeCalls(): number { return this.active.size; }
+
+  private accept(stream: ServerHttp2Stream, headers: IncomingHttpHeaders): void {
+    stream.on("error", () => {});
+    stream.once("finish", () => { if (!stream.readableEnded && !stream.closed) stream.close(); });
+    if (!/^application\/grpc(?:\+proto)?(?:;|$)/.test(String(headers["content-type"]))) {
+      stream.respond({ ":status": 415 }, { endStream: true }); return;
+    }
+    const reject = (code: GrpcStatus, message: string): void => {
+      if (!stream.destroyed) stream.respond({
+        ":status": 200, "content-type": "application/grpc+proto", "grpc-accept-encoding": "identity",
+        "grpc-status": String(code), "grpc-message": encodeURIComponent(message),
+      }, { endStream: true });
+    };
+    if (headers[":method"] !== "POST") { reject(GrpcStatus.UNIMPLEMENTED, "gRPC requires POST."); return; }
+    if (this.state !== "running") { reject(GrpcStatus.UNAVAILABLE, "Server is stopping."); return; }
+    const route = this.routes.get(String(headers[":path"]));
+    if (!route) { reject(GrpcStatus.UNIMPLEMENTED, "Unknown gRPC method."); return; }
+    if (this.active.size >= this.maxConcurrentCalls) { reject(GrpcStatus.RESOURCE_EXHAUSTED, "Too many concurrent RPCs."); return; }
+    if (headers["grpc-encoding"] !== undefined && headers["grpc-encoding"] !== "identity") {
+      reject(GrpcStatus.UNIMPLEMENTED, "Compressed gRPC messages are not supported."); return;
+    }
+    let transport: GrpcTransport;
+    try { transport = new GrpcTransport(stream, headers, route.method, this.receiveLimit, this.sendLimit); }
+    catch (error) {
+      reject(error instanceof GrpcError ? error.code : GrpcStatus.INVALID_ARGUMENT, error instanceof GrpcError ? error.message : "Invalid gRPC headers.");
+      return;
+    }
+    const execution = new GrpcCall(transport, route.method, route.name, route.entry.activation, this.provider, route.binding);
+    const pending = execution.run().catch((error: unknown) => transport.fail(error))
+      .finally(() => this.active.delete(execution));
+    this.active.set(execution, pending);
+  }
+
+  start(signal?: AbortSignal): Promise<void> {
+    if (this.state === "running") return Promise.resolve();
+    if (this.state === "starting") return this.starting!;
+    if (this.state !== "idle") return Promise.reject(new Error("A stopped gRPC server cannot be restarted."));
+    if (signal?.aborted) { this.state = "stopped"; return Promise.reject(signal.reason); }
+    this.state = "starting";
+    this.starting = new Promise<void>((resolve, reject) => {
+      let settled = false;
+      const cleanup = (): void => {
+        signal?.removeEventListener("abort", abort);
+        this.server.off("error", fail);
+        this.abortStart = undefined;
+      };
+      const fail = (error: unknown): void => {
+        if (settled) return;
+        settled = true;
+        cleanup(); this.state = "stopped"; this.forceClose(); reject(error);
+      };
+      const abort = (): void => fail(signal?.reason ?? new Error("gRPC startup cancelled."));
+      this.abortStart = fail;
+      signal?.addEventListener("abort", abort, { once: true });
+      this.server.once("error", fail);
+      try {
+        this.server.listen(this.listenPort, this.hostname, () => {
+          cleanup();
+          if (this.state !== "starting") { this.forceClose(); reject(new Error("gRPC startup cancelled.")); return; }
+          settled = true;
+          this.boundPort = (this.server.address() as AddressInfo).port;
+          this.state = "running"; resolve();
+        });
+      } catch (error) { fail(error); }
+    });
+    return this.starting;
+  }
+
+  stop(): Promise<void> {
+    if (this.stopping) return this.stopping;
+    this.stopping = this.stopServer();
+    return this.stopping;
+  }
+  private async stopServer(): Promise<void> {
+    if (this.state === "idle" || this.state === "stopped") { this.state = "stopped"; return; }
+    if (this.state === "starting") {
+      this.abortStart?.(new Error("gRPC startup cancelled by stop."));
+      await this.starting?.catch(() => {});
+    }
+    this.state = "stopping";
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const closed = new Promise<void>((resolve) => {
+        if (!this.server.listening) { resolve(); return; }
+        this.server.close(() => resolve());
+      });
+      for (const session of this.sessions) session.close();
+      const expired = new Promise<never>((_resolve, reject) => {
+        timeout = setTimeout(() => {
+          for (const execution of this.active.keys()) execution.cancel();
+          this.forceClose();
+          reject(new Error("gRPC shutdown timed out; transport forced closed."));
+        }, this.shutdownTimeoutMs);
+      });
+      await Promise.race([Promise.all([closed, ...this.active.values()]), expired]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      this.forceClose(); this.boundPort = undefined; this.state = "stopped";
+    }
+  }
+  private forceClose(): void {
+    for (const session of this.sessions) session.destroy();
+    if (this.server.listening) this.server.close();
+  }
+}
+
+function positiveInteger(value: number | undefined, fallback: number, name: string): number {
+  const result = value === undefined ? fallback : value;
+  if (!Number.isSafeInteger(result) || result <= 0) throw new TypeError("gRPC " + name + " must be a positive safe integer.");
+  return result;
+}
+function messageLimit(value: number | undefined): number {
+  const result = value === undefined ? 4 * 1024 * 1024 : value;
+  if (!Number.isInteger(result) || result < 0 || result > 0x7fffffff) throw new TypeError("gRPC message limit must be 0..2147483647 bytes.");
+  return result;
+}

package/core/grpc/GrpcStatus.ts

@@ -0,0 +1,8 @@
+/** Standard gRPC status numbers, independent of any client/server library. */
+export enum GrpcStatus {
+  OK = 0, CANCELLED = 1, UNKNOWN = 2, INVALID_ARGUMENT = 3,
+  DEADLINE_EXCEEDED = 4, NOT_FOUND = 5, ALREADY_EXISTS = 6,
+  PERMISSION_DENIED = 7, RESOURCE_EXHAUSTED = 8, FAILED_PRECONDITION = 9,
+  ABORTED = 10, OUT_OF_RANGE = 11, UNIMPLEMENTED = 12, INTERNAL = 13,
+  UNAVAILABLE = 14, DATA_LOSS = 15, UNAUTHENTICATED = 16,
+}

package/core/grpc/GrpcTransport.ts

@@ -0,0 +1,174 @@
+import type { IncomingHttpHeaders, ServerHttp2Stream } from "node:http2";
+import type { GrpcContext } from "./contracts";
+import { Metadata } from "./Metadata";
+import { GrpcError } from "./GrpcError";
+import { GrpcStatus } from "./GrpcStatus";
+import type { MethodDefinition } from "./serviceDefinition";
+
+/** Owns the standard five-byte gRPC envelope and one built-in HTTP/2 stream. */
+export class GrpcTransport {
+  readonly context: GrpcContext;
+  private readonly abort = new AbortController();
+  private sentHeaders = false;
+  private ended = false;
+  private consumed = false;
+  private timer?: ReturnType<typeof setTimeout>;
+  private trailers: import("node:http2").OutgoingHttpHeaders = {};
+
+  constructor(
+    private readonly stream: ServerHttp2Stream,
+    headers: IncomingHttpHeaders,
+    private readonly method: MethodDefinition,
+    private readonly receiveLimit: number,
+    private readonly sendLimit: number,
+  ) {
+    const deadline = parseDeadline(headers["grpc-timeout"]);
+    this.context = Object.freeze({
+      metadata: Metadata.fromHttp2Headers(headers),
+      signal: this.abort.signal,
+      deadline,
+      path: method.path,
+      peer: stream.session?.socket.remoteAddress ?? "",
+      sendMetadata: (metadata: Metadata) => this.sendMetadata(metadata),
+    });
+    stream.on("error", () => this.disconnected());
+    stream.on("aborted", () => this.disconnected());
+    stream.on("close", () => { this.clearTimer(); if (!this.ended) this.disconnected(); });
+    stream.on("wantTrailers", () => {
+      if (!stream.destroyed && !stream.closed) {
+        try { stream.sendTrailers(this.trailers); } catch { this.disconnected(); }
+      }
+    });
+    if (deadline !== Infinity) this.armDeadline(deadline);
+  }
+
+  cancel(code = GrpcStatus.CANCELLED, message = "RPC cancelled."): void {
+    const error = new GrpcError(code, message);
+    this.abort.abort(error);
+    this.fail(error);
+  }
+  private disconnected(): void {
+    this.clearTimer();
+    this.abort.abort(new GrpcError(GrpcStatus.CANCELLED, "RPC cancelled."));
+    this.ended = true;
+  }
+  private armDeadline(deadline: number): void {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      const error = new GrpcError(GrpcStatus.DEADLINE_EXCEEDED, "Deadline exceeded.");
+      this.abort.abort(error); this.fail(error);
+    } else this.timer = setTimeout(() => this.armDeadline(deadline), Math.min(remaining, 2_147_483_647));
+  }
+  private clearTimer(): void { if (this.timer) clearTimeout(this.timer); this.timer = undefined; }
+
+  async unaryRequest(): Promise<unknown> {
+    let value: unknown, count = 0;
+    for await (const request of this.requests()) {
+      if (++count > 1) throw new GrpcError(GrpcStatus.INTERNAL, "Unary RPC requires exactly one message.");
+      value = request;
+    }
+    if (count !== 1) throw new GrpcError(GrpcStatus.INTERNAL, "Unary RPC requires exactly one message.");
+    return value;
+  }
+
+  async *requests(): AsyncGenerator<unknown> {
+    if (this.consumed) throw new Error("gRPC request stream can only be consumed once.");
+    this.consumed = true;
+    const iterator = this.stream.iterator({ destroyOnReturn: false });
+    const prefix = Buffer.alloc(5);
+    let prefixBytes = 0, message: Buffer | undefined, messageBytes = 0;
+    try {
+      while (true) {
+        const next = await abortable(iterator.next(), this.abort.signal);
+        if (next.done) break;
+        const chunk = next.value as Buffer;
+        let offset = 0;
+        while (offset < chunk.length) {
+          this.abort.signal.throwIfAborted();
+          if (!message) {
+            const amount = Math.min(5 - prefixBytes, chunk.length - offset);
+            chunk.copy(prefix, prefixBytes, offset, offset + amount);
+            offset += amount; prefixBytes += amount;
+            if (prefixBytes !== 5) continue;
+            if (prefix[0] !== 0) {
+              throw new GrpcError(prefix[0] === 1 ? GrpcStatus.UNIMPLEMENTED : GrpcStatus.INTERNAL,
+                prefix[0] === 1 ? "Compressed gRPC messages are not supported." : "Invalid gRPC compression flag.");
+            }
+            const length = prefix.readUInt32BE(1);
+            if (length > this.receiveLimit) throw new GrpcError(GrpcStatus.RESOURCE_EXHAUSTED, "gRPC request message is too large.");
+            message = Buffer.alloc(length); messageBytes = 0;
+          }
+          const amount = Math.min(message.length - messageBytes, chunk.length - offset);
+          chunk.copy(message, messageBytes, offset, offset + amount);
+          offset += amount; messageBytes += amount;
+          if (messageBytes === message.length) {
+            let value: unknown;
+            try { value = this.method.requestDeserialize(message); }
+            catch { throw new GrpcError(GrpcStatus.INTERNAL, "Invalid protobuf request."); }
+            message = undefined; prefixBytes = 0;
+            yield value;
+          }
+        }
+      }
+      this.abort.signal.throwIfAborted();
+      if (message || prefixBytes !== 0) throw new GrpcError(GrpcStatus.INTERNAL, "Incomplete gRPC message.");
+    } finally {
+      // return() never destroys the duplex response side. A pending read is
+      // released by stream close after status/cancellation.
+      void iterator.return?.().catch(() => {});
+    }
+  }
+
+  sendMetadata(metadata: Metadata): void {
+    if (!(metadata instanceof Metadata)) throw new TypeError("Expected Bazis Metadata.");
+    if (this.sentHeaders || this.ended) throw new Error("gRPC response headers have already been sent.");
+    this.stream.respond({ ...metadata.toHttp2Headers(), ":status": 200, "content-type": "application/grpc+proto", "grpc-accept-encoding": "identity" }, { waitForTrailers: true });
+    this.sentHeaders = true;
+  }
+  async write(value: unknown): Promise<void> {
+    this.abort.signal.throwIfAborted();
+    if (this.ended) return;
+    const body = this.method.responseSerialize(value);
+    if (!Buffer.isBuffer(body)) throw new TypeError("gRPC codecs must return Buffer.");
+    if (body.length > this.sendLimit) throw new GrpcError(GrpcStatus.RESOURCE_EXHAUSTED, "gRPC response message is too large.");
+    if (!this.sentHeaders) this.sendMetadata(new Metadata());
+    const frame = Buffer.allocUnsafe(body.length + 5);
+    frame[0] = 0; frame.writeUInt32BE(body.length, 1); body.copy(frame, 5);
+    await abortable(new Promise<void>((resolve, reject) => {
+      this.stream.write(frame, (error?: Error | null) => error ? reject(error) : resolve());
+    }), this.abort.signal);
+  }
+  fail(error: unknown): void {
+    const failure = error instanceof GrpcError ? error : new GrpcError(GrpcStatus.INTERNAL, "Internal server error.");
+    this.finish(failure.code, failure.message, failure.metadata);
+  }
+  finish(code = GrpcStatus.OK, message = "", metadata = new Metadata()): void {
+    if (this.ended) return;
+    const trailers = { ...metadata.toHttp2Headers(), "grpc-status": String(code),
+      "grpc-message": encodeURIComponent(Buffer.from(message, "utf8").toString("utf8")) };
+    this.ended = true; this.clearTimer();
+    this.trailers = trailers;
+    if (this.stream.destroyed || this.stream.closed) return;
+    try {
+      if (!this.sentHeaders) {
+        this.stream.respond({ ":status": 200, "content-type": "application/grpc+proto", ...this.trailers }, { endStream: true });
+      } else this.stream.end();
+    } catch { this.disconnected(); }
+  }
+}
+
+function parseDeadline(value: string | string[] | undefined): number {
+  if (value === undefined) return Infinity;
+  if (typeof value !== "string" || !/^\d{1,8}[HMSmun]$/.test(value)) throw new GrpcError(GrpcStatus.INVALID_ARGUMENT, "Invalid grpc-timeout.");
+  const scale: Record<string, number> = { H: 3_600_000, M: 60_000, S: 1000, m: 1, u: 0.001, n: 0.000001 };
+  return Date.now() + Math.ceil(Number(value.slice(0, -1)) * scale[value.at(-1)!]!);
+}
+
+function abortable<T>(pending: Promise<T>, signal: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const cancel = (): void => reject(signal.reason);
+    if (signal.aborted) { void pending.catch(() => {}); reject(signal.reason); return; }
+    signal.addEventListener("abort", cancel, { once: true });
+    pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", cancel));
+  });
+}

package/core/grpc/Metadata.ts

@@ -0,0 +1,73 @@
+import type { OutgoingHttpHeaders } from "node:http2";
+
+export type MetadataValue = string | Buffer;
+
+/** gRPC metadata. Binary values use -bin keys and base64 only on the wire. */
+export class Metadata {
+  private readonly values = new Map<string, MetadataValue[]>();
+
+  set(key: string, value: MetadataValue): void {
+    key = this.validate(key, value);
+    this.values.set(key, [Buffer.isBuffer(value) ? Buffer.from(value) : value]);
+  }
+  add(key: string, value: MetadataValue): void {
+    key = this.validate(key, value);
+    const values = this.values.get(key) ?? [];
+    values.push(Buffer.isBuffer(value) ? Buffer.from(value) : value);
+    this.values.set(key, values);
+  }
+  get(key: string): MetadataValue[] { return [...(this.values.get(key.toLowerCase()) ?? [])]; }
+  remove(key: string): void { this.values.delete(key.toLowerCase()); }
+  getMap(): Record<string, MetadataValue> {
+    return Object.fromEntries([...this.values].map(([key, values]) => [key, values[0]!]));
+  }
+  clone(): Metadata {
+    const result = new Metadata();
+    for (const [key, values] of this.values) for (const value of values) result.add(key, value);
+    return result;
+  }
+  merge(other: Metadata): void {
+    for (const [key, values] of other.values) for (const value of values) this.add(key, value);
+  }
+  toHttp2Headers(): OutgoingHttpHeaders {
+    const headers: OutgoingHttpHeaders = Object.create(null);
+    for (const [key, values] of this.values) {
+      // Application metadata cannot override transport control headers.
+      if (reserved(key)) continue;
+      headers[key] = values.map((value) => Buffer.isBuffer(value) ? value.toString("base64") : value);
+    }
+    return headers;
+  }
+  static fromHttp2Headers(headers: Readonly<Record<string, string | string[] | number | undefined>>): Metadata {
+    const result = new Metadata();
+    for (const [key, raw] of Object.entries(headers)) {
+      if (raw === undefined || reserved(key)) continue;
+      for (const value of Array.isArray(raw) ? raw : [String(raw)]) {
+        if (key.endsWith("-bin")) {
+          for (const part of value.split(",")) {
+            const encoded = part.trim();
+            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.replace(/=+$/, "").length % 4 === 1) {
+              throw new TypeError("Invalid binary gRPC metadata.");
+            }
+            result.add(key, Buffer.from(encoded, "base64"));
+          }
+        } else if (/^[\x20-\x7e]*$/.test(value)) result.add(key, value);
+      }
+    }
+    return result;
+  }
+  private validate(key: string, value: MetadataValue): string {
+    if (typeof key !== "string" || !/^[0-9a-z_.-]+$/i.test(key)) throw new TypeError("Invalid gRPC metadata key.");
+    key = key.toLowerCase();
+    if (key.endsWith("-bin") ? !Buffer.isBuffer(value) : typeof value !== "string" || !/^[\x20-\x7e]*$/.test(value)) {
+      throw new TypeError("gRPC metadata requires printable text, or Buffer for a -bin key.");
+    }
+    return key;
+  }
+}
+
+function reserved(key: string): boolean {
+  return key.startsWith(":") || key.startsWith("grpc-")
+    && key !== "grpc-status-details-bin"
+    || ["content-type", "te", "user-agent"].includes(key);
+}