@restatedev/restate-sdk-integration-client 0.0.0-placeholder → 1.18.0

package/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -0,0 +1,133 @@
+# @restatedev/restate-sdk-integration-client
+
+Turn any source of events into Restate invocations through the Restate ingestion API.
+
+> **Experimental.** The ingestion API is not yet part of a released Restate version.
+
+Node-only (uses `node:http2`). Node ≥ 22.
+
+## Installation
+
+```bash
+npm install @restatedev/restate-sdk-integration-client
+```
+
+## Create a client
+
+Create one client for your Restate ingress URL and close it when your integration shuts down:
+
+```ts
+import { connect } from "@restatedev/restate-sdk-integration-client";
+
+const client = connect({ url: "http://localhost:8080" });
+// Use the client
+await client.close();
+```
+
+Pass `authToken` to send a bearer token.
+
+## Simple producer
+
+Use `producer()` when your source does not provide stable offsets that you can replay.
+Call `close()` (or `flush()`) to wait until Restate has durably committed everything you sent:
+
+```ts
+const producer = client.producer();
+for (const record of records) {
+  await producer.send({
+    service: "OrderService",
+    handler: "ingest",
+    headers: { "content-type": "application/json" },
+    body: record.payload,
+  });
+}
+await producer.close();
+```
+
+`send()` resolves once the producer accepted the record into its buffer, not once Restate committed it.
+When the buffer is full (`bufferBytes`, 32 MiB by default) `send()` waits, so **always await `send()`**:
+calls that are not awaited keep waiting for buffer space without any bound.
+
+To wait a single individual record to be committed instead, pass `waitCommitted`:
+
+```ts
+const offset = await producer.send(record, { waitCommitted: true });
+```
+
+## Exactly-once producer
+
+Use `exactlyOnceProducer()` when your source provides stable, strictly increasing offsets.
+Restate deduplicates records on `(producerId, offset)`, across streams and restarts,
+so choose a producer id that remains stable across restarts and is unique to that offset sequence.
+
+Checkpoint the committed offset in your source with `onCommitted`, or with the value returned by `flush()`.
+After a restart, resume from the checkpoint: Restate drops the records it already committed.
+
+```ts
+const producer = client.exactlyOnceProducer("orders/partition-0", {
+  // Optional, you can use this to add a hook to your source checkpointing
+  onCommitted: (offset) => checkpoints.save("orders/partition-0", offset),
+});
+for (const record of sourceRecords) {
+  await producer.send({
+    offset: record.offset,
+    service: "OrderService",
+    handler: "ingest",
+    body: record.payload,
+  });
+}
+// Waits all previous records to be durably committed
+const committedOffset = await producer.flush();
+```
+
+## Producer defaults
+
+Producers accept `defaults` when every invocation shares fields such as the target service, handler, or headers.
+Defaults are sent once, when the stream is opened, instead of with every invocation.
+Fields set on an individual invocation override the defaults.
+
+```ts
+const producer = client.producer({
+  defaults: {
+    service: "OrderService",
+    handler: "ingest",
+    headers: { "content-type": "application/json" },
+  },
+});
+for (const record of records) {
+  await producer.send({ body: record.payload });
+}
+```
+
+## Piping a source
+
+`producer.writable` is a `WritableStream` view of the producer: writing sends the record,
+closing the stream closes the producer, and the producer buffer applies backpressure to the source.
+
+```ts
+await ReadableStream.from(records)
+  .pipeThrough(
+    new TransformStream({
+      transform: (record, controller) =>
+        controller.enqueue({ body: record.payload }),
+    })
+  )
+  .pipeTo(producer.writable);
+```
+
+With Node streams, convert it with `Writable.fromWeb`:
+
+```ts
+import { Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+await pipeline(
+  source,
+  async function* (records) {
+    for await (const record of records) yield { body: record.payload };
+  },
+  Writable.fromWeb(producer.writable, { objectMode: true })
+);
+```
+
+

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,25 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/api.d.cts

