@zintrust/core 0.1.0 → 0.1.2

package/src/templates/project/basic/config/security.ts.tpl

@@ -4,9 +4,10 @@
  * Sealed namespace for immutability
  */
 
+import { appConfig } from '@config/app';
 import { Env } from '@config/env';
 import { Logger } from '@config/logger';
-import { ErrorFactory } from '@zintrust/core';
+import { ErrorFactory } from '@exceptions/ZintrustError';
 
 /**
  * Helper to warn about missing secrets
@@ -14,9 +15,7 @@ import { ErrorFactory } from '@zintrust/core';
 function warnMissingSecret(secretName: string): string {
   Logger.error(`❌ CRITICAL: ${secretName} environment variable is not set!`);
   Logger.error('⚠️  Application may not function correctly. Set this in production immediately.');
-
-  const nodeEnv = Env.get('NODE_ENV', 'development');
-  if (nodeEnv === 'production') {
+  if (appConfig.isProduction()) {
     throw ErrorFactory.createConfigError(`Missing required secret: ${secretName}`, { secretName });
   }
 
@@ -44,7 +43,7 @@ const securityConfigObj = {
     algorithm: Env.get('JWT_ALGORITHM', 'HS256') as 'HS256' | 'HS512' | 'RS256',
     expiresIn: Env.get('JWT_EXPIRES_IN', '1h'),
     refreshExpiresIn: Env.get('JWT_REFRESH_EXPIRES_IN', '7d'),
-    issuer: Env.get('JWT_ISSUER', '@zintrust/core'),
+    issuer: Env.get('JWT_ISSUER', 'zintrust'),
     audience: Env.get('JWT_AUDIENCE', 'zintrust-api'),
   },
 

package/src/templates/project/basic/config/startup.ts.tpl

@@ -0,0 +1,27 @@
+/**
+ * Startup Configuration
+ *
+ * Startup-only controls (evaluated during Application.boot()).
+ */
+
+import { Env } from '@config/env';
+
+export type StartupConfig = {
+  healthChecksEnabled: boolean;
+  validateSecrets: boolean;
+  checkDatabase: boolean;
+  checkCache: boolean;
+  timeoutMs: number;
+  continueOnFailure: boolean;
+};
+
+export const startupConfig = Object.freeze({
+  healthChecksEnabled: Env.getBool('STARTUP_HEALTH_CHECKS', true),
+  validateSecrets: Env.getBool('STARTUP_VALIDATE_SECRETS', true),
+  checkDatabase: Env.getBool('STARTUP_CHECK_DB', false),
+  checkCache: Env.getBool('STARTUP_CHECK_CACHE', false),
+  timeoutMs: Env.getInt('STARTUP_HEALTH_TIMEOUT_MS', 2500),
+  continueOnFailure: Env.getBool('STARTUP_CONTINUE_ON_FAILURE', false),
+} satisfies StartupConfig);
+
+export default startupConfig;

package/src/templates/project/basic/config/storage.ts.tpl

