@gobing-ai/ts-infra 0.1.0

package/README.md

@@ -0,0 +1,389 @@
+# @gobing-ai/ts-infra
+
+Infrastructure backbone — typed event bus, job queue (types), cron scheduler, OpenTelemetry telemetry, HTTP API client, and structured logging. Designed to be wired together at bootstrap via `RuntimeContext`.
+
+## Overview
+
+`ts-infra` provides seven subsystems that form the application backbone:
+
+| Subsystem | Module | Purpose |
+|-----------|--------|---------|
+| **Event Bus** | `event-bus/` | Typed pub/sub with sync + async dispatch, lifecycle self-observability |
+| **Events** | `events/` | Typed event map pattern + system bus factory |
+| **Job Queue** | `job-queue/` | Types for DB-backed job processing (`JobQueue`, `QueueConsumer`, `Job`) |
+| **Scheduler** | `scheduler/` | Cron-like scheduled actions — Node (interval), Cloudflare (Cron Triggers), Noop (test) |
+| **Telemetry** | `telemetry/` | OpenTelemetry SDK wrapper — tracing (`traceAsync`), metrics (17 instruments), SQL sanitizer |
+| **API Client** | `api-client.ts` | Typed HTTP client with OTel tracing, retry, timeout, error handling |
+| **Logger** | `logger.ts` | Structured JSON logger with levels, child loggers, and mute toggle |
+
+## Architecture
+
+```mermaid
+classDiagram
+    namespace event-bus {
+        class EventBus~TEvents~ {
+            +on(event, handler, opts?) void
+            +once(event, handler, opts?) void
+            +off(event, handler) void
+            +emit(event, ...args) Promise~void~
+            +removeAllListeners(event?) void
+            +listenerCount(event) number
+            +eventNames() string[]
+        }
+    }
+
+    namespace events {
+        class EventFactory {
+            +createSystemBus() EventBus
+        }
+    }
+
+    namespace job-queue {
+        class JobQueue~T~ {
+            <<interface>>
+            +enqueue(type, payload, opts?) Promise~string~
+            +enqueueBatch(jobs) Promise~string[]~
+        }
+        class QueueConsumer~T~ {
+            <<interface>>
+            +register(type, handler) void
+            +start() Promise~void~
+            +stop() Promise~void~
+            +stats() Promise~QueueStats~
+        }
+        class Job~T~ {
+            <<interface>>
+        }
+        class QueueStats {
+            <<interface>>
+        }
+    }
+
+    namespace scheduler {
+        class SchedulerAdapter {
+            <<interface>>
+            +register(cron, action) void
+            +start() Promise~void~
+            +stop() Promise~void~
+        }
+        class NodeSchedulerAdapter {
+        }
+        class CloudflareSchedulerAdapter {
+        }
+        class NoopSchedulerAdapter {
+        }
+        class SchedulerFactory {
+            +initScheduler(cronEntries?) SchedulerAdapter
+            +setSchedulerAdapter(adapter) void
+            +getSchedulerAdapter() SchedulerAdapter
+        }
+    }
+
+    namespace telemetry {
+        class TelemetrySDK {
+            +initTelemetry(config?) void
+            +shutdownTelemetry() Promise~void~
+            +getTracer() Tracer
+        }
+        class Tracing {
+            +traceAsync~T~(name, fn) Promise~T~
+            +traceSync~T~(name, fn) T
+            +addSpanAttributes(attrs) void
+            +getActiveSpan() Span
+        }
+        class Metrics {
+            +getHttpServerRequestTotal() Counter
+            +getHttpServerRequestDuration() Histogram
+            +getDbOperationTotal() Counter
+            +getQueueJobEnqueuedTotal() Counter
+            +getSchedulerJobExecutedTotal() Counter
+        }
+        class DbSanitize {
+            +sanitizeSql(sql) string
+            +extractSqlOperation(sql) string
+        }
+    }
+
+    namespace api-client {
+        class APIClient {
+            +get~T~(path, opts?) Promise~T~
+            +post~T~(path, body?, opts?) Promise~T~
+            +put~T~(path, body?, opts?) Promise~T~
+            +delete~T~(path, opts?) Promise~T~
+        }
+        class APIError {
+            +number status
+            +string body
+        }
+    }
+
+    namespace logger {
+        class Logger {
+            <<interface>>
+            +trace(msg, data?) void
+            +debug(msg, data?) void
+            +info(msg, data?) void
+            +warn(msg, data?) void
+            +error(msg, data?) void
+            +fatal(msg, data?) void
+            +child(context) Logger
+        }
+        class LoggerFactory {
+            +getLogger(category) Logger
+            +initializeLogger(level) void
+        }
+    }
+
+    SchedulerAdapter <|.. NodeSchedulerAdapter : implements
+    SchedulerAdapter <|.. CloudflareSchedulerAdapter : implements
+    SchedulerAdapter <|.. NoopSchedulerAdapter : implements
+    SchedulerFactory --> NodeSchedulerAdapter
+    SchedulerFactory --> CloudflareSchedulerAdapter
+    SchedulerFactory --> NoopSchedulerAdapter
+    EventBus --> JobQueue : "async dispatch"
+    EventBus --> Logger : "self-observability"
+    APIClient --> Tracing : "traceAsync"
+    APIClient --> Metrics : "counters + histograms"
+```
+
+## How It Works
+
+### Event Bus — typed pub/sub
+
+```ts
+import { EventBus, type EventMap } from '@gobing-ai/ts-infra';
+
+// Define your event map
+type AppEvents = {
+    'user.signed_up': (email: string, plan: string) => void;
+    'order.placed': (orderId: string, total: number) => void;
+};
+
+const bus = new EventBus<AppEvents>();
+
+// Sync handler (runs in-process immediately)
+bus.on('user.signed_up', (email, plan) => {
+    console.log(`Welcome ${email} on ${plan} plan!`);
+});
+
+// Async handler (runs through the async handler path)
+bus.on('order.placed', (orderId) => {
+    console.log(`Order placed: ${orderId}`);
+}, { async: true });
+
+// Emit
+await bus.emit('user.signed_up', 'alice@test.com', 'pro');
+// → "Welcome alice@test.com on pro plan!"
+
+// Once (auto-removes after first emit)
+bus.once('user.signed_up', () => console.log('one-time'));
+```
+
+**Lifecycle events** — inject a second `EventBus` to observe bus internals:
+
+```ts
+const lifecycleBus = new EventBus<BusLifecycleEvents>();
+lifecycleBus.on('bus.emit.done', (detail) => {
+    // { event, syncCount, asyncCount, emitDurationMs, errors }
+    metrics.recordEmit(detail);
+});
+
+const bus = new EventBus<AppEvents>({ lifecycleBus });
+```
+
+### Scheduler — cron-like actions
+
+```ts
+import { NodeSchedulerAdapter, initScheduler } from '@gobing-ai/ts-infra';
+
+// Node.js (interval-based)
+const scheduler = new NodeSchedulerAdapter();
+scheduler.register('60000', async () => {
+    console.log('Runs every 60 seconds');
+});
+scheduler.register('*/5 * * * *', async () => {
+    console.log('Runs every 5 minutes');
+});
+await scheduler.start();
+
+// Or use factory
+const sched = initScheduler([
+    ['300000', async () => cleanupExpiredSessions()],
+    ['3600000', async () => generateReports()],
+]);
+await sched.start();
+
+// Cloudflare Workers
+import { CloudflareSchedulerAdapter } from '@gobing-ai/ts-infra';
+const cfScheduler = new CloudflareSchedulerAdapter();
+cfScheduler.register('* * * * *', async () => { /* ... */ });
+
+export default {
+    async scheduled(event, env, ctx) {
+        cfScheduler.handleScheduledEvent(event, ctx);
+    },
+};
+```
+
+### API Client — typed HTTP with tracing
+
+```ts
+import { APIClient, APIError } from '@gobing-ai/ts-infra';
+
+const api = new APIClient({
+    baseUrl: 'https://api.example.com',
+    defaultHeaders: { Authorization: `Bearer ${token}` },
+    timeout: 10_000,
+});
+
+// Typed response — spans are auto-created
+const user = await api.get<{ id: string; name: string }>('/users/me');
+
+try {
+    await api.post('/orders', { productId: 'p1', quantity: 2 });
+} catch (error) {
+    if (error instanceof APIError) {
+        console.error(`HTTP ${error.status}: ${error.body}`);
+    }
+}
+
+// Custom operation name for tracing
+const items = await api.get<Item[]>('/items', { operationName: 'inventory.list' });
+```
+
+The client auto-instruments every request: creates a `CLIENT` span, records method/URL/status attributes, emits request count + duration metrics, and records errors.
+
+### Logger — structured JSON
+
+```ts
+import { getLogger, initializeLogger } from '@gobing-ai/ts-infra';
+
+initializeLogger('debug'); // set minimum level
+
+const log = getLogger('auth');
+log.info('User logged in', { userId: 'u1', method: 'password' });
+// → {"level":"info","message":"User logged in",...,"category":"auth","userId":"u1"}
+
+// Child loggers carry context
+const reqLog = log.child({ requestId: 'req-123' });
+reqLog.error('Validation failed', { field: 'email' });
+// → {...,"category":"auth","requestId":"req-123","field":"email"}
+
+// Mute during tests
+import { setLoggerMuted } from './logger.js'; // internal import
+setLoggerMuted(true);
+```
+
+### Telemetry — OpenTelemetry
+
+```ts
+import {
+    initTelemetry, shutdownTelemetry,
+    traceAsync, addSpanAttributes, getActiveSpan,
+    sanitizeSql,
+} from '@gobing-ai/ts-infra';
+
+// Initialize at startup
+initTelemetry({
+    enabled: true,
+    serviceName: 'my-api',
+    environment: 'production',
+    exporterEndpoint: 'http://otel-collector:4318/v1/traces',
+});
+
+// Trace an operation
+const result = await traceAsync('db.query', async (span) => {
+    addSpanAttributes({ 'db.system': 'sqlite', 'db.operation': 'SELECT' });
+    return db.select().from(users);
+});
+
+// Sanitize SQL before export
+const safe = sanitizeSql("SELECT * FROM users WHERE email = 'alice@test.com'");
+// → "SELECT * FROM users WHERE email = ?"
+
+// Shutdown gracefully
+process.on('SIGTERM', async () => {
+    await shutdownTelemetry();
+});
+```
+
+Metrics are lazy-initialized — no configuration needed beyond `initTelemetry()`:
+
+```ts
+import { getQueueJobEnqueuedTotal, getQueueJobProcessingDuration } from '@gobing-ai/ts-infra';
+
+getQueueJobEnqueuedTotal().add(1, { 'queue.job_type': 'send-email' });
+getQueueJobProcessingDuration().record(42, { 'queue.job_type': 'send-email' });
+```
+
+## Usage
+
+### Install
+
+```bash
+bun add @gobing-ai/ts-infra @gobing-ai/ts-runtime @gobing-ai/ts-db
+```
+
+### Full bootstrap example
+
+```ts
+import { createRuntimeContext } from '@gobing-ai/ts-runtime';
+import { createDbAdapter, applyMigrations } from '@gobing-ai/ts-db';
+import {
+    EventBus,
+    NodeSchedulerAdapter,
+    initTelemetry,
+    APIClient,
+    getLogger,
+    initializeLogger,
+} from '@gobing-ai/ts-infra';
+
+// 1. Runtime
+const ctx = createRuntimeContext({ runtimeName: 'node-bun' });
+
+// 2. Database
+const db = await createDbAdapter({ driver: 'bun-sqlite', url: './data/app.db' });
+await applyMigrations(db);
+ctx.register('db', db);
+
+// 3. Logging
+initializeLogger('info');
+const log = getLogger('app');
+
+// 4. Telemetry
+initTelemetry({ serviceName: 'my-app', environment: 'production' });
+
+// 5. Event bus
+const bus = new EventBus<AppEvents>();
+
+// 6. Scheduler
+const scheduler = new NodeSchedulerAdapter();
+scheduler.register('3600000', async () => {
+    log.info('Hourly cleanup running');
+});
+await scheduler.start();
+
+// 7. API client
+const stripeApi = new APIClient({
+    baseUrl: 'https://api.stripe.com/v1',
+    defaultHeaders: { Authorization: `Bearer ${process.env.STRIPE_KEY}` },
+});
+
+log.info('Application started');
+```
+
+### Graceful shutdown
+
+```ts
+async function shutdown() {
+    log.info('Shutting down...');
+    await scheduler.stop();
+    db.close();
+    await shutdownTelemetry();
+    await ctx.dispose();
+    process.exit(0);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+```

