@zintrust/core 0.4.27 → 0.4.28

package/packages/workers/src/routes/workers.js

@@ -0,0 +1,126 @@
+/**
+ * Worker Management Routes
+ * HTTP API for managing workers with dashboard functionality
+ */
+import { Cloudflare, Env, Logger, Router } from '../../../../src/index.js';
+import { HealthMonitor } from '../HealthMonitor.js';
+import { ValidationSchemas, withCustomValidation } from '../http/middleware/CustomValidation.js';
+import { withEditWorkerValidation } from '../http/middleware/EditWorkerValidation.js';
+import { withDriverValidation } from '../http/middleware/ValidateDriver.js';
+import { withCreateWorkerValidation, withWorkerOperationValidation, } from '../http/middleware/WorkerValidationChain.js';
+import { WorkerApiController } from '../http/WorkerApiController.js';
+import { WorkerController } from '../http/WorkerController.js';
+import { ResourceMonitor } from '../ResourceMonitor.js';
+import { TelemetryDashboard } from '../telemetry/index.js';
+import { registerStaticAssets } from '../ui/router/ui.js';
+import { WorkerFactory } from '../WorkerFactory.js';
+const controller = WorkerController.create();
+const apiController = WorkerApiController.create();
+function registerCoreWorkerRoutes(r) {
+    // Core worker operations
+    Router.post(r, '/create', withCreateWorkerValidation(controller.create));
+    Router.put(r, '/:name', withCreateWorkerValidation(controller.update));
+    // Worker editing with custom validation that handles mapping
+    Router.put(r, '/:name/edit', withEditWorkerValidation(controller.update));
+    Router.post(r, '/:name/start', withDriverValidation(withWorkerOperationValidation(controller.start)));
+    Router.post(r, '/:name/auto-start', withDriverValidation(withWorkerOperationValidation(controller.setAutoStart)));
+    Router.post(r, '/:name/stop', withDriverValidation(withWorkerOperationValidation(controller.stop)));
+    Router.post(r, '/:name/restart', withDriverValidation(withWorkerOperationValidation(controller.restart)));
+    Router.post(r, '/:name/pause', withDriverValidation(withWorkerOperationValidation(controller.pause)));
+    Router.post(r, '/:name/resume', withDriverValidation(withWorkerOperationValidation(controller.resume)));
+    Router.del(r, '/:name', withDriverValidation(withWorkerOperationValidation(controller.remove)));
+}
+function registerWorkerQueryRoutes(r) {
+    // Worker listing and filtering
+    Router.get(r, '/', withDriverValidation(withCustomValidation(ValidationSchemas.workerFilter, apiController.listWorkers)));
+    Router.get(r, '/:name', withDriverValidation(withWorkerOperationValidation(controller.get)));
+    Router.get(r, '/:name/status', withWorkerOperationValidation(controller.status));
+    Router.get(r, '/:name/creation-status', withWorkerOperationValidation(controller.getCreationStatus));
+    Router.get(r, '/:name/metrics', withWorkerOperationValidation(controller.metrics));
+    Router.get(r, '/:name/health', withWorkerOperationValidation(controller.health));
+    // Worker details
+    Router.get(r, '/:name/details', withDriverValidation(apiController.getWorkerDetailsHandler));
+    // Worker driver data for editing
+    Router.get(r, '/:name/driver-data', withDriverValidation(apiController.getWorkerDriverDataHandler));
+}
+function registerMonitoringRoutes(r) {
+    // SSE events stream for monitoring + workers snapshot
+    Router.get(r, '/events', controller.eventsStream);
+    // Health monitoring
+    Router.post(r, '/:name/monitoring/start', controller.startMonitoring);
+    Router.post(r, '/:name/monitoring/stop', controller.stopMonitoring);
+    Router.get(r, '/:name/monitoring/history', controller.healthHistory);
+    Router.get(r, '/:name/monitoring/trend', controller.healthTrend);
+    Router.put(r, '/:name/monitoring/config', controller.updateMonitoringConfig);
+    // SLA monitoring
+    Router.get(r, '/:name/sla/status', controller.getSlaStatus);
+}
+function registerVersioningRoutes(r) {
+    // Versioning
+    Router.post(r, '/:name/versions', controller.registerVersion);
+    Router.get(r, '/:name/versions', controller.listVersions);
+    Router.get(r, '/:name/versions/:version', controller.getVersion);
+}
+function registerUtilityRoutes(r) {
+    // Utility endpoints
+    Router.get(r, '/drivers', apiController.getDriversHandler);
+    Router.get(r, '/queue-data', apiController.getQueueDataHandler);
+    Router.get(r, '/health', apiController.getHealthSummaryHandler);
+}
+function registerWorkerLifecycleRoutes(router, middleware) {
+    Router.group(router, '/api/workers', (r) => {
+        Logger.info('Registering Worker Management Routes');
+        registerCoreWorkerRoutes(r);
+        if (Cloudflare.getWorkersEnv() === null) {
+            registerMonitoringRoutes(r); // ← Move FIRST - has /events
+            registerWorkerQueryRoutes(r);
+            registerVersioningRoutes(r);
+            registerUtilityRoutes(r);
+        }
+    }, { middleware: middleware });
+}
+function registerWorkerTelemetryRoutes(router, middleware) {
+    const options = middleware ? { middleware } : undefined;
+    Router.group(router, '/api', (r) => {
+        Router.get(r, '/workers/system/summary', async (_req, res) => {
+            const workers = WorkerFactory.list();
+            const monitoringSummary = await HealthMonitor.getSummary();
+            const resourceUsage = ResourceMonitor.getCurrentUsage('system');
+            res.json({
+                ok: true,
+                summary: {
+                    workers: workers.length,
+                    monitoring: monitoringSummary,
+                    resources: resourceUsage,
+                },
+            });
+        });
+        Router.get(r, '/workers/system/monitoring/summary', async (_req, res) => {
+            const summary = await HealthMonitor.getSummary();
+            res.json({ ok: true, summary });
+        });
+        Router.get(r, '/resources/current', async (_req, res) => {
+            const usage = ResourceMonitor.getCurrentUsage('system');
+            res.json({ ok: true, usage });
+        });
+        Router.get(r, '/resources/trends', async (req, res) => {
+            const period = (req.getParam('period') ?? 'day');
+            const trends = ResourceMonitor.getAllTrends('system', period);
+            res.json({ ok: true, trends });
+        });
+    }, options);
+}
+export function registerWorkerRoutes(router, _options, routeOptions) {
+    registerStaticAssets(router, routeOptions?.middleware ?? []);
+    registerWorkerLifecycleRoutes(router, routeOptions?.middleware);
+    registerWorkerTelemetryRoutes(router, routeOptions?.middleware);
+    // Register Telemetry Dashboard
+    const dashboard = TelemetryDashboard.create({
+        basePath: '/telemetry',
+    });
+    dashboard.registerRoutes(router);
+    const port = Env.get('PORT', '7777');
+    Logger.info(`Worker routes registered at http://127.0.0.1:${port}/workers`);
+    Logger.info(`Telemetry dashboard registered at http://127.0.0.1:${port}/telemetry`);
+}
+export default registerWorkerRoutes;

