@liquidmetal-ai/raindrop 0.9.7 → 0.10.0

package/dist/codegen.test.js

@@ -0,0 +1,223 @@
+import { mustManifestFromString } from '@liquidmetal-ai/drizzle/appify/index';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from 'vitest';
+import { codegenPlan, gatherEnvForHandler, kebabCaseToCamelCase, kebabCaseToConstantCase, kebabCaseToUpperCamelCase, renderTemplatesFromDirectory, shouldWriteTemplate, trimTemplateSuffix, } from './codegen.js';
+test('trims handlebars suffix', async () => {
+    expect(trimTemplateSuffix('index.ts.hbs')).toEqual('index.ts');
+});
+test('codegens from blank app', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {}
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(1);
+    expect(plan[0]?.templateName).toMatch('templates/init');
+    expect(plan[0]?.outPath).toEqual('');
+});
+test('codegens from app with observer', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      bucket "bucket" {}
+
+      observer "process" {
+        source {
+          bucket = "bucket"
+        }
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/bucket-event-notification');
+    expect(plan[1]?.outPath).toEqual('src/process');
+});
+test('codegens from app with service', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      bucket "bucket" {}
+
+      service "ingester" {
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/http-service');
+    expect(plan[1]?.outPath).toEqual('src/ingester');
+});
+test('codegens from app with durable object', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      actor "ingest-object" {
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/actor');
+    expect(plan[1]?.outPath).toEqual('src/ingest-object');
+});
+test('codegens from app with sql database', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      sql_database "demosql" {}
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(6);
+    expect(plan[0]?.templateName).toMatch('templates/init');
+    expect(plan[0]?.outPath).toEqual('');
+    expect(plan[1]?.templateName).toMatch('templates/db/package.json');
+    expect(plan[1]?.outPath).toEqual('./');
+    expect(plan[2]?.templateName).toMatch('templates/db/db');
+    expect(plan[2]?.outPath).toEqual('db/demosql');
+    expect(plan[3]?.templateName).toMatch('templates/db/common');
+    expect(plan[3]?.outPath).toEqual('src/common');
+    expect(plan[4]?.templateName).toMatch('templates/db/prisma');
+    expect(plan[4]?.outPath).toEqual('prisma/demosql');
+    expect(plan[5]?.templateName).toMatch('templates/db/scripts');
+    expect(plan[5]?.outPath).toEqual('scripts');
+});
+test('only codegens scaffolding when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderScaffoldingCode: true,
+    }, 'src/handlers/something/__index.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderScaffoldingCode: false,
+    }, 'src/handlers/something/__index.ts')).toBe(false);
+});
+test('only codegens user modifiable code when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderUserModifiableCode: true,
+    }, 'src/handlers/something/index.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderUserModifiableCode: false,
+    }, 'src/handlers/something/index.ts')).toBe(false);
+});
+test('only codegens non-user modifiable code when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderNonUserModifiableCode: true,
+    }, 'src/handlers/something/env.gen.d.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderNonUserModifiableCode: false,
+    }, 'src/handlers/something/env.gen.d.ts')).toBe(false);
+});
+test('codegens template files', async () => {
+    const templatePath = path.join(__dirname, '..', 'templates', 'init');
+    const outPath = await fs.mkdtemp(path.join(os.tmpdir(), 'codegen-test'));
+    await renderTemplatesFromDirectory({
+        templatePath,
+        outPath,
+        context: {
+            toolName: 'raindrop',
+            applicationName: 'test-app',
+            raindropFrameworkVersion: '0.4.9',
+        },
+        opts: {
+            renderScaffoldingCode: true,
+            renderUserModifiableCode: true,
+            renderNonUserModifiableCode: true,
+        },
+    });
+    // Verify nested directory structure is preserved
+    const authFilePath = path.join(outPath, 'src', '_app', 'auth.ts');
+    const authFileExists = await fs.access(authFilePath).then(() => true, () => false);
+    expect(authFileExists).toBe(true);
+    // Verify the file content was copied correctly
+    const authFileContent = await fs.readFile(authFilePath, 'utf-8');
+    expect(authFileContent).toContain('verifyIssuer');
+    expect(authFileContent).toContain('requireAuthenticated');
+});
+test('kebabCaseToConstantCase', () => {
+    expect(kebabCaseToConstantCase('my-variable')).toEqual('MY_VARIABLE');
+});
+test('kebabCaseToCamelCase', () => {
+    expect(kebabCaseToCamelCase('my-variable')).toEqual('myVariable');
+});
+test('kebabCaseToUpperCamelCase', () => {
+    expect(kebabCaseToUpperCamelCase('my-variable')).toEqual('MyVariable');
+});
+test('generates SmartMemory type bindings', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      smartmemory "user-memory" {}
+
+      service "test-service" {}
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include SmartMemory import
+    expect(generated).toMatch(/import\s+{[^}]*SmartMemory[^}]*}\s+from\s+'@liquidmetal-ai\/raindrop-framework'/);
+    // Should include SmartMemory type binding with constant case naming
+    expect(generated).toMatch(/USER_MEMORY:\s*SmartMemory/);
+});
+test('generates SmartBucket type bindings', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      smartbucket "data-bucket" {}
+
+      service "test-service" {}
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include SmartBucket import
+    expect(generated).toMatch(/import\s+{[^}]*SmartBucket[^}]*}\s+from\s+'@liquidmetal-ai\/raindrop-framework'/);
+    // Should include SmartBucket type binding with constant case naming
+    expect(generated).toMatch(/DATA_BUCKET:\s*SmartBucket/);
+});
+test('always includes mem KvCache binding', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      service "test-service" {}
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include KvCache import
+    expect(generated).toMatch(/import\s+{[^}]*KvCache[^}]*}\s+from\s+'@liquidmetal-ai\/raindrop-framework'/);
+    // Should include mem type binding
+    expect(generated).toMatch(/mem:\s*KvCache/);
+});
+test('includes auth env vars for protected service', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      service "protected-service" {
+        visibility = "protected"
+      }
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include core auth bindings and WorkOS provider bindings for protected services
+    expect(generated).toMatch(/LM_AUTH_ALLOWED_ORIGINS:\s*string/);
+    expect(generated).toMatch(/LM_AUTH_ALLOWED_ISSUERS:\s*string/);
+    expect(generated).toMatch(/LM_PROVIDER_WORKOS_ORG_ID\?:\s*string/);
+    expect(generated).toMatch(/LM_PROVIDER_WORKOS_CLIENT_ID\?:\s*string/);
+    expect(generated).toMatch(/LM_PROVIDER_WORKOS_API_KEY\?:\s*string/);
+});
+test('does not include auth env vars for public service', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      service "public-service" {
+        visibility = "public"
+      }
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should NOT include auth env vars for non-protected services
+    expect(generated).not.toMatch(/LM_AUTH_ALLOWED_ORIGINS/);
+    expect(generated).not.toMatch(/LM_AUTH_ALLOWED_ISSUERS/);
+    expect(generated).not.toMatch(/LM_PROVIDER_WORKOS_ORG_ID/);
+    expect(generated).not.toMatch(/LM_PROVIDER_WORKOS_CLIENT_ID/);
+    expect(generated).not.toMatch(/LM_PROVIDER_WORKOS_API_KEY/);
+});

