@enclave-vm/client 2.19.0 → 2.19.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -6,16 +6,15 @@
6
6
 
7
7
  > Browser and Node.js client SDK for the EnclaveJS streaming runtime
8
8
 
9
- The @enclave-vm/client package provides a client SDK for connecting to EnclaveJS runtime servers from browsers and Node.js applications. It handles connection management, message streaming, and provides a simple API for executing code and handling tool calls.
9
+ The @enclave-vm/client package is a client for an EnclaveJS broker, for browsers and Node.js applications. It sends a script to the broker over HTTP, reads the events of the session as they arrive, and gives you the result.
10
10
 
11
11
  ## Features
12
12
 
13
- - **Cross-Platform**: Works in browsers and Node.js
14
- - **Streaming Support**: Real-time message streaming with backpressure handling
15
- - **Auto-Reconnection**: Automatic reconnection with configurable retry strategy
13
+ - **Cross-Platform**: Works in browsers and Node.js, on top of `fetch`
14
+ - **Streaming Support**: Session events are passed to your handlers as they arrive
15
+ - **Auto-Reconnection**: A lost connection is resumed after the last event received, so every event is delivered once and in order
16
+ - **Cancellation**: Stop a session with its handle, by its id, or with an `AbortSignal`
16
17
  - **Type-Safe**: Full TypeScript support
17
- - **Event-Based**: Rich event system for monitoring execution
18
- - **Encryption Ready**: Built-in support for encrypted channels
19
18
 
20
19
  ## Installation
21
20
 
@@ -34,90 +33,82 @@ import { EnclaveClient } from '@enclave-vm/client';
34
33
 
35
34
  // Create client
36
35
  const client = new EnclaveClient({
37
- url: 'wss://runtime.example.com',
36
+ baseUrl: 'https://api.example.com',
38
37
  });
39
38
 
40
- // Connect and execute code
41
- await client.connect();
42
-
39
+ // Execute code and wait for the result
43
40
  const result = await client.execute(`
44
41
  const user = await callTool('getUser', { id: 123 });
45
42
  return { name: user.name };
46
43
  `);
47
44
 
48
- console.log(result.value); // { name: 'Alice' }
49
-
50
- // Disconnect when done
51
- await client.disconnect();
45
+ if (result.success) {
46
+ console.log(result.value); // what the script returned
47
+ } else {
48
+ console.error(result.error?.code, result.error?.message);
49
+ }
52
50
  ```
53
51
 
52
+ Tools run on the broker. The client is told about tool calls (`onToolCall`, `onToolResultApplied`), but it executes nothing and has no API to register tools.
53
+
54
54
  ## Event Handling
55
55
 
56
- Listen to execution events:
56
+ Pass handlers with the options of `execute()` or `executeStream()`:
57
57
 
58
58
  ```typescript
59
59
  import { EnclaveClient } from '@enclave-vm/client';
60
60
 
61
- const client = new EnclaveClient({ url: 'wss://runtime.example.com' });
62
-
63
- client.on('connected', () => {
64
- console.log('Connected to runtime');
65
- });
66
-
67
- client.on('disconnected', (reason) => {
68
- console.log('Disconnected:', reason);
69
- });
61
+ const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
70
62
 