package/packages/workers/src/storage/WorkerStore.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+import type { createRedisConnection } from '../../../../src/index.js';
+import { type IDatabase } from '../../../../src/index.js';
+type RedisConnection = ReturnType<typeof createRedisConnection>;
+export type WorkerRecord = {
+    name: string;
+    queueName: string;
+    version: string | null;
+    status: string;
+    autoStart: boolean;
+    concurrency: number;
+    region: string | null;
+    processorSpec?: string | null;
+    activeStatus?: boolean;
+    features?: Record<string, unknown> | null;
+    infrastructure?: Record<string, unknown> | null;
+    datacenter?: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+    lastHealthCheck?: Date;
+    lastError?: string;
+    connectionState?: 'disconnected' | 'connecting' | 'connected' | 'error';
+};
+export type WorkerStore = {
+    init(): Promise<void>;
+    list(options?: {
+        offset?: number;
+        limit?: number;
+        search?: string;
+        includeInactive?: boolean;
+    }): Promise<WorkerRecord[]>;
+    get(name: string): Promise<WorkerRecord | null>;
+    save(record: WorkerRecord): Promise<void>;
+    update(name: string, patch: Partial<WorkerRecord>): Promise<void>;
+    updateMany?: (names: string[], patch: Partial<WorkerRecord>) => Promise<void>;
+    remove(name: string): Promise<void>;
+    close?(): Promise<void>;
+};
+export declare const InMemoryWorkerStore: Readonly<{
+    create(): WorkerStore;
+}>;
+export declare const RedisWorkerStore: Readonly<{
+    create(client: RedisConnection, keyPrefix?: string): WorkerStore;
+}>;
+export declare const DbWorkerStore: Readonly<{
+    create(db: IDatabase, table?: string): WorkerStore;
+}>;
+export {};
+//# sourceMappingURL=WorkerStore.d.ts.map