package/dist/api-client.d.ts

@@ -0,0 +1,31 @@
+export interface APIClientConfig {
+    baseUrl: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+    fetch?: typeof globalThis.fetch;
+}
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+    operationName?: string;
+    signal?: AbortSignal;
+}
+export declare class APIError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string);
+}
+export declare class APIClient {
+    private readonly baseUrl;
+    private readonly defaultHeaders;
+    private readonly timeout;
+    private readonly fetchFn;
+    constructor(config: APIClientConfig);
+    private buildUrl;
+    private request;
+    get<T>(path: string, opts?: RequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
+    delete<T>(path: string, opts?: RequestOptions): Promise<T>;
+}
+//# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../src/api-client.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,eAAe;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAED,qBAAa,QAAS,SAAQ,KAAK;aAEX,MAAM,EAAE,MAAM;aACd,IAAI,EAAE,MAAM;gBADZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM;CAKnC;AAID,qBAAa,SAAS;IAClB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyB;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;gBAEtC,MAAM,EAAE,eAAe;IAOnC,OAAO,CAAC,QAAQ;YAIF,OAAO;IAqFf,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAIvD,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAIxE,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAIvE,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;CAGnE"}

package/dist/api-client.js

@@ -0,0 +1,112 @@
+/**
+ * Typed HTTP client builder wrapping fetch with OTel tracing.
+ */
+import { SpanKind } from '@opentelemetry/api';
+import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL, } from '@opentelemetry/semantic-conventions';
+import { getHttpClientRequestDuration, getHttpClientRequestErrors, getHttpClientRequestTotal, } from './telemetry/metrics.js';
+import { traceAsync } from './telemetry/tracing.js';
+export class APIError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`HTTP ${status}: ${body.slice(0, 200)}`);
+        this.status = status;
+        this.body = body;
+        this.name = 'APIError';
+    }
+}
+// ── Client ──────────────────────────────────────────────────────────
+export class APIClient {
+    baseUrl;
+    defaultHeaders;
+    timeout;
+    fetchFn;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/+$/, '');
+        this.defaultHeaders = config.defaultHeaders ?? {};
+        this.timeout = config.timeout ?? 30_000;
+        this.fetchFn = config.fetch ?? globalThis.fetch;
+    }
+    buildUrl(path) {
+        return `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    }
+    async request(method, path, body, opts) {
+        const url = this.buildUrl(path);
+        const headers = {
+            'Content-Type': 'application/json',
+            ...this.defaultHeaders,
+            ...opts?.headers,
+        };
+        const operationName = opts?.operationName ?? `HTTP ${method} ${url}`;
+        return traceAsync(operationName, async (span) => {
+            span.setAttribute(ATTR_HTTP_REQUEST_METHOD, method);
+            span.setAttribute(ATTR_URL_FULL, url);
+            const controller = new AbortController();
+            const timeoutMs = opts?.timeout ?? this.timeout;
+            let timer;
+            if (timeoutMs > 0) {
+                timer = setTimeout(() => controller.abort(), timeoutMs);
+            }
+            const combinedSignal = opts?.signal
+                ? AbortSignal.any([opts.signal, controller.signal])
+                : controller.signal;
+            try {
+                const start = performance.now();
+                const response = await this.fetchFn(url, {
+                    method,
+                    headers,
+                    body: body !== undefined ? JSON.stringify(body) : undefined,
+                    signal: combinedSignal,
+                });
+                if (timer)
+                    clearTimeout(timer);
+                span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+                getHttpClientRequestTotal().add(1, {
+                    'http.request.method': method,
+                    'http.response.status_code': response.status,
+                });
+                const duration = performance.now() - start;
+                getHttpClientRequestDuration().record(duration, {
+                    'http.request.method': method,
+                    'http.response.status_code': response.status,
+                });
+                if (!response.ok) {
+                    const text = await response.text();
+                    getHttpClientRequestErrors().add(1, {
+                        'http.request.method': method,
+                        'error.type': `HTTP_${response.status}`,
+                    });
+                    throw new APIError(response.status, text);
+                }
+                const contentType = response.headers.get('content-type') ?? '';
+                if (contentType.includes('application/json')) {
+                    return (await response.json());
+                }
+                return (await response.text());
+            }
+            catch (error) {
+                if (timer)
+                    clearTimeout(timer);
+                if (!(error instanceof APIError)) {
+                    getHttpClientRequestErrors().add(1, {
+                        'http.request.method': method,
+                        'error.type': error instanceof Error ? error.name : 'Unknown',
+                    });
+                }
+                throw error;
+            }
+        }, { kind: SpanKind.CLIENT });
+    }
+    async get(path, opts) {
+        return this.request('GET', path, undefined, opts);
+    }
+    async post(path, body, opts) {
+        return this.request('POST', path, body, opts);
+    }
+    async put(path, body, opts) {
+        return this.request('PUT', path, body, opts);
+    }
+    async delete(path, opts) {
+        return this.request('DELETE', path, undefined, opts);
+    }
+}

package/dist/event-bus/event-bus.d.ts

@@ -0,0 +1,33 @@
+import type { JobQueue } from '../job-queue/types';
+import type { BusLifecycleEvents, EventMap, SubscribeOptions } from './types';
+/**
+ * Type-safe event bus supporting both synchronous (in-process) and
+ * asynchronous handlers with optional job-queue enqueue instrumentation.
+ */
+export declare class EventBus<TEvents extends EventMap> {
+    private readonly syncHandlers;
+    private readonly asyncHandlers;
+    private readonly asyncHandlerIds;
+    private readonly jobQueue;
+    private readonly lifecycleBus;
+    private nextAsyncHandlerId;
+    constructor(opts?: {
+        jobQueue?: JobQueue;
+        lifecycleBus?: EventBus<BusLifecycleEvents>;
+    });
+    on<K extends keyof TEvents>(event: K, handler: TEvents[K], opts?: SubscribeOptions): void;
+    once<K extends keyof TEvents>(event: K, handler: TEvents[K], opts?: SubscribeOptions): void;
+    off<K extends keyof TEvents>(event: K, handler: TEvents[K]): void;
+    removeAllListeners<K extends keyof TEvents>(event?: K): void;
+    emit<K extends keyof TEvents>(event: K, ...args: Parameters<TEvents[K]>): Promise<void>;
+    listenerCount<K extends keyof TEvents>(event: K, mode?: 'sync' | 'async'): number;
+    eventNames(): string[];
+    private registerSync;
+    private registerAsync;
+    private getAsyncHandlerId;
+    private publishEmitDone;
+    private publishEmitNoop;
+    private publishHandlerError;
+    private publishAsyncEnqueued;
+}
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/event-bus/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../../src/event-bus/event-bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAER,kBAAkB,EAElB,QAAQ,EAER,gBAAgB,EACnB,MAAM,SAAS,CAAC;AAQjB;;;GAGG;AACH,qBAAa,QAAQ,CAAC,OAAO,SAAS,QAAQ;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyD;IACtF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyD;IACvF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiD;IACjF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsC;IACnE,OAAO,CAAC,kBAAkB,CAAK;gBAEnB,IAAI,CAAC,EAAE;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAC;QACpB,YAAY,CAAC,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAC;KAC/C;IAKD,EAAE,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAQzF,IAAI,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAS3F,GAAG,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IAkBjE,kBAAkB,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI;IAUtD,IAAI,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAwE7F,aAAa,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM;IAMjF,UAAU,IAAI,MAAM,EAAE;IAOtB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,oBAAoB;CAU/B"}