@@ -0,0 +1,219 @@
+import { Transport } from "@connectrpc/connect";
+
+//#region src/api.d.ts
+
+/**
+ * Options for {@link connect}.
+ *
+ * @experimental
+ */
+interface IntegrationClientOptions {
+  /**
+   * Restate ingress URL, e.g. `http://localhost:8080`. `https` selects TLS.
+   */
+  url: string;
+  /**
+   * Bearer token, sent as the `authorization` header of every ingestion stream.
+   */
+  authToken?: string;
+  /**
+   * Identifies the integration to Restate, as `name/version`. Restate records it on
+   * traces and metrics. Longer than 64 bytes, it is truncated.
+   *
+   * Defaults to this client's own identity, `restate-integration-client-ts/<version>`.
+   */
+  integration?: {
+    name: string;
+    version: string;
+  };
+  /**
+   * Connect transport to use instead of opening a new HTTP/2 connection to
+   * {@link IntegrationClientOptions.url}.
+   * The transport remains owned by the caller and {@link IntegrationClient.close} does not
+   * close it.
+   */
+  transport?: Transport;
+}
+/**
+ * Entry point for producing invocations to Restate through the ingestion API.
+ *
+ * @experimental
+ */
+interface IntegrationClient {
+  /**
+   * Creates an at-least-once {@link Producer}. Offsets are assigned automatically, and
+   * records resent on a new stream are not deduplicated: set {@link Invocation.idempotencyKey}
+   * when handler-level deduplication is required.
+   */
+  producer(opts?: ProducerOptions): Producer;
+  /**
+   * Creates an {@link ExactlyOnceProducer}. Restate deduplicates on `(producerId, offset)`, so
+   * choose a producer id that is stable across restarts and distinct per independent offset
+   * sequence, e.g. a Kafka `groupId/topic/partition`.
+   *
+   * @param producerId - stable identity of the producer, non-empty and at most 256 bytes.
+   */
+  exactlyOnceProducer(producerId: string, opts?: ProducerOptions): ExactlyOnceProducer;
+  /**
+   * Closes the HTTP/2 connection opened by this client. Close (or flush) the producers
+   * first when their records must be durably committed.
+   */
+  close(): Promise<void>;
+}
+/**
+ * Invocation fields shared by every record of a producer, see {@link ProducerOptions.defaults}.
+ *
+ * @experimental
+ */
+interface InvocationDefaults {
+  /** Target service name. */
+  service?: string;
+  /** Target handler name. */
+  handler?: string;
+  /** Target key, required when the target is a Virtual Object or a Workflow. */
+  key?: string;
+  /** Invocation scope. */
+  scope?: string;
+  /** Concurrency/rate limit key. */
+  limitKey?: string;
+  /** Headers. A record's own headers are added to these, overriding the same keys. */
+  headers?: Record<string, string>;
+}
+/**
+ * A record to send through a {@link Producer}. Fields set here override the producer
+ * {@link ProducerOptions.defaults}.
+ *
+ * @experimental
+ */
+interface Invocation extends InvocationDefaults {
+  /** Invocation payload. Strings are encoded as UTF-8. */
+  body?: Uint8Array | string;
+  /** Idempotency key used by Restate to deduplicate the invocation. */
+  idempotencyKey?: string;
+  /** Schedule the invocation at this time. */
+  invokeAt?: Date;
+  /** W3C `traceparent`. */
+  traceparent?: string;
+  /** W3C `tracestate`. */
+  tracestate?: string;
+}
+/**
+ * A record to send through an {@link ExactlyOnceProducer}.
+ *
+ * @experimental
+ */
+interface ExactlyOnceInvocation extends Invocation {
+  /**
+   * Position of this record in the source, e.g. a Kafka offset. Must be strictly greater than
+   * the offset of the previous record sent by this producer, and at most
+   * `Number.MAX_SAFE_INTEGER`. Gaps are allowed.
+   */
+  offset: number;
+}
+/**
+ * Options for {@link IntegrationClient.producer} and {@link IntegrationClient.exactlyOnceProducer}.
+ *
+ * @experimental
+ */
+interface ProducerOptions {
+  /**
+   * Fields applied to every record unless the record sets them itself. They are sent
+   * once, when the stream is opened.
+   */
+  defaults?: InvocationDefaults;
+  /**
+   * Maximum combined serialized size of the records waiting to be written to the stream.
+   * While the buffer is full, {@link ProducerBase.send} waits. Zero disables the buffer:
+   * `send` then waits until the record can be written to the stream directly.
+   *
+   * Defaults to 32 MiB.
+   */
+  bufferBytes?: number;
+  /**
+   * Called with the commit watermark every time it advances: every record with an offset up
+   * to and including it is durably committed by Restate. Use it to checkpoint an
+   * exactly-once source.
+   *
+   * If the callback throws, the producer is aborted with the thrown error.
+   */
+  onCommitted?: (offset: number) => void;
+}
+/**
+ * Options for {@link ProducerBase.send}.
+ *
+ * @experimental
+ */
+interface SendOptions {
+  /**
+   * Wait until the record is durably committed by Restate, instead of only until it is
+   * accepted by the producer.
+   */
+  waitCommitted?: boolean;
+}
+/**
+ * Operations shared by {@link Producer} and {@link ExactlyOnceProducer}.
+ *
+ * A producer owns one ingestion stream. Errors are terminal: once the stream fails, every
+ * pending and later operation rejects with the same error, and a new producer is needed.
+ *
+ * @experimental
+ */
+interface ProducerBase<R extends Invocation> {
+  /**
+   * Sends a record.
+   *
+   * The returned promise resolves with the record offset once the producer has accepted the
+   * record into its buffer (or, with `bufferBytes: 0`, written it to the stream), waiting
+   * while the buffer is full. With `waitCommitted`, it resolves once Restate has durably
+   * committed the record instead.
+   *
+   * Always await `send`: calls that are not awaited keep waiting for buffer space without
+   * any bound. Records are sent in call order, so concurrent calls, e.g. with `Promise.all`,
+   * are safe. Note that a record rejected by validation (an oversized record, or a
+   * non-increasing exactly-once offset) rejects only its own call, while the others are
+   * still sent: with an exactly-once producer, validate records before sending them
+   * concurrently, or the commit watermark can move past the rejected offset.
+   */
+  send(record: R, opts?: SendOptions): Promise<number>;
+  /**
+   * Waits until every record sent so far is durably committed.
+   *
+   * @returns the commit watermark, or -1 if nothing was sent.
+   */
+  flush(): Promise<number>;
+  /**
+   * Flushes the producer, then closes its stream.
+   */
+  close(): Promise<void>;
+  /**
+   * Closes the producer immediately, without flushing. Every pending operation rejects
+   * with `reason`.
+   */
+  abort(reason?: unknown): void;
+  /**
+   * A `WritableStream` view of this producer, to pipe a source into it, e.g. with
+   * `ReadableStream.pipeTo` or Node's `stream/promises` `pipeline`. Writing sends the
+   * record, closing the stream closes the producer and aborting it aborts the producer.
+   */
+  readonly writable: WritableStream<R>;
+}
+/**
+ * Sends invocations to Restate with at-least-once delivery.
+ *
+ * @experimental
+ */
+type Producer = ProducerBase<Invocation>;
+/**
+ * Sends invocations to Restate with exactly-once delivery: Restate deduplicates records on
+ * `(producerId, offset)`, across streams and restarts. After a restart, resend from the
+ * last checkpointed offset and Restate drops the records it already committed.
+ *
+ * @experimental
+ */
+interface ExactlyOnceProducer extends ProducerBase<ExactlyOnceInvocation> {
+  /** Stable identity of this producer. */
+  readonly producerId: string;
+}
+//#endregion
+export { ExactlyOnceInvocation, ExactlyOnceProducer, IntegrationClient, IntegrationClientOptions, Invocation, InvocationDefaults, Producer, ProducerBase, ProducerOptions, SendOptions };
+//# sourceMappingURL=api.d.cts.map