package/packages/workers/src/storage/WorkerStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerStore.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/src/storage/WorkerStore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,KAAK,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,eAAe,CAAC,EAAE,IAAI,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,CAAC,OAAO,CAAC,EAAE;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAChD,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAgFF,eAAO,MAAM,mBAAmB;cACpB,WAAW;EA0CrB,CAAC;AAEH,eAAO,MAAM,gBAAgB;mBACZ,eAAe,uBAAmC,WAAW;EA2E5E,CAAC;AAEH,eAAO,MAAM,aAAa;eACb,SAAS,mBAA+B,WAAW;EA2D9D,CAAC"}

package/packages/workers/src/storage/WorkerStore.js

@@ -0,0 +1,259 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+const now = () => new Date();
+const mergeRecord = (current, patch) => ({
+    ...current,
+    ...patch,
+    updatedAt: patch.updatedAt ?? now(),
+});
+const toSqlDateTime = (value) => {
+    if (!value)
+        return null;
+    // Use UTC and drop timezone for SQL DATETIME compatibility
+    return value.toISOString().slice(0, 19).replace('T', ' ');
+};
+const serializeDbWorker = (record) => ({
+    name: record.name,
+    queue_name: record.queueName,
+    version: record.version,
+    status: record.status,
+    auto_start: record.autoStart,
+    concurrency: record.concurrency,
+    region: record.region,
+    processor_spec: record.processorSpec ?? null,
+    active_status: record.activeStatus ?? true,
+    features: record.features ? JSON.stringify(record.features) : null,
+    infrastructure: record.infrastructure ? JSON.stringify(record.infrastructure) : null,
+    datacenter: record.datacenter ? JSON.stringify(record.datacenter) : null,
+    created_at: toSqlDateTime(record.createdAt),
+    updated_at: toSqlDateTime(record.updatedAt),
+    last_health_check: toSqlDateTime(record.lastHealthCheck ?? null),
+    last_error: record.lastError ?? null,
+    connection_state: record.connectionState ?? null,
+});
+const getHealthCheck = (row) => {
+    if (!row['last_health_check']) {
+        return undefined;
+    }
+    return row['last_health_check'] instanceof Date
+        ? row['last_health_check']
+        : new Date(String(row['last_health_check']));
+};
+const deserializeDbWorker = (row) => {
+    const parseJson = (value) => {
+        if (typeof value !== 'string' || value.trim() === '')
+            return null;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        name: String(row['name'] ?? ''),
+        queueName: String(row['queue_name'] ?? ''),
+        version: row['version'] ? String(row['version']) : null,
+        status: String(row['status'] ?? 'unknown'),
+        autoStart: Boolean(row['auto_start'] ?? false),
+        concurrency: Number(row['concurrency'] ?? 0),
+        region: row['region'] ? String(row['region']) : null,
+        processorSpec: String(row['processor_spec']),
+        activeStatus: row['active_status'] === undefined ? true : Boolean(row['active_status']),
+        features: parseJson(row['features']),
+        infrastructure: parseJson(row['infrastructure']),
+        datacenter: parseJson(row['datacenter']),
+        createdAt: row['created_at'] instanceof Date ? row['created_at'] : new Date(String(row['created_at'])),
+        updatedAt: row['updated_at'] instanceof Date ? row['updated_at'] : new Date(String(row['updated_at'])),
+        lastHealthCheck: getHealthCheck(row),
+        lastError: row['last_error'] ? String(row['last_error']) : undefined,
+        connectionState: row['connection_state']
+            ? String(row['connection_state'])
+            : undefined,
+    };
+};
+export const InMemoryWorkerStore = Object.freeze({
+    create() {
+        const store = new Map();
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                let values = Array.from(store.values());
+                if (options) {
+                    const start = options.offset || 0;
+                    const end = options.limit ? start + options.limit : undefined;
+                    values = values.slice(start, end);
+                }
+                return values;
+            },
+            async get(name) {
+                return store.get(name) ?? null;
+            },
+            async save(record) {
+                store.set(record.name, record);
+            },
+            async update(name, patch) {
+                const current = store.get(name);
+                if (!current)
+                    return;
+                store.set(name, mergeRecord(current, patch));
+            },
+            async updateMany(names, patch) {
+                for (const name of names) {
+                    const current = store.get(name);
+                    if (!current)
+                        continue;
+                    store.set(name, mergeRecord(current, patch));
+                }
+            },
+            async remove(name) {
+                store.delete(name);
+            },
+            async close() {
+                // No-op for memory store
+            },
+        };
+    },
+});
+export const RedisWorkerStore = Object.freeze({
+    create(client, keyPrefix = 'workers:registry') {
+        const key = keyPrefix;
+        const serialize = (record) => JSON.stringify({
+            ...record,
+            createdAt: record.createdAt.toISOString(),
+            updatedAt: record.updatedAt.toISOString(),
+        });
+        const deserialize = (raw) => {
+            const parsed = JSON.parse(raw);
+            return {
+                ...parsed,
+                createdAt: new Date(parsed.createdAt),
+                updatedAt: new Date(parsed.updatedAt),
+            };
+        };
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                const all = await client.hgetall(key);
+                let values = Object.values(all).map((element) => deserialize(element));
+                values.sort((a, b) => a.name.localeCompare(b.name));
+                if (options) {
+                    const start = options.offset || 0;
+                    const end = options.limit ? start + options.limit : undefined;
+                    values = values.slice(start, end);
+                }
+                return values;
+            },
+            async get(name) {
+                const raw = await client.hget(key, name);
+                return raw ? deserialize(raw) : null;
+            },
+            async save(record) {
+                await client.hset(key, record.name, serialize(record));
+            },
+            async update(name, patch) {
+                const current = await this.get(name);
+                if (!current)
+                    return;
+                await client.hset(key, name, serialize(mergeRecord(current, patch)));
+            },
+            async updateMany(names, patch) {
+                if (names.length === 0)
+                    return;
+                const entries = await client.hmget(key, ...names);
+                const updates = [];
+                entries.forEach((raw, index) => {
+                    if (!raw)
+                        return;
+                    const current = deserialize(raw);
+                    const updated = mergeRecord(current, patch);
+                    updates.push(names[index], serialize(updated));
+                });
+                if (updates.length === 0)
+                    return;
+                await client.hset(key, ...updates);
+            },
+            async close() {
+                try {
+                    // Force disconnect in Cloudflare env to avoid hanging on quit()
+                    client.disconnect();
+                }
+                catch {
+                    // Ignore connection errors during cleanup
+                }
+            },
+            async remove(name) {
+                await client.hdel(key, name);
+            },
+        };
+    },
+});
+export const DbWorkerStore = Object.freeze({
+    create(db, table = 'zintrust_workers') {
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                const query = db.table(table);
+                if (options?.limit)
+                    query.limit(options.limit);
+                if (options?.offset)
+                    query.offset(options.offset);
+                const rows = await query.get();
+                return rows.map((element) => deserializeDbWorker(element));
+            },
+            async get(name) {
+                const row = await db.table(table).where('name', '=', name).first();
+                return row ? deserializeDbWorker(row) : null;
+            },
+            async save(record) {
+                const existing = await db
+                    .table(table)
+                    .where('name', '=', record.name)
+                    .first();
+                if (existing) {
+                    await db.table(table).where('name', '=', record.name).update(serializeDbWorker(record));
+                    return;
+                }
+                await db.table(table).insert(serializeDbWorker(record));
+            },
+            async update(name, patch) {
+                const current = await this.get(name);
+                if (!current)
+                    return;
+                const updated = mergeRecord(current, patch);
+                await db.table(table).where('name', '=', name).update(serializeDbWorker(updated));
+            },
+            async updateMany(names, patch) {
+                if (names.length === 0)
+                    return;
+                const update = {
+                    updated_at: toSqlDateTime(patch.updatedAt ?? now()),
+                };
+                if (patch.status !== undefined)
+                    update['status'] = patch.status;
+                if (patch.lastError !== undefined)
+                    update['last_error'] = patch.lastError ?? null;
+                if (patch.lastHealthCheck !== undefined)
+                    update['last_health_check'] = toSqlDateTime(patch.lastHealthCheck ?? null);
+                if (patch.connectionState !== undefined)
+                    update['connection_state'] = patch.connectionState ?? null;
+                await db.table(table).whereIn('name', names).update(update);
+            },
+            async remove(name) {
+                await db.table(table).where('name', '=', name).delete();
+            },
+            async close() {
+                // Database clients often managed by pool, but if needed:
+                // await db.destroy?.();
+            },
+        };
+    },
+});