71
- client.on('tool_call', (call) => {
72
- console.log(`Tool called: ${call.name}`, call.args);
73
- });
74
-
75
- client.on('tool_result', (result) => {
76
- console.log(`Tool result:`, result.data);
77
- });
78
-
79
- client.on('error', (error) => {
80
- console.error('Error:', error);
81
- });
82
-
83
- client.on('log', (log) => {
84
- console.log(`[${log.level}]`, ...log.args);
63
+ const result = await client.execute(code, {
64
+ onSessionInit: (event) => {
65
+ console.log('Session started:', event.sessionId);
66
+ },
67
+ onStdout: (chunk) => {
68
+ process.stdout.write(chunk);
69
+ },
70
+ onLog: (level, message, data) => {
71
+ console.log(`[${level}]`, message, data);
72
+ },
73
+ onToolCall: (callId, toolName, args) => {
74
+ console.log(`Tool called: ${toolName}`, args);
75
+ },
76
+ onToolResultApplied: (callId) => {
77
+ console.log(`Tool result applied: ${callId}`);
78
+ },
79
+ onError: (errorCode, message) => {
80
+ console.error(`${errorCode}: ${message}`);
81
+ },
85
82
  });
86
83
  ```
87
84
 
85
+ The handlers are `onEvent` (every event), `onSessionInit`, `onStdout`, `onLog`, `onToolCall`, `onToolResultApplied`, `onHeartbeat`, `onError`, `onPartialResult`, `onToolProgress`, `onDeadlineExceeded` and `onCatalogChanged`. The end of the session has no handler of its own: the result comes from the promise of `execute()`, or from `wait()` on the handle.
86
+
88
87
  ## Streaming Execution
89
88
 
90
- Handle streaming responses:
89
+ `executeStream()` returns a handle for the running session at once:
91
90
 
92
91
  ```typescript
93
92
  import { EnclaveClient } from '@enclave-vm/client';
94
93
 
95
- const client = new EnclaveClient({ url: 'wss://runtime.example.com' });
96
- await client.connect();
94
+ const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
97
95
 
98
- // Stream execution with callbacks
99
- await client.stream(
100
- `
101
- for (const id of [1, 2, 3]) {
102
- const user = await callTool('getUser', { id });
103
- yield user;
104
- }
105
- return 'done';
106
- `,
107
- {
108
- onYield: (value) => {
109
- console.log('Yielded:', value);
110
- },
111
- onComplete: (result) => {
112
- console.log('Completed:', result);
113
- },
114
- onError: (error) => {
115
- console.error('Error:', error);
116
- },
96
+ const session = client.executeStream(code, {
97
+ onStdout: (chunk) => {
98
+ process.stdout.write(chunk);
117
99
  },
118
- );
100
+ });
101
+
102
+ console.log('Session ID:', session.sessionId);
103
+ console.log('Active:', session.isActive());
104
+ console.log('Events so far:', session.getEvents().length);
105
+
106
+ // Wait for the result
107
+ const result = await session.wait();
119
108
  ```
120
109
 
110
+ `await client.execute(code, options)` is the same as `await client.executeStream(code, options).wait()`.
111
+
121
112
  ## Configuration Options
122
113
 
123
114
  ```typescript
@@ -125,118 +116,165 @@ import { EnclaveClient } from '@enclave-vm/client';
125
116
 
126
117
  const client = new EnclaveClient({
127
118
  // Connection
128
- url: 'wss://runtime.example.com',
129
- protocols: ['enclavejs-v1'],
130
-
131
- // Authentication
132
- auth: {
133
- token: 'your-api-token',
134
- // or
135
- apiKey: 'your-api-key',
136
- },
119
+ baseUrl: 'https://api.example.com',
137
120
 
138
- // Reconnection
139
- reconnect: {
140
- enabled: true,
141
- maxAttempts: 5,
142
- initialDelay: 1000,
143
- maxDelay: 30000,
121
+ // Headers sent with every request (for example credentials)
122
+ headers: {
123
+ Authorization: 'Bearer your-api-token',
144
124
  },
145
125
 
146
- // Encryption
147
- encryption: {
148
- enabled: true,
149
- // Key exchange happens automatically
150
- },
126
+ // Waiting for the server
127
+ timeout: 60000,
151
128
 
152
- // Timeouts
153
- timeout: 30000, // Execution timeout
154
- connectionTimeout: 10000,
129
+ // Reconnection
130
+ autoReconnect: true,
131
+ maxReconnectAttempts: 3,
132
+ reconnectDelay: 1000,
155
133
 
156
- // Debug
157
- debug: true,
134
+ // Largest event accepted
135
+ maxEventLength: 8388608,
158
136
  });
159
137
  ```
160
138
 
139
+ | Option | Default | Description |
140
+ | ---------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
141
+ | `baseUrl` | Required | Base URL of the broker |
142
+ | `headers` | none | Headers sent with every request |
143
+ | `timeout` | `60000` | How long the client waits for the server, in milliseconds: for the answer to a request, and for the next event on an open stream (there, never less than two heartbeat intervals). When it runs out the connection counts as lost. |
144
+ | `autoReconnect` | `true` | Reconnect when the connection is lost |
145
+ | `maxReconnectAttempts` | `3` | Reconnection attempts in a row before the session fails |
146
+ | `reconnectDelay` | `1000` | Base delay before a reconnection attempt, in milliseconds; it grows with each attempt in a row |
147
+ | `maxEventLength` | `8388608` | Largest event the client accepts, in characters (8 MiB). A longer event ends the session with `PARSE_ERROR`. |
148
+ | `fetch` | global `fetch` | Custom fetch implementation. Required where there is no global `fetch`. |
149
+
150
+ These are all the options. Any other option makes the constructor throw a `TypeError` that names it: the client has no `encryption`, `auth`, `serverUrl` or `reconnect` option. A value the client cannot use, such as a `timeout` of `0`, throws as well.
151
+
152
+ The client does not encrypt. Requests and events travel as plain JSON over HTTP and are protected only by the transport: use an `https:` base URL, and send credentials with `headers`.
153
+
161
154
  ## Session Management
162
155
 
156
+ Every execution is a session with an id that starts with `s_`. The client generates the id unless you pass one with the `sessionId` option; an id that does not start with `s_` is refused before a request is made.
157
+
163
158
  ```typescript
164
159
  import { EnclaveClient } from '@enclave-vm/client';
165
160
 
166
- const client = new EnclaveClient({ url: 'wss://runtime.example.com' });
167
- await client.connect();
161
+ const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
168
162
 
169
- // Create a persistent session
170
- const session = await client.createSession({
171
- timeout: 60000,
172
- maxToolCalls: 100,
173
- metadata: { userId: 'user_123' },
163
+ const session = client.executeStream(code, {
164
+ // Limits requested for the session
165
+ limits: {
166
+ sessionTtlMs: 60000,
167
+ maxToolCalls: 100,
168
+ },
174
169
  });
175
170
 
176
- console.log('Session ID:', session.id);
171
+ console.log('Session ID:', session.sessionId);
177
172
 
178
- // Execute within session
179
- const result1 = await client.execute('const x = 1; return x;', { sessionId: session.id });
180
- const result2 = await client.execute('return x + 1;', { sessionId: session.id }); // x is still available
173
+ // Ask the broker about the session (null if it does not know the session)
174
+ const info = await client.getSession(session.sessionId);
175
+ console.log(info?.state, info?.stats.toolCallCount);
181
176
 
182
- // Destroy session when done
183
- await client.destroySession(session.id);
177
+ // Cancel the session
178
+ await session.cancel('User cancelled');
179
+ // or: await client.cancelSession(session.sessionId, 'User cancelled');
180
+
181
+ const result = await session.wait();
182
+ console.log(result.error?.code); // 'CANCELLED'
184
183
  ```
185
184
 
185
+ `cancel()`, `cancelSession()` and aborting the `signal` option all do the same: the session ends in the client as `CANCELLED`, and the broker is asked to end it with `DELETE {baseUrl}/sessions/:sessionId`. They do not reject. If the broker does not confirm the stop, `onError` is called with the code `CANCEL_FAILED`: the script may still be running.
186
+
186
187
  ## Error Handling
187
188
 
188
- ```typescript
189
- import { EnclaveClient, EnclaveError, TimeoutError, ValidationError } from '@enclave-vm/client';
189
+ A session that fails is not a rejected promise. `execute()` and `wait()` resolve with `success: false` and an `error`:
190
190
 
191
- const client = new EnclaveClient({ url: 'wss://runtime.example.com' });
191
+ ```typescript
192
+ import { EnclaveClient, EnclaveClientError } from '@enclave-vm/client';
193
+
194
+ const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
195
+
196
+ const result = await client.execute(code);
197
+
198
+ if (!result.success) {
199
+ switch (result.error?.code) {
200
+ case 'CANCELLED':
201
+ console.error('Execution was cancelled');
202
+ break;
203
+ case 'TIMEOUT':
204
+ console.error('The broker did not answer in time');
205
+ break;
206
+ case 'NETWORK_ERROR':
207
+ case 'RECONNECT_FAILED':
208
+ console.error('Connection lost:', result.error?.message);
209
+ break;
210
+ default:
211
+ console.error('Execution failed:', result.error?.code, result.error?.message);
212
+ }
213
+ }
192
214
 
215
+ // getSession() is the one method that rejects, with an EnclaveClientError
193
216
  try {
194
- await client.connect();
195
- const result = await client.execute('invalid code {{{{');
217
+ const info = await client.getSession(result.sessionId);
218
+ console.log(info?.state);
196
219
  } catch (error) {
197
- if (error instanceof ValidationError) {
198
- console.error('Code validation failed:', error.issues);
199
- } else if (error instanceof TimeoutError) {
200
- console.error('Execution timed out');
201
- } else if (error instanceof EnclaveError) {
202
- console.error('Enclave error:', error.code, error.message);
220
+ if (error instanceof EnclaveClientError) {
221
+ console.error('Enclave client error:', error.code, error.message);
203
222
  } else {
204
223
  throw error;
205
224
  }
206
225
  }
207
226
  ```
208
227
 
228
+ `error.code` is one of the client's codes, or the code that the broker sent with the end of the session:
229
+
230
+ | Code | Meaning |
231
+ | ------------------ | ------------------------------------------------------------------------------------------------------------------ |
232
+ | `CANCELLED` | The session was cancelled with `cancel()`, `cancelSession()` or the `signal` |
233
+ | `TIMEOUT` | The broker did not answer, or sent no event, within the time the client waits |
234
+ | `NETWORK_ERROR` | A request failed, or the stream ended before the session was complete |
235
+ | `PARSE_ERROR` | The answer cannot be read: an event longer than `maxEventLength`, an encrypted event, or a response without a body |
236
+ | `SESSION_ERROR` | The broker refused to start the session, the session id is not valid, or the id is already running on this client |
237
+ | `RECONNECT_FAILED` | The broker refused a reconnection |
238
+
239
+ When the connection is lost and `autoReconnect` is on, the client reconnects first. If the attempts are used up, the session fails with the code of the last failure.
240
+
209
241
  ## Browser Usage
210
242
 
211
- ```html
212
- <script type="module">
213
- import { EnclaveClient } from 'https://esm.sh/@enclave-vm/client';
243
+ In the browser the client uses the global `fetch`:
244
+
245
+ ```typescript
246
+ import { EnclaveClient } from '@enclave-vm/client';
214
247
 
215
- const client = new EnclaveClient({
216
- url: 'wss://runtime.example.com',
217
- });
248
+ const client = new EnclaveClient({
249
+ baseUrl: 'https://api.example.com',
250
+ });
218
251
 
219
- async function runCode() {
220
- await client.connect();
221
- const result = await client.execute(`
252
+ async function runCode() {
253
+ const result = await client.execute(
254
+ `
222
255
  const data = await callTool('fetchData', { url: '/api/users' });
223
256
  return data;
224
- `);
225
- console.log(result);
226
- }
257
+ `,
258
+ {
259
+ onStdout: (chunk) => {
260
+ document.body.append(chunk);
261
+ },
262
+ },
263
+ );
264
+ console.log(result);
265
+ }
227
266
 
228
- runCode();
229
- </script>
267
+ runCode();
230
268
  ```
231
269
 
232
270
  ## Related Packages
233
271
 
234
- | Package | Description |
235
- | ------------------------------------------- | --------------------------------- |
236
- | [@enclave-vm/types](../enclavejs-types) | Type definitions and Zod schemas |
237
- | [@enclave-vm/stream](../enclavejs-stream) | Streaming protocol implementation |
238
- | [@enclave-vm/react](../enclavejs-react) | React hooks and components |
239
- | [@enclave-vm/runtime](../enclavejs-runtime) | Standalone runtime worker |
272
+ | Package | Description |
273
+ | --------------------------------- | ------------------------------------------------------- |
274
+ | [@enclave-vm/types](../types) | Type definitions and Zod schemas |
275
+ | [@enclave-vm/stream](../stream) | Streaming protocol implementation |
276
+ | [@enclave-vm/react](../react) | React hooks and components |
277
+ | [@enclave-vm/runtime](../runtime) | Runtime worker building blocks (not a runnable service) |
240
278
 
241
279
  ## License
242
280
 
package/client.d.ts CHANGED
@@ -25,6 +25,9 @@ export declare class EnclaveClient {
25
25
  private readonly activeSessions;
26
26
  /**
27
27
  * Create a new EnclaveClient instance.
28
+ *
29
+ * @throws TypeError when the configuration has an option this client does not implement
30
+ * (for example `encryption` or `auth`) or a value it cannot use
28
31
  */
29
32
  constructor(config: EnclaveClientConfig);
30
33
  /**
@@ -59,16 +62,52 @@ export declare class EnclaveClient {
59
62
  getSession(sessionId: SessionId): Promise<SessionInfo | null>;
60
63
  /**
61
64
  * Cancel a running session.
65
+ *
66
+ * The session of this client ends as `CANCELLED`, and the server is asked to end the session
67
+ * (`DELETE /sessions/:sessionId`). When the server does not confirm that, the session's
68
+ * `onError` handler is called with the code `CANCEL_FAILED`: the script may still be running.
62
69
  */
63
70
  cancelSession(sessionId: SessionId, reason?: string): Promise<void>;
71
+ /**
72
+ * End a session of this client as cancelled and ask the server to end it too.
73
+ * Never rejects.
74
+ */
75
+ private stopSession;
64
76
  /**
65
77
  * Start a session and begin streaming events.
66
78
  */
67
79
  private startSession;
80
+ /**
81
+ * Attempt to reconnect a session.
82
+ */
83
+ private reconnectSession;
84
+ /**
85
+ * Open a connection for a session and follow its stream until the session ends or the
86
+ * connection is lost. A session has one connection at a time: the previous one is closed
87
+ * first, and nothing that still arrives on it is delivered.
88
+ */
89
+ private runConnection;
68
90
  /**
69
91
  * Stream and parse the NDJSON response.
70
92
  */
71
93
  private streamResponse;
94
+ /**
95
+ * (Re)start the timer of a connection. When it runs out the connection counts as lost.
96
+ */
97
+ private watch;
98
+ /**
99
+ * Whether a connection is the one its session is using.
100
+ */
101
+ private isCurrent;
102
+ /**
103
+ * Close the connection of a session, if it has one.
104
+ */
105
+ private closeConnection;
106
+ /**
107
+ * A connection failed, ended early or went silent: reconnect if that is allowed, otherwise
108
+ * the session fails. A connection that is no longer the session's own is ignored.
109
+ */
110
+ private connectionLost;
72
111
  /**
73
112
  * Handle a received stream event.
74
113
  */
@@ -78,17 +117,24 @@ export declare class EnclaveClient {
78
117
  */
79
118
  private handleFinalEvent;
80
119
  /**
81
- * Handle a session error.
120
+ * End a session with an error.
82
121
  */
83
- private handleSessionError;
122
+ private failSession;
84
123
  /**
85
- * Complete a session and clean up.
124
+ * End a session that was never requested from the server.
86
125
  */
87
- private completeSession;
126
+ private refuseSession;
88
127
  /**
89
- * Attempt to reconnect a session.
128
+ * Give a session its result and clean up. The first result is the only one.
90
129
  */
91
- private reconnectSession;
130
+ private endSession;
131
+ private cancelledResult;
132
+ private statsOf;
133
+ /**
134
+ * Run a request that is not a session stream, bounded by the configured timeout.
135
+ * The promise settles at the deadline even when the request does not react to its signal.
136
+ */
137
+ private withDeadline;
92
138
  /**
93
139
  * Build request headers.
94
140
  */
package/client.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAA0C,MAAM,mBAAmB,CAAC;AAkB3F,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAC;AAgCpB;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IACF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuC;IAEtE;;OAEG;gBACS,MAAM,EAAE,mBAAmB;IAevC;;;;;;;;;;OAUG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAc,GAAG,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IAKxG;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAc,GAAG,oBAAyB,GAAG,aAAa;IAqF/F;;OAEG;IACG,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IA4BnE;;OAEG;IACG,aAAa,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwCzE;;OAEG;YACW,YAAY;IAwD1B;;OAEG;YACW,cAAc;IA2B5B;;OAEG;IACH,OAAO,CAAC,WAAW;IAoDnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAoCxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA6B1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;YACW,gBAAgB;IA0C9B;;OAEG;IACH,OAAO,CAAC,YAAY;CAKrB"}
1
+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAA0C,MAAM,mBAAmB,CAAC;AA0B3F,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAC;AA+KpB;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IACF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuC;IAEtE;;;;;OAKG;gBACS,MAAM,EAAE,mBAAmB;IAIvC;;;;;;;;;;OAUG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAc,GAAG,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IAKxG;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAc,GAAG,oBAAyB,GAAG,aAAa;IAuF/F;;OAEG;IACG,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAmCnE;;;;;;OAMG;IACG,aAAa,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASzE;;;OAGG;YACW,WAAW;IA0CzB;;OAEG;YACW,YAAY;IAsC1B;;OAEG;YACW,gBAAgB;IA0B9B;;;;OAIG;YACW,aAAa;IA0B3B;;OAEG;YACW,cAAc;IA2B5B;;OAEG;IACH,OAAO,CAAC,KAAK;IAUb;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;;OAGG;IACH,OAAO,CAAC,cAAc;IA0BtB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmEnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,OAAO;IAQf;;;OAGG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,YAAY;CAKrB"}