monora-ai 1.0.0 → 1.0.1

package/README.md

@@ -21,27 +21,89 @@ npm install monora
 ## Quick Start
 
 ```typescript
-import { loadConfig, ModelRegistry, PolicyEngine, trace } from 'monora';
+import { init, llmCall, trace } from 'monora';
 
-// Load configuration
-const config = loadConfig({ configPath: './monora.json' });
+// Initialize SDK
+init({ configPath: './monora.yml' });
 
-// Create policy engine
-const policyEngine = new PolicyEngine(config.policies || {});
-
-// Check if a model is allowed
-const violation = policyEngine.checkModel('gpt-4o', 'internal');
-if (violation) {
-  console.error('Policy violation:', violation.message);
-}
+const ask = llmCall({ purpose: 'support' })(function ask(
+  question: string,
+  model: string = 'gpt-4o-mini'
+) {
+  return { choices: [{ message: { content: 'ok' } }] };
+});
 
 // Create a trace
 trace('my-ai-task', (span) => {
   console.log('Trace ID:', span.traceId);
-  console.log('Span ID:', span.spanId);
+  ask('hello');
+});
+```
+
+### Guided Setup (Wizard)
 
-  // Your AI code here
+```bash
+npx monora-ai init
+# or
+./node_modules/.bin/monora init
+```
+
+This generates a `monora.yml` you can load with `loadConfig({ configPath: './monora.yml' })`.
+
+### Reports & Security Review
+
+```bash
+npx monora-ai report --input events.jsonl --output report.json
+npx monora-ai report --input events.jsonl --output report.md --format markdown
+
+npx monora-ai security-review --input events.jsonl --output security.json
+npx monora-ai security-review --input events.jsonl --output security.json --sign gpg --gpg-key "you@example.com"
+```
+
+### Data Handling + Alerts
+
+```typescript
+import { DataHandlingEngine, buildDataViolation, ViolationWebhookDispatcher } from 'monora';
+
+const dataHandling = new DataHandlingEngine({
+  enabled: true,
+  mode: 'redact',
+  rules: [
+    { name: 'email', pattern: '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}' }
+  ]
 });
+
+const payload = { message: 'Contact me at person@example.com' };
+const { value, applied } = dataHandling.sanitizePayload('request', payload, 'confidential');
+
+const dispatcher = new ViolationWebhookDispatcher({
+  endpoint: 'https://hooks.example.com/monora',
+  headers: { Authorization: 'Bearer TOKEN' }
+});
+dispatcher.start();
+dispatcher.send({ event_type: 'policy_violation', message: 'Example violation' });
+```
+
+### High-level Runtime Helpers
+
+```typescript
+import { init, logEvent, toolCall, agentStep, setViolationHandler } from 'monora';
+
+init({ configPath: './monora.yml' });
+
+setViolationHandler((violation) => {
+  console.error('Violation:', violation.message);
+});
+
+const fetchTool = toolCall({ toolName: 'fetch', purpose: 'integration' })(async (url: string) => {
+  return { ok: true, url };
+});
+
+const plan = agentStep({ agentName: 'planner', stepType: 'planning', purpose: 'analysis' })(
+  (goal: string) => [`step for ${goal}`]
+);
+
+logEvent('custom', { message: 'hello' }, { purpose: 'manual' });
 ```
 
 ## Configuration
@@ -144,46 +206,50 @@ const gaps = detectSequenceGaps(events);
 console.log('Sequence gaps:', gaps);
 ```
 
-### Security Reports (Planned)
+### Security Reports
 
-Planned HTTP endpoint (see roadmap: https://github.com/monora/monora/issues).
+Generate JSON security review reports locally with CLI:
 
-- **Endpoint**: `POST /v1/reports/security`
-- **Auth**: `Authorization: Bearer $MONORA_API_KEY`
-- **Request**:
-  - `events`: array of Monora events
-  - `config` (optional): policies/registry overrides
-- **Response**: `{ overall_risk_level, risk_factors, operational_metrics, ... }`
-- **Errors**: `401` unauthorized, `400` invalid payload, `404` endpoint unavailable
+Auth: none (local CLI). Errors: invalid JSONL/config or GPG signing failures.
 
 ```bash