package/dist/api.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.cts","names":[],"sources":["../src/api.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AAiCA;;AAMoC,UAvCnB,wBAAA,CAuCmB;EAWzB;;;EAOO,GAAA,EAAA,MAAA;EAQD;AAqBjB;;EAMa,SAAA,CAAA,EAAA,MAAA;EANuB;;AAkBpC;AAcA;AA+BA;AAgBA;EAAwC,WAAA,CAAA,EAAA;IAgBzB,IAAA,EAAA,MAAA;IAAU,OAAA,EAAA,MAAA;EAAc,CAAA;EAO5B;;;;;AA0BX;EASiB,SAAA,CAAA,EAtMH,SAsMG;;;;;;;UA9LA,iBAAA;;;;;;kBAMC,kBAAkB;;;;;;;;iDAWzB,kBACN;;;;;WAMM;;;;;;;UAQM,kBAAA;;;;;;;;;;;;YAYL;;;;;;;;UASK,UAAA,SAAmB;;SAE3B;;;;aAII;;;;;;;;;;;UAYI,qBAAA,SAA8B;;;;;;;;;;;;;UAc9B,eAAA;;;;;aAKJ;;;;;;;;;;;;;;;;;;;;;;;UA0BI,WAAA;;;;;;;;;;;;;;;UAgBA,uBAAuB;;;;;;;;;;;;;;;;eAgBzB,UAAU,cAAc;;;;;;WAO5B;;;;WAKA;;;;;;;;;;;qBAaU,eAAe;;;;;;;KAQxB,QAAA,GAAW,aAAa;;;;;;;;UASnB,mBAAA,SAA4B,aAAa"}