@@ -18,8 +18,8 @@ type LocalStorageDriverConfig = {
 
 type S3StorageDriverConfig = {
   driver: 's3';
-  key: EnvGetValue;
-  secret: EnvGetValue;
+  accessKeyId: EnvGetValue;
+  secretAccessKey: EnvGetValue;
   region: typeof Env.AWS_REGION;
   bucket: EnvGetValue;
   url: EnvGetValue;
@@ -27,6 +27,16 @@ type S3StorageDriverConfig = {
   usePathStyleUrl: EnvGetBoolValue;
 };
 
+type R2StorageDriverConfig = {
+  driver: 'r2';
+  accessKeyId: EnvGetValue;
+  secretAccessKey: EnvGetValue;
+  region: EnvGetValue;
+  bucket: EnvGetValue;
+  endpoint: EnvGetValue;
+  url: EnvGetValue;
+};
+
 type GcsStorageDriverConfig = {
   driver: 'gcs';
   projectId: EnvGetValue;
@@ -38,6 +48,7 @@ type GcsStorageDriverConfig = {
 type StorageDrivers = {
   local: LocalStorageDriverConfig;
   s3: S3StorageDriverConfig;
+  r2: R2StorageDriverConfig;
   gcs: GcsStorageDriverConfig;
 };
 
@@ -45,11 +56,14 @@ type StorageDriverName = keyof StorageDrivers;
 type StorageDriverConfig = StorageDrivers[StorageDriverName];
 
 type StorageConfigRuntime = {
-  default: string;
-  drivers: StorageDrivers;
+  readonly default: string;
+  readonly drivers: StorageDrivers;
 };
 
-const isStorageDriverName = (value: string, drivers: StorageDrivers): value is StorageDriverName => {
+const isStorageDriverName = (
+  value: string,
+  drivers: StorageDrivers
+): value is StorageDriverName => {
   return value in drivers;
 };
 
@@ -63,39 +77,54 @@ const getStorageDriver = (config: StorageConfigRuntime): StorageDriverConfig =>
   return config.drivers.local;
 };
 
+const getDrivers = (): StorageDrivers => ({
+  local: {
+    driver: 'local' as const,
+    root: Env.get('STORAGE_PATH', 'storage'),
+    url: Env.get('STORAGE_URL', '/storage'),
+    visibility: Env.get('STORAGE_VISIBILITY', 'private'),
+  },
+  s3: {
+    driver: 's3' as const,
+    accessKeyId: Env.get('AWS_ACCESS_KEY_ID', ''),
+    secretAccessKey: Env.get('AWS_SECRET_ACCESS_KEY', ''),
+    region: Env.AWS_REGION,
+    bucket: Env.get('AWS_S3_BUCKET', ''),
+    url: Env.get('AWS_S3_URL', ''),
+    endpoint: Env.get('AWS_S3_ENDPOINT', ''),
+    usePathStyleUrl: Env.getBool('AWS_S3_USE_PATH_STYLE_URL', false),
+  },
+  r2: {
+    driver: 'r2' as const,
+    accessKeyId: Env.get('R2_ACCESS_KEY_ID', ''),
+    secretAccessKey: Env.get('R2_SECRET_ACCESS_KEY', ''),
+    region: Env.get('R2_REGION', ''),
+    bucket: Env.get('R2_BUCKET', ''),
+    endpoint: Env.get('R2_ENDPOINT', ''),
+    url: Env.get('R2_URL', ''),
+  },
+  gcs: {
+    driver: 'gcs' as const,
+    projectId: Env.get('GCS_PROJECT_ID', ''),
+    keyFile: Env.get('GCS_KEY_FILE', ''),
+    bucket: Env.get('GCS_BUCKET', ''),
+    url: Env.get('GCS_URL', ''),
+  },
+});
+
 const storageConfigObj = {
   /**
-   * Default storage driver
+   * Default storage driver (dynamic; tests may mutate process.env)
    */
-  default: Env.get('STORAGE_DRIVER', 'local'),
+  get default(): string {
+    return Env.get('STORAGE_DRIVER', 'local');
+  },
 
   /**
-   * Storage drivers configuration
+   * Storage drivers configuration (dynamic; tests may mutate process.env)
    */
-  drivers: {
-    local: {
-      driver: 'local' as const,
-      root: Env.get('STORAGE_PATH', 'storage'),
-      url: Env.get('STORAGE_URL', '/storage'),
-      visibility: Env.get('STORAGE_VISIBILITY', 'private'),
-    },
-    s3: {
-      driver: 's3' as const,
-      key: Env.get('AWS_ACCESS_KEY_ID'),
-      secret: Env.get('AWS_SECRET_ACCESS_KEY'),
-      region: Env.AWS_REGION,
-      bucket: Env.get('AWS_S3_BUCKET'),
-      url: Env.get('AWS_S3_URL'),
-      endpoint: Env.get('AWS_S3_ENDPOINT'),
-      usePathStyleUrl: Env.getBool('AWS_S3_USE_PATH_STYLE_URL', false),
-    },
-    gcs: {
-      driver: 'gcs' as const,
-      projectId: Env.get('GCS_PROJECT_ID'),
-      keyFile: Env.get('GCS_KEY_FILE'),
-      bucket: Env.get('GCS_BUCKET'),
-      url: Env.get('GCS_URL'),
-    },
+  get drivers(): StorageDrivers {
+    return getDrivers();
   },
 
   /**
@@ -108,26 +137,32 @@ const storageConfigObj = {
   /**
    * Temporary file settings
    */
-  temp: {
-    path: Env.get('TEMP_PATH', 'storage/temp'),
-    maxAge: Env.getInt('TEMP_FILE_MAX_AGE', 86400), // 24 hours
+  get temp(): { path: string; maxAge: number } {
+    return {
+      path: Env.get('TEMP_PATH', 'storage/temp'),
+      maxAge: Env.getInt('TEMP_FILE_MAX_AGE', 86400), // 24 hours
+    };
   },
 
   /**
    * Uploads settings
    */
-  uploads: {
-    maxSize: Env.get('MAX_UPLOAD_SIZE', '100mb'),
-    allowedMimes: Env.get('ALLOWED_UPLOAD_MIMES', 'jpg,jpeg,png,pdf,doc,docx'),
-    path: Env.get('UPLOADS_PATH', 'storage/uploads'),
+  get uploads(): { maxSize: string; allowedMimes: string; path: string } {
+    return {
+      maxSize: Env.get('MAX_UPLOAD_SIZE', '100mb'),
+      allowedMimes: Env.get('ALLOWED_UPLOAD_MIMES', 'jpg,jpeg,png,pdf,doc,docx'),
+      path: Env.get('UPLOADS_PATH', 'storage/uploads'),
+    };
   },
 
   /**
    * Backups settings
    */
-  backups: {
-    path: Env.get('BACKUPS_PATH', 'storage/backups'),
-    driver: Env.get('BACKUP_DRIVER', 's3'),
+  get backups(): { path: string; driver: string } {
+    return {
+      path: Env.get('BACKUPS_PATH', 'storage/backups'),
+      driver: Env.get('BACKUP_DRIVER', 's3'),
+    };
   },
 };
 

package/src/templates/project/basic/database/migrations/index.ts.tpl

@@ -1,2 +1,2 @@
 // Placeholder for migrations
-export {};
+export const migrations = Object.freeze([] as const);

package/src/templates/project/basic/package.json.tpl

@@ -11,7 +11,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@zintrust/core": "^0.1.0"
+    "@zintrust/core": "^0.1.1"
   },
   "devDependencies": {
     "tsx": "^4.21.0",

package/src/templates/project/basic/routes/api.ts.tpl

@@ -5,8 +5,9 @@
 
 import { UserController } from '@app/Controllers/UserController';
 import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import { useDatabase, type IRouter, Router } from '@zintrust/core';
+import { registerBroadcastRoutes } from '@routes/broadcast';
+import { registerHealthRoutes } from '@routes/health';
+import { type IRouter, Router } from '@routing/Router';
 
 export function registerRoutes(router: IRouter): void {
   const userController = UserController.create();
@@ -19,6 +20,12 @@ export function registerRoutes(router: IRouter): void {
  * Register public routes
  */
 function registerPublicRoutes(router: IRouter): void {
+  registerRootRoute(router);
+  registerHealthRoutes(router);
+  registerBroadcastRoutes(router);
+}
+
+function registerRootRoute(router: IRouter): void {
   Router.get(router, '/', async (_req, res) => {
     res.json({
       framework: 'Zintrust Framework',
@@ -28,41 +35,6 @@ function registerPublicRoutes(router: IRouter): void {
       database: Env.DB_CONNECTION ?? 'sqlite',
     });
   });
-
-  Router.get(router, '/health', async (_req, res) => {
-    try {
-      const db = useDatabase();
-      await db.query('SELECT 1');
-
-      const uptime =
-        typeof process !== 'undefined' && typeof process.uptime === 'function'
-          ? process.uptime()
-          : 0;
-
-      res.json({
-        status: 'healthy',
-        timestamp: new Date().toISOString(),
-        uptime,
-        database: 'connected',
-        environment: Env.NODE_ENV ?? 'development',
-      });
-    } catch (error) {
-      Logger.error('Health check failed:', error);
-
-      const isProd =
-        typeof process !== 'undefined' &&
-        typeof process.env === 'object' &&
-        process.env !== null &&
-        process.env['NODE_ENV'] === 'production';
-
-      res.setStatus(503).json({
-        status: 'unhealthy',
-        timestamp: new Date().toISOString(),
-        database: 'disconnected',
-        error: isProd ? 'Service unavailable' : (error as Error).message,
-      });
-    }
-  });
 }
 
 /**

package/src/templates/project/basic/routes/broadcast.ts.tpl

@@ -0,0 +1,32 @@
+/**
+ * Broadcast Routes
+ *
+ * Runtime-only endpoints for broadcast.
+ * Provider setup and secret provisioning remain CLI-only.
+ */
+
+import { type IRouter, Router } from '@routing/Router';
+
+export function registerBroadcastRoutes(router: IRouter): void {
+  Router.get(router, '/broadcast/health', async (_req, res) => {
+    res.json({ ok: true });
+  });
+
+  Router.post(router, '/broadcast/send', async (req: { body?: unknown }, res) => {
+    const body = (req.body ?? {}) as Record<string, unknown>;
+    const channel = typeof body['channel'] === 'string' ? body['channel'] : '';
+    const event = typeof body['event'] === 'string' ? body['event'] : '';
+    const data = body['data'];
+
+    if (!channel || !event) {
+      res
+        .setStatus(400)
+        .json({ ok: false, error: 'Invalid payload: channel and event are required' });
+      return;
+    }
+
+    const { Broadcast } = await import('@broadcast/Broadcast');
+    const result = await Broadcast.send(channel, event, data);
+    res.json({ ok: true, result });
+  });
+}

package/src/templates/project/basic/routes/health.ts.tpl

@@ -0,0 +1,134 @@
+/**
+ * Health Routes
+ * Provides health, liveness, and readiness endpoints.
+ */
+
+import { appConfig } from '@/config';
+import { RuntimeHealthProbes } from '@/health/RuntimeHealthProbes';
+import { Env } from '@config/env';
+import { Logger } from '@config/logger';
+import { useDatabase } from '@orm/Database';
+import { QueryBuilder } from '@orm/QueryBuilder';
+import { type IRouter, Router } from '@routing/Router';
+
+export function registerHealthRoutes(router: IRouter): void {
+  registerHealthRoute(router);
+  registerHealthLiveRoute(router);
+  registerHealthReadyRoute(router);
+}
+
+function registerHealthRoute(router: IRouter): void {
+  Router.get(router, '/health', async (_req, res) => {
+    const environment = Env.NODE_ENV ?? 'development';
+
+    try {
+      const db = useDatabase();
+      await QueryBuilder.ping(db);
+
+      const uptime =
+        typeof process !== 'undefined' && typeof process.uptime === 'function'
+          ? process.uptime()
+          : 0;
+
+      res.json({
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        uptime,
+        database: 'connected',
+        environment,
+      });
+    } catch (error) {
+      Logger.error('Health check failed:', error);
+
+      const isProd = environment === 'production' || environment === 'prod';
+
+      res.setStatus(503).json({
+        status: 'unhealthy',
+        timestamp: new Date().toISOString(),
+        database: 'disconnected',
+        error: isProd ? 'Service unavailable' : (error as Error).message,
+      });
+    }
+  });
+}
+
+function registerHealthLiveRoute(router: IRouter): void {
+  Router.get(router, '/health/live', async (_req, res) => {
+    const uptime =
+      typeof process !== 'undefined' && typeof process.uptime === 'function' ? process.uptime() : 0;
+
+    res.json({
+      status: 'alive',
+      timestamp: new Date().toISOString(),
+      uptime,
+    });
+  });
+}
+
+function registerHealthReadyRoute(router: IRouter): void {
+  Router.get(router, '/health/ready', async (_req, res) => {
+    const startTime = Date.now();
+    const environment = appConfig.environment;
+
+    let databaseResponseTime: number | null = null;
+    let cacheResponseTime: number | null = null;
+
+    try {
+      const db = useDatabase();
+      await QueryBuilder.ping(db);
+
+      databaseResponseTime = Date.now() - startTime;
+
+      // Only probe KV at runtime when explicitly configured.
+      cacheResponseTime = await RuntimeHealthProbes.pingKvCache(2000);
+
+      res.json({
+        status: 'ready',
+        timestamp: new Date().toISOString(),
+        environment,
+        dependencies: {
+          database: {
+            status: 'ready',
+            responseTime: databaseResponseTime,
+          },
+          ...(cacheResponseTime === null
+            ? {}
+            : {
+                cache: {
+                  status: 'ready',
+                  responseTime: cacheResponseTime,
+                },
+              }),
+        },
+      });
+    } catch (error) {
+      Logger.error('Readiness check failed:', error);
+
+      const isProd = environment === 'production';
+
+      const responseTime = Date.now() - startTime;
+
+      const dependencies: Record<string, unknown> = {
+        database: {
+          status: databaseResponseTime === null ? 'unavailable' : 'ready',
+          responseTime: databaseResponseTime ?? responseTime,
+        },
+      };
+
+      if (RuntimeHealthProbes.getCacheDriverName() === 'kv') {
+        dependencies['cache'] = {
+          status: 'unavailable',
+          responseTime: cacheResponseTime ?? responseTime,
+        };
+      }
+
+      res.setStatus(503).json({
+        status: 'not_ready',
+        timestamp: new Date().toISOString(),
+        environment,
+        dependencies,
+        error: isProd ? 'Service unavailable' : (error as Error).message,
+      });
+    }
+  });
+}

package/src/templates/project/basic/src/index.ts.tpl

@@ -28,22 +28,49 @@ async function start() {
     await server.listen();
 
     Logger.info(`Server running at http://${host}:${port}`);
+
+    const shutdown = async (signal: string): Promise<void> => {
+      Logger.info(`${signal} received, shutting down gracefully...`);
+
+      const timeoutMs = Env.getInt('SHUTDOWN_TIMEOUT', 10000);
+      const withTimeout = async <T>(promise: Promise<T>, ms: number): Promise<T> => {
+        if (ms <= 0) return promise;
+        return new Promise<T>((resolve, reject) => {
+          const timer = setTimeout(() => reject(new globalThis.Error('Shutdown timed out')), ms);
+          promise
+            .then((value) => {
+              clearTimeout(timer);
+              resolve(value);
+            })
+            .catch((err) => {
+              clearTimeout(timer);
+              reject(err);
+            });
+        });
+      };
+
+      try {
+        await withTimeout(
+          (async () => {
+            await server.close();
+            await app.shutdown();
+          })(),
+          timeoutMs
+        );
+        process.exit(0);
+      } catch (error) {
+        Logger.error('Graceful shutdown failed:', error);
+        process.exit(1);
+      }
+    };
+
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.on('SIGINT', () => void shutdown('SIGINT'));
   } catch (error) {
     Logger.error('Failed to start application:', error);
     process.exit(1);
   }
 }
 
-// Handle graceful shutdown
-process.on('SIGTERM', () => {
-  Logger.info('SIGTERM received, shutting down gracefully...');
-  process.exit(0);
-});
-
-process.on('SIGINT', () => {
-  Logger.info('SIGINT received, shutting down gracefully...');
-  process.exit(0);
-});
-
 // Run start
 await start();

package/src/templates/project/basic/template.json

@@ -8,6 +8,9 @@
     "config",
     "database/migrations",
     "database/seeders",
+    "logs",
+    "storage",
+    "tmp",
     "public",
     "routes",
     "src",

package/src/toolkit/Secrets/EnvFile.d.ts

@@ -0,0 +1,15 @@
+export type EnvFileWriteMode = 'overwrite';
+export declare const EnvFile: Readonly<{
+    read(params: {
+        cwd: string;
+        path: string;
+    }): Promise<Record<string, string>>;
+    write(params: {
+        cwd: string;
+        path: string;
+        values: Record<string, string>;
+        mode: EnvFileWriteMode;
+    }): Promise<void>;
+}>;
+export default EnvFile;
+//# sourceMappingURL=EnvFile.d.ts.map

package/src/toolkit/Secrets/EnvFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvFile.d.ts","sourceRoot":"","sources":["../../../../src/toolkit/Secrets/EnvFile.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAmC3C,eAAO,MAAM,OAAO;iBACC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;kBAgB9D;QAClB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/B,IAAI,EAAE,gBAAgB,CAAC;KACxB,GAAG,OAAO,CAAC,IAAI,CAAC;EAgBjB,CAAC;AAEH,eAAe,OAAO,CAAC"}

package/src/toolkit/Secrets/EnvFile.js

@@ -0,0 +1,63 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { fsPromises as fs } from '../../node-singletons/fs';
+import * as path from '../../node-singletons/path';
+const isValidKey = (key) => /^[A-Z0-9_]+$/.test(key);
+const parseEnvLine = (line) => {
+    const trimmed = line.trim();
+    if (trimmed === '' || trimmed.startsWith('#'))
+        return null;
+    const eq = trimmed.indexOf('=');
+    if (eq <= 0)
+        return null;
+    const key = trimmed.slice(0, eq).trim();
+    const raw = trimmed.slice(eq + 1);
+    if (!isValidKey(key))
+        return null;
+    // Preserve value verbatim (except strip surrounding quotes if present)
+    let value = raw;
+    const v = raw.trim();
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+        value = v.slice(1, -1);
+    }
+    return { key, value };
+};
+const serializeEnv = (values) => {
+    const keys = Object.keys(values).sort((a, b) => a.localeCompare(b));
+    const lines = keys.map((key) => {
+        const value = values[key] ?? '';
+        // Write as JSON string to safely quote newlines, #, etc.
+        return `${key}=${JSON.stringify(value)}`;
+    });
+    return `${lines.join('\n')}\n`;
+};
+export const EnvFile = Object.freeze({
+    async read(params) {
+        const filePath = path.resolve(params.cwd, params.path);
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const result = {};
+            for (const line of raw.split(/\r?\n/)) {
+                const parsed = parseEnvLine(line);
+                if (parsed)
+                    result[parsed.key] = parsed.value;
+            }
+            return result;
+        }
+        catch {
+            return {};
+        }
+    },
+    async write(params) {
+        const filePath = path.resolve(params.cwd, params.path);
+        for (const key of Object.keys(params.values)) {
+            if (!isValidKey(key)) {
+                throw ErrorFactory.createCliError(`Invalid env key: ${key}`);
+            }
+        }
+        const content = serializeEnv(params.values);
+        // Ensure parent dir exists for cases like ./.zintrust/.env.pull
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, content, 'utf-8');
+    },
+});
+export default EnvFile;

package/src/toolkit/Secrets/Manifest.d.ts

@@ -0,0 +1,24 @@
+export type SecretsProviderName = 'aws' | 'cloudflare';
+export type ManifestKeySpec = {
+    aws?: {
+        secretId: string;
+        jsonKey?: string;
+    };
+    cloudflare?: {
+        key: string;
+        namespaceId?: string;
+    };
+};
+export type SecretsManifest = {
+    provider: SecretsProviderName;
+    keys: Record<string, ManifestKeySpec>;
+};
+export declare const Manifest: Readonly<{
+    load(params: {
+        cwd: string;
+        path: string;
+        provider: SecretsProviderName;
+    }): Promise<SecretsManifest>;
+}>;
+export default Manifest;
+//# sourceMappingURL=Manifest.d.ts.map

package/src/toolkit/Secrets/Manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../../../src/toolkit/Secrets/Manifest.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,YAAY,CAAC;AAEvD,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,CAAC,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,UAAU,CAAC,EAAE;QACX,GAAG,EAAE,MAAM,CAAC;QACZ,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACvC,CAAC;AA+DF,eAAO,MAAM,QAAQ;iBACA;QACjB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,mBAAmB,CAAC;KAC/B,GAAG,OAAO,CAAC,eAAe,CAAC;EA4B5B,CAAC;AAEH,eAAe,QAAQ,CAAC"}