-curl -X POST "https://api.monora.example.com/v1/reports/security" \
-  -H "Authorization: Bearer $MONORA_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"events": [{"event_type": "llm_call"}], "config": {"policies": {}}}'
+npx monora-ai security-review --input events.jsonl --output security.json
+npx monora-ai security-review --input events.jsonl --output security.json --config monora.yml
 ```
 
-### Data Redaction (Planned)
+### Data Handling
 
-Planned SDK/config surface (see roadmap: https://github.com/monora/monora/issues).
+Use the data handling engine for redaction or blocking decisions (modes: `redact`, `block`, `allow`):
 
-- **Config**: `data_handling.mode`, `data_handling.apply_to`, `data_handling.rules`
-- **Auth**: none for local processing
-- **Errors**: `DataHandlingViolation` (block mode), invalid regex patterns
+Auth: none. Errors: `DataHandlingViolation` in block mode or invalid regex patterns.
 
 ```typescript
-// Planned API
-// const engine = new DataHandlingEngine(config.data_handling);
-// const [redacted, applied] = engine.redact('request', payload, 'confidential');
+import { DataHandlingEngine } from 'monora';
+
+const engine = new DataHandlingEngine({
+  enabled: true,
+  mode: 'redact',
+  rules: [{ name: 'email', pattern: '[^@]+@[^@]+\\.[^@]+' }]
+});
+const { value, applied } = engine.sanitizePayload('request', payload, 'confidential');
 ```
 
-### Webhook Alerts (Planned)
+### Webhook Alerts
 
-Planned configuration (see roadmap: https://github.com/monora/monora/issues).
+Send policy violation payloads to a webhook:
 
-- **Config**: `alerts.violation_webhook`, `alerts.headers`, `alerts.retry_attempts`
-- **Auth**: set `alerts.headers.Authorization` for your webhook
-- **Errors**: invalid URL, non-2xx responses, network timeouts
+Auth: set headers such as `Authorization`. Errors: network failures, non-2xx responses, or queue overflow.
+
+```typescript
+import { ViolationWebhookDispatcher } from 'monora';
+
+const dispatcher = new ViolationWebhookDispatcher({
+  endpoint: 'https://hooks.example.com/monora',
+  headers: { Authorization: 'Bearer TOKEN' }
+});
+dispatcher.start();
+dispatcher.send({ event_type: 'policy_violation', message: 'Blocked model' });
+```
 
 ```json
 {
@@ -196,6 +262,8 @@ Planned configuration (see roadmap: https://github.com/monora/monora/issues).
 
 ### Event Building and Dispatching
 
+Event builder and dispatcher classes are available in the current Node SDK.
+
 ```typescript
 import { EventBuilder, EventDispatcher, StdoutSink, FileSink } from 'monora';
 
@@ -233,6 +301,8 @@ dispatcher.close();
 
 ### Sink Options
 
+These sink implementations are exported and ready for use.
+
 ```typescript
 // Stdout Sink
 const stdoutSink = new StdoutSink('pretty'); // or 'json'

package/dist/alerts.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Violation alert dispatching.
+ */
+export declare class AlertError extends Error {
+    constructor(message: string);
+}
+export declare function buildViolationPayload(event: Record<string, any>): Record<string, any>;
+export declare class ViolationWebhookDispatcher {
+    private endpoint;
+    private headers;
+    private timeoutSec;
+    private retries;
+    private backoffBaseSec;
+    private queue;
+    private queueSize;
+    private failureMode;
+    private queueFullMode;
+    private timer?;
+    private fatalError?;
+    private inFlight;
+    constructor(options: {
+        endpoint: string;
+        headers: Record<string, string>;
+        timeoutSec?: number;
+        retryAttempts?: number;
+        backoffBaseSec?: number;
+        queueSize?: number;
+        failureMode?: 'warn' | 'raise' | 'ignore';
+        queueFullMode?: 'warn' | 'raise' | 'ignore';
+    });
+    start(): void;
+    send(payload: Record<string, any>): void;
+    flush(): void;
+    close(): void;
+    private processQueue;
+    private sendPayload;
+    private handleQueueFull;
+    private handleFailure;
+}
+//# sourceMappingURL=alerts.d.ts.map

package/dist/alerts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alerts.d.ts","sourceRoot":"","sources":["../src/alerts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,qBAAa,UAAW,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAiBrF;AAED,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,KAAK,CAAC,CAAiB;IAC/B,OAAO,CAAC,UAAU,CAAC,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAU;gBAEd,OAAO,EAAE;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;QAC1C,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;KAC7C;IAaD,KAAK,IAAI,IAAI;IASb,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAWxC,KAAK,IAAI,IAAI;IAIb,KAAK,IAAI,IAAI;YAQC,YAAY;YAqBZ,WAAW;IAmBzB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,aAAa;CAStB"}

package/dist/alerts.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Violation alert dispatching.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViolationWebhookDispatcher = exports.AlertError = void 0;
+exports.buildViolationPayload = buildViolationPayload;
+const axios_1 = __importDefault(require("axios"));
+class AlertError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AlertError';
+    }
+}
+exports.AlertError = AlertError;
+function buildViolationPayload(event) {
+    const body = event.body || {};
+    return {
+        event_type: 'policy_violation',
+        policy_event_type: event.event_type,
+        model: body.model,
+        policy_name: body.policy_name,
+        message: body.message,
+        timestamp: event.timestamp,
+        data_classification: event.data_classification,
+        rule_names: body.rule_names,
+        trace_id: event.trace_id,
+        span_id: event.span_id,
+        parent_span_id: event.parent_span_id,
+        service_name: event.service_name,
+        environment: event.environment,
+    };
+}
+class ViolationWebhookDispatcher {
+    constructor(options) {
+        this.endpoint = options.endpoint;
+        this.headers = options.headers || {};
+        this.timeoutSec = options.timeoutSec ?? 5.0;
+        this.retries = options.retryAttempts ?? 3;
+        this.backoffBaseSec = options.backoffBaseSec ?? 0.5;
+        this.queue = [];
+        this.queueSize = options.queueSize ?? 200;
+        this.failureMode = options.failureMode ?? 'warn';
+        this.queueFullMode = options.queueFullMode ?? 'warn';
+        this.inFlight = false;
+    }
+    start() {
+        if (this.timer) {
+            return;
+        }
+        this.timer = setInterval(() => {
+            void this.processQueue();
+        }, 500);
+    }
+    send(payload) {
+        if (this.fatalError && this.failureMode === 'raise') {
+            throw new AlertError('Violation webhook dispatcher failed');
+        }
+        if (this.queue.length >= this.queueSize) {
+            this.handleQueueFull();
+            return;
+        }
+        this.queue.push(payload);
+    }
+    flush() {
+        void this.processQueue(true);
+    }
+    close() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        this.flush();
+    }
+    async processQueue(drain = false) {
+        if (this.inFlight) {
+            return;
+        }
+        this.inFlight = true;
+        try {
+            while (this.queue.length > 0) {
+                const payload = this.queue.shift();
+                if (!payload) {
+                    break;
+                }
+                await this.sendPayload(payload);
+                if (!drain && this.queue.length === 0) {
+                    break;
+                }
+            }
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    async sendPayload(payload) {
+        for (let attempt = 0; attempt < this.retries; attempt += 1) {
+            try {
+                await axios_1.default.post(this.endpoint, payload, {
+                    headers: this.headers,
+                    timeout: this.timeoutSec * 1000,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempt === this.retries - 1) {
+                    this.handleFailure(error instanceof Error ? error : new Error(String(error)));
+                    return;
+                }
+                const backoff = this.backoffBaseSec * Math.pow(2, attempt);
+                await delay(backoff * 1000);
+            }
+        }
+    }
+    handleQueueFull() {
+        const message = 'Monora violation webhook queue full; dropping alert';
+        if (this.queueFullMode === 'raise') {
+            throw new AlertError(message);
+        }
+        if (this.queueFullMode === 'warn') {
+            console.error(message);
+        }
+    }
+    handleFailure(error) {
+        if (this.failureMode === 'raise') {
+            this.fatalError = error;
+            return;
+        }
+        if (this.failureMode === 'warn') {
+            console.error(`Monora violation webhook failed: ${error}`);
+        }
+    }
+}
+exports.ViolationWebhookDispatcher = ViolationWebhookDispatcher;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/attestation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Signed attestation bundle helpers.
+ */
+export declare class AttestationError extends Error {
+    constructor(message: string);
+}
+export interface SignatureResult {
+    signature: string;
+    signature_type: string;
+    key_id?: string;
+    fingerprint?: string;
+}
+export declare function serializeReport(report: Record<string, any>): Buffer;
+export declare function computeSha256(payload: Buffer): string;
+export declare function signReportGpg(reportBytes: Buffer, options?: {
+    keyId?: string;
+    gpgHome?: string;
+}): SignatureResult;
+export declare function buildAttestationBundle(report: Record<string, any>, reportBytes: Buffer, signature: SignatureResult): Record<string, any>;
+//# sourceMappingURL=attestation.d.ts.map

package/dist/attestation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation.d.ts","sourceRoot":"","sources":["../src/attestation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAEnE;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,eAAe,CAsDjB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,eAAe,GACzB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAcrB"}

package/dist/attestation.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Signed attestation bundle helpers.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestationError = void 0;
+exports.serializeReport = serializeReport;
+exports.computeSha256 = computeSha256;
+exports.signReportGpg = signReportGpg;
+exports.buildAttestationBundle = buildAttestationBundle;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+class AttestationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AttestationError';
+    }
+}
+exports.AttestationError = AttestationError;
+function serializeReport(report) {
+    return Buffer.from(JSON.stringify(report, null, 2), 'utf-8');
+}
+function computeSha256(payload) {
+    const digest = crypto.createHash('sha256').update(payload).digest('hex');
+    return `sha256:${digest}`;
+}
+function signReportGpg(reportBytes, options) {
+    const gpg = findGpg();
+    if (!gpg) {
+        throw new AttestationError('gpg not found on PATH');
+    }
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'monora-sign-'));
+    const reportPath = path.join(tmpDir, 'report.json');
+    const sigPath = path.join(tmpDir, 'report.json.asc');
+    try {
+        fs.writeFileSync(reportPath, reportBytes);
+        const args = ['--armor', '--detach-sign', '--output', sigPath];
+        if (options?.gpgHome) {
+            args.push('--homedir', options.gpgHome);
+        }
+        if (options?.keyId) {
+            args.push('--local-user', options.keyId);
+        }
+        args.push(reportPath);
+        const result = (0, child_process_1.spawnSync)(gpg, args, { encoding: 'utf-8' });
+        if (result.status !== 0) {
+            throw new AttestationError(result.stderr || 'gpg signing failed');
+        }
+        const signature = fs.readFileSync(sigPath, 'utf-8');
+        const fingerprint = options?.keyId
+            ? getGpgFingerprint(gpg, options.keyId, options.gpgHome)
+            : undefined;
+        return {
+            signature,
+            signature_type: 'gpg',
+            key_id: options?.keyId,
+            fingerprint,
+        };
+    }
+    finally {
+        try {
+            fs.unlinkSync(sigPath);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        try {
+            fs.unlinkSync(reportPath);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+}
+function buildAttestationBundle(report, reportBytes, signature) {
+    return {
+        bundle_version: '1.0.0',
+        generated_at: new Date().toISOString(),
+        report_sha256: computeSha256(reportBytes),
+        report_json: reportBytes.toString('utf-8'),
+        signature: {
+            type: signature.signature_type,
+            value: signature.signature,
+            key_id: signature.key_id,
+            fingerprint: signature.fingerprint,
+            signed_at: new Date().toISOString(),
+        },
+    };
+}
+function findGpg() {
+    const candidates = ['gpg', 'gpg2'];
+    for (const candidate of candidates) {
+        const result = (0, child_process_1.spawnSync)(candidate, ['--version'], { encoding: 'utf-8' });
+        if (result.status === 0) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function getGpgFingerprint(gpg, keyId, gpgHome) {
+    const args = ['--with-colons', '--fingerprint', keyId];
+    if (gpgHome) {
+        args.unshift('--homedir', gpgHome);
+    }
+    const result = (0, child_process_1.spawnSync)(gpg, args, { encoding: 'utf-8' });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    const lines = result.stdout.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line.startsWith('fpr:')) {
+            continue;
+        }
+        const parts = line.split(':').filter(Boolean);
+        return parts[parts.length - 1];
+    }
+    return undefined;
+}

package/dist/cli/diagnostics.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration diagnostics and validation.
+ */
+import { MonoraConfig } from '../config';
+interface ValidationResult {
+    errors: string[];
+    warnings: string[];
+}
+export declare function validateConfig(config: MonoraConfig): ValidationResult;
+export declare function doctorChecks(config: MonoraConfig, options?: {
+    checkNetwork?: boolean;
+}): ValidationResult;
+export declare function emitResults(results: ValidationResult, options?: {
+    json?: boolean;
+}): number;
+export {};
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/cli/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/cli/diagnostics.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAc,YAAY,EAAE,MAAM,WAAW,CAAC;AAOrD,UAAU,gBAAgB;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAuIrE;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACnC,gBAAgB,CAqDlB;AA+CD,wBAAgB,WAAW,CACzB,OAAO,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,MAAM,CA2BR"}