package/dist/commands/logs/tail.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tail.test.d.ts.map

package/dist/commands/logs/tail.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.test.d.ts","sourceRoot":"","sources":["../../../src/commands/logs/tail.test.ts"],"names":[],"mappings":""}

package/dist/commands/logs/tail.test.js

@@ -0,0 +1,366 @@
+import { create } from '@bufbuild/protobuf';
+import { QueryLogsResponseSchema, StreamLogsResponseSchema } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/riverjack_pb';
+import { expect, test, vi, describe, beforeEach, afterEach } from 'vitest';
+import Tail from './tail.js';
+// Mock valueOf function
+vi.mock('@liquidmetal-ai/drizzle/appify/build', () => ({
+    valueOf: (obj) => obj?.value || obj,
+}));
+// Mock the base command dependencies
+vi.mock('../../base-command.js', () => {
+    return {
+        BaseCommand: class {
+            static HIDDEN_FLAGS = {};
+            flags = {};
+            log = vi.fn();
+            error = vi.fn((msg, options) => {
+                if (options?.exit) {
+                    throw new Error(msg);
+                }
+            });
+            async loadManifest() {
+                return [{ name: { value: 'test-app' } }];
+            }
+            async loadConfig() {
+                return { versionId: 'test-version-123' };
+            }
+            async tenantRiverjackService() {
+                return {
+                    userId: 'test-user',
+                    organizationId: 'test-org',
+                    client: this.mockRiverjackClient,
+                };
+            }
+            mockRiverjackClient = {
+                queryLogs: vi.fn(),
+                streamLogs: vi.fn(),
+            };
+        }
+    };
+});
+// Mock the log helpers
+vi.mock('../../log-helpers.js', () => ({
+    displayTraceGroupedEvents: vi.fn(),
+}));
+describe('Tail command', () => {
+    let tail;
+    let mockQueryLogs;
+    let mockStreamLogs;
+    let logSpy;
+    beforeEach(() => {
+        tail = new Tail([], {});
+        logSpy = vi.spyOn(tail, 'log');
+        // Access the mock client through the instance
+        const mockClient = tail.mockRiverjackClient;
+        mockQueryLogs = mockClient.queryLogs;
+        mockStreamLogs = mockClient.streamLogs;
+        // Reset mocks
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('GNU tail behavior', () => {
+        test('default behavior: shows 10 logs and exits (no streaming)', async () => {
+            // Setup mock response
+            const mockEvents = [
+                { traceId: '1', message: 'log 1' },
+                { traceId: '2', message: 'log 2' },
+            ];
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(2),
+                hasMore: false,
+            }));
+            // Set no flags (default behavior)
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+            };
+            await tail.run();
+            // Should query for 10 logs (default)
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 10,
+                organizationId: 'test-org',
+                userId: 'test-user',
+                applicationName: 'test-app',
+                applicationVersionId: 'test-version-123',
+            }));
+            // Should NOT start streaming
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+            // Should show appropriate messages
+            expect(logSpy).toHaveBeenCalledWith('Using organization: test-org');
+            expect(logSpy).toHaveBeenCalledWith('Using user: test-user');
+            expect(logSpy).toHaveBeenCalledWith('Showing last 10 logs for test-app@test-version-123...');
+            expect(logSpy).toHaveBeenCalledWith('📜 Showing last 2 log events:');
+            // Should NOT show streaming messages
+            expect(logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Press Ctrl+C'));
+            expect(logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Live stream starting'));
+        });
+        test('with -n flag: shows N logs and exits', async () => {
+            const mockEvents = Array(5).fill(null).map((_, i) => ({
+                traceId: `${i}`,
+                message: `log ${i}`,
+            }));
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(5),
+                hasMore: false,
+            }));
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 25,
+            };
+            await tail.run();
+            // Should query for 25 logs
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 25,
+            }));
+            // Should NOT stream
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+            // Should show correct message
+            expect(logSpy).toHaveBeenCalledWith('Showing last 25 logs for test-app@test-version-123...');
+        });
+        test('with -f flag: shows 10 logs then streams', async () => {
+            const mockEvents = [{ traceId: '1', message: 'log 1' }];
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(1),
+                hasMore: false,
+            }));
+            // Mock async generator for streaming
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                    message: 'Stream started',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            await tail.run();
+            // Should query for 10 logs (default)
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 10,
+            }));
+            // Should start streaming
+            expect(mockStreamLogs).toHaveBeenCalled();
+            // Should show appropriate messages
+            expect(logSpy).toHaveBeenCalledWith('Following logs for test-app@test-version-123...');
+            expect(logSpy).toHaveBeenCalledWith('Press Ctrl+C to stop following\n');
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Live stream starting'));
+        });
+        test('with -n and -f flags: shows N logs then streams', async () => {
+            const mockEvents = Array(30).fill(null).map((_, i) => ({
+                traceId: `${i}`,
+                message: `log ${i}`,
+            }));
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(30),
+                hasMore: false,
+            }));
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 30,
+                follow: true,
+            };
+            await tail.run();
+            // Should query for 30 logs
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 30,
+            }));
+            // Should start streaming
+            expect(mockStreamLogs).toHaveBeenCalled();
+            // Should show correct messages
+            expect(logSpy).toHaveBeenCalledWith('Following logs for test-app@test-version-123...');
+            expect(logSpy).toHaveBeenCalledWith('📜 Showing last 30 log events:');
+        });
+    });
+    describe('edge cases', () => {
+        test('handles no logs found gracefully', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 10,
+            };
+            await tail.run();
+            expect(logSpy).toHaveBeenCalledWith('ℹ️  No recent logs found in the last hour');
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+        });
+        test('handles query error gracefully when following', async () => {
+            mockQueryLogs.mockRejectedValue(new Error('Query failed'));
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            await tail.run();
+            // Should show error but continue to stream
+            expect(logSpy).toHaveBeenCalledWith('⚠️  Could not fetch recent logs: Query failed');
+            expect(logSpy).toHaveBeenCalledWith('🔴 Starting live stream anyway...');
+            expect(mockStreamLogs).toHaveBeenCalled();
+        });
+        test('handles query error gracefully when not following', async () => {
+            mockQueryLogs.mockRejectedValue(new Error('Query failed'));
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 10,
+            };
+            await tail.run();
+            // Should show error and exit
+            expect(logSpy).toHaveBeenCalledWith('⚠️  Could not fetch recent logs: Query failed');
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+        });
+        test('handles -n 0 correctly (no recent logs)', async () => {
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 0,
+            };
+            await tail.run();
+            // Should not query for logs when lines is 0
+            expect(mockQueryLogs).not.toHaveBeenCalled();
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+            expect(logSpy).toHaveBeenCalledWith('Showing last 0 logs for test-app@test-version-123...');
+        });
+        test('handles JSON output format', async () => {
+            const mockEvents = [
+                { traceId: '1', message: 'log 1' },
+            ];
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(1),
+                hasMore: false,
+            }));
+            tail.flags = {
+                application: 'test-app',
+                output: 'json',
+                lines: 1,
+            };
+            await tail.run();
+            // Should output JSON format
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('['));
+        });
+    });
+    describe('streaming behavior', () => {
+        test('handles different stream response types', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                    message: 'Started',
+                    timestamp: new Date().toISOString(),
+                });
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'heartbeat',
+                });
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'events',
+                    events: [{ traceId: '1', message: 'streamed log' }],
+                });
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_ended',
+                    message: 'Ended',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            await tail.run();
+            // Check that different response types are handled
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Started streaming logs'));
+            expect(logSpy).toHaveBeenCalledWith('✅ Stream ended');
+        });
+        test('handles stream errors', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            // Mock error method to capture the error
+            const errorSpy = vi.spyOn(tail, 'error').mockImplementation((msg) => {
+                throw new Error(msg);
+            });
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'service_error',
+                    message: 'Stream connection failed',
+                });
+                throw new Error('Stream connection failed');
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            // Should handle the error
+            await expect(tail.run()).rejects.toThrow('Failed to tail logs');
+            // Restore the mock
+            errorSpy.mockRestore();
+        });
+    });
+    describe('configuration', () => {
+        test('uses application from manifest when not provided', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            tail.flags = {
+                output: 'text',
+                // No application flag set
+            };
+            await tail.run();
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                applicationName: 'test-app', // From manifest
+            }));
+        });
+        test('uses provided application over manifest', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            tail.flags = {
+                output: 'text',
+                application: 'custom-app',
+            };
+            await tail.run();
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                applicationName: 'custom-app',
+            }));
+        });
+    });
+});

package/dist/commands/object/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/object/list.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,WAAW,CAAC,OAAO,UAAU,CAAC;IACpE,MAAM,CAAC,WAAW,SAA8B;IAEhD,MAAM,CAAC,QAAQ,WAUb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;MAgDV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAqK3B"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/object/list.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,WAAW,CAAC,OAAO,UAAU,CAAC;IACpE,MAAM,CAAC,WAAW,SAA8B;IAEhD,MAAM,CAAC,QAAQ,WAUb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;MAgDV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA0P3B"}