package/dist/api.d.ts

@@ -0,0 +1,219 @@
+import { Transport } from "@connectrpc/connect";
+
+//#region src/api.d.ts
+
+/**
+ * Options for {@link connect}.
+ *
+ * @experimental
+ */
+interface IntegrationClientOptions {
+  /**
+   * Restate ingress URL, e.g. `http://localhost:8080`. `https` selects TLS.
+   */
+  url: string;
+  /**
+   * Bearer token, sent as the `authorization` header of every ingestion stream.
+   */
+  authToken?: string;
+  /**
+   * Identifies the integration to Restate, as `name/version`. Restate records it on
+   * traces and metrics. Longer than 64 bytes, it is truncated.
+   *
+   * Defaults to this client's own identity, `restate-integration-client-ts/<version>`.
+   */
+  integration?: {
+    name: string;
+    version: string;
+  };
+  /**
+   * Connect transport to use instead of opening a new HTTP/2 connection to
+   * {@link IntegrationClientOptions.url}.
+   * The transport remains owned by the caller and {@link IntegrationClient.close} does not
+   * close it.
+   */
+  transport?: Transport;
+}
+/**
+ * Entry point for producing invocations to Restate through the ingestion API.
+ *
+ * @experimental
+ */
+interface IntegrationClient {
+  /**
+   * Creates an at-least-once {@link Producer}. Offsets are assigned automatically, and
+   * records resent on a new stream are not deduplicated: set {@link Invocation.idempotencyKey}
+   * when handler-level deduplication is required.
+   */
+  producer(opts?: ProducerOptions): Producer;
+  /**
+   * Creates an {@link ExactlyOnceProducer}. Restate deduplicates on `(producerId, offset)`, so
+   * choose a producer id that is stable across restarts and distinct per independent offset
+   * sequence, e.g. a Kafka `groupId/topic/partition`.
+   *
+   * @param producerId - stable identity of the producer, non-empty and at most 256 bytes.
+   */
+  exactlyOnceProducer(producerId: string, opts?: ProducerOptions): ExactlyOnceProducer;
+  /**
+   * Closes the HTTP/2 connection opened by this client. Close (or flush) the producers
+   * first when their records must be durably committed.
+   */
+  close(): Promise<void>;
+}
+/**
+ * Invocation fields shared by every record of a producer, see {@link ProducerOptions.defaults}.
+ *
+ * @experimental
+ */
+interface InvocationDefaults {
+  /** Target service name. */
+  service?: string;
+  /** Target handler name. */
+  handler?: string;
+  /** Target key, required when the target is a Virtual Object or a Workflow. */
+  key?: string;
+  /** Invocation scope. */
+  scope?: string;
+  /** Concurrency/rate limit key. */
+  limitKey?: string;
+  /** Headers. A record's own headers are added to these, overriding the same keys. */
+  headers?: Record<string, string>;
+}
+/**
+ * A record to send through a {@link Producer}. Fields set here override the producer
+ * {@link ProducerOptions.defaults}.
+ *
+ * @experimental
+ */
+interface Invocation extends InvocationDefaults {
+  /** Invocation payload. Strings are encoded as UTF-8. */
+  body?: Uint8Array | string;
+  /** Idempotency key used by Restate to deduplicate the invocation. */
+  idempotencyKey?: string;
+  /** Schedule the invocation at this time. */
+  invokeAt?: Date;
+  /** W3C `traceparent`. */
+  traceparent?: string;
+  /** W3C `tracestate`. */
+  tracestate?: string;
+}
+/**
+ * A record to send through an {@link ExactlyOnceProducer}.
+ *
+ * @experimental
+ */
+interface ExactlyOnceInvocation extends Invocation {
+  /**
+   * Position of this record in the source, e.g. a Kafka offset. Must be strictly greater than
+   * the offset of the previous record sent by this producer, and at most
+   * `Number.MAX_SAFE_INTEGER`. Gaps are allowed.
+   */
+  offset: number;
+}
+/**
+ * Options for {@link IntegrationClient.producer} and {@link IntegrationClient.exactlyOnceProducer}.
+ *
+ * @experimental
+ */
+interface ProducerOptions {
+  /**
+   * Fields applied to every record unless the record sets them itself. They are sent
+   * once, when the stream is opened.
+   */
+  defaults?: InvocationDefaults;
+  /**
+   * Maximum combined serialized size of the records waiting to be written to the stream.
+   * While the buffer is full, {@link ProducerBase.send} waits. Zero disables the buffer:
+   * `send` then waits until the record can be written to the stream directly.
+   *
+   * Defaults to 32 MiB.
+   */
+  bufferBytes?: number;
+  /**
+   * Called with the commit watermark every time it advances: every record with an offset up
+   * to and including it is durably committed by Restate. Use it to checkpoint an
+   * exactly-once source.
+   *
+   * If the callback throws, the producer is aborted with the thrown error.
+   */
+  onCommitted?: (offset: number) => void;
+}
+/**
+ * Options for {@link ProducerBase.send}.
+ *
+ * @experimental
+ */
+interface SendOptions {
+  /**
+   * Wait until the record is durably committed by Restate, instead of only until it is
+   * accepted by the producer.
+   */
+  waitCommitted?: boolean;
+}
+/**
+ * Operations shared by {@link Producer} and {@link ExactlyOnceProducer}.
+ *
+ * A producer owns one ingestion stream. Errors are terminal: once the stream fails, every
+ * pending and later operation rejects with the same error, and a new producer is needed.
+ *
+ * @experimental
+ */
+interface ProducerBase<R extends Invocation> {
+  /**
+   * Sends a record.
+   *
+   * The returned promise resolves with the record offset once the producer has accepted the
+   * record into its buffer (or, with `bufferBytes: 0`, written it to the stream), waiting
+   * while the buffer is full. With `waitCommitted`, it resolves once Restate has durably
+   * committed the record instead.
+   *
+   * Always await `send`: calls that are not awaited keep waiting for buffer space without
+   * any bound. Records are sent in call order, so concurrent calls, e.g. with `Promise.all`,
+   * are safe. Note that a record rejected by validation (an oversized record, or a
+   * non-increasing exactly-once offset) rejects only its own call, while the others are
+   * still sent: with an exactly-once producer, validate records before sending them
+   * concurrently, or the commit watermark can move past the rejected offset.
+   */
+  send(record: R, opts?: SendOptions): Promise<number>;
+  /**
+   * Waits until every record sent so far is durably committed.
+   *
+   * @returns the commit watermark, or -1 if nothing was sent.
+   */
+  flush(): Promise<number>;
+  /**
+   * Flushes the producer, then closes its stream.
+   */
+  close(): Promise<void>;
+  /**
+   * Closes the producer immediately, without flushing. Every pending operation rejects
+   * with `reason`.
+   */
+  abort(reason?: unknown): void;
+  /**
+   * A `WritableStream` view of this producer, to pipe a source into it, e.g. with
+   * `ReadableStream.pipeTo` or Node's `stream/promises` `pipeline`. Writing sends the
+   * record, closing the stream closes the producer and aborting it aborts the producer.
+   */
+  readonly writable: WritableStream<R>;
+}
+/**
+ * Sends invocations to Restate with at-least-once delivery.
+ *
+ * @experimental
+ */
+type Producer = ProducerBase<Invocation>;
+/**
+ * Sends invocations to Restate with exactly-once delivery: Restate deduplicates records on
+ * `(producerId, offset)`, across streams and restarts. After a restart, resend from the
+ * last checkpointed offset and Restate drops the records it already committed.
+ *
+ * @experimental
+ */
+interface ExactlyOnceProducer extends ProducerBase<ExactlyOnceInvocation> {
+  /** Stable identity of this producer. */
+  readonly producerId: string;
+}
+//#endregion
+export { ExactlyOnceInvocation, ExactlyOnceProducer, IntegrationClient, IntegrationClientOptions, Invocation, InvocationDefaults, Producer, ProducerBase, ProducerOptions, SendOptions };
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","names":[],"sources":["../src/api.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AAiCA;;AAMoC,UAvCnB,wBAAA,CAuCmB;EAWzB;;;EAOO,GAAA,EAAA,MAAA;EAQD;AAqBjB;;EAMa,SAAA,CAAA,EAAA,MAAA;EANuB;;AAkBpC;AAcA;AA+BA;AAgBA;EAAwC,WAAA,CAAA,EAAA;IAgBzB,IAAA,EAAA,MAAA;IAAU,OAAA,EAAA,MAAA;EAAc,CAAA;EAO5B;;;;;AA0BX;EASiB,SAAA,CAAA,EAtMH,SAsMG;;;;;;;UA9LA,iBAAA;;;;;;kBAMC,kBAAkB;;;;;;;;iDAWzB,kBACN;;;;;WAMM;;;;;;;UAQM,kBAAA;;;;;;;;;;;;YAYL;;;;;;;;UASK,UAAA,SAAmB;;SAE3B;;;;aAII;;;;;;;;;;;UAYI,qBAAA,SAA8B;;;;;;;;;;;;;UAc9B,eAAA;;;;;aAKJ;;;;;;;;;;;;;;;;;;;;;;;UA0BI,WAAA;;;;;;;;;;;;;;;UAgBA,uBAAuB;;;;;;;;;;;;;;;;eAgBzB,UAAU,cAAc;;;;;;WAO5B;;;;WAKA;;;;;;;;;;;qBAaU,eAAe;;;;;;;KAQxB,QAAA,GAAW,aAAa;;;;;;;;UASnB,mBAAA,SAA4B,aAAa"}