package/packages/workers/src/telemetry/api/TelemetryAPI.d.ts

@@ -0,0 +1,47 @@
+export type TelemetrySettings = {
+    enabled: boolean;
+    basePath: string;
+    middleware: ReadonlyArray<string>;
+    autoRefresh: boolean;
+    refreshIntervalMs: number;
+};
+export type ResourceCurrentResponse = {
+    ok: boolean;
+    usage?: unknown;
+};
+export type SystemSummaryResponse = {
+    ok: boolean;
+    summary?: unknown;
+};
+export type ApiResponse<T> = {
+    ok: boolean;
+    error?: string;
+} & T;
+export type AlertRep = {
+    type: string;
+    severity: string;
+    message: string;
+    timestamp: string;
+    recommendation?: string;
+};
+export declare const TelemetryAPI: Readonly<{
+    getSystemSummary(): Promise<ApiResponse<{
+        summary: unknown;
+    }>>;
+    getMonitoringSummary(): Promise<ApiResponse<{
+        summary: unknown;
+    }>>;
+    getResourceCurrent(): Promise<ApiResponse<{
+        usage: unknown;
+    }>>;
+    getResourceTrends(): Promise<ApiResponse<{
+        trends: unknown;
+    }>>;
+}>;
+export declare function createSnapshotBuilder(): () => Promise<{
+    ok: boolean;
+    summary: unknown;
+    resources: unknown;
+    cost: unknown;
+}>;
+//# sourceMappingURL=TelemetryAPI.d.ts.map

package/packages/workers/src/telemetry/api/TelemetryAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryAPI.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/telemetry/api/TelemetryAPI.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAQvE,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC,CAAC;AACjE,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AA+IF,eAAO,MAAM,YAAY;wBACG,OAAO,CAAC,WAAW,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;4BAuCtC,OAAO,CAAC,WAAW,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;0BAc5C,OAAO,CAAC,WAAW,CAAC;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;yBAczC,OAAO,CAAC,WAAW,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;EAapE,CAAC;AAEH,wBAAgB,qBAAqB,UAClB,OAAO,CAAC;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC,CA4BH"}