@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/public/v1/history/[id].js

@@ -0,0 +1,176 @@
+/**
+ * GET /api/public/v1/history/[id]
+ * Get detailed artifact with download URL for files
+ *
+ * DELETE /api/public/v1/history/[id]
+ * Delete artifact and its storage file
+ */
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { validateApiKey } from "../_lib/auth";
+import { createErrorResponse } from "../_lib/errors";
+import { getSignedDownloadUrl, deleteArtifact } from "../_lib/artifacts";
+export async function GET(request, { params }) {
+    const requestId = randomUUID();
+    try {
+        const { id: artifactId } = await params;
+        const authHeader = request.headers.get("Authorization");
+        // 1. Validate API key OR session auth
+        let ownerId = null;
+        if (authHeader) {
+            // Try API key authentication
+            const authResult = await validateApiKey(authHeader);
+            if (authResult.success && authResult.apiKey) {
+                ownerId = authResult.apiKey.owner_id;
+            }
+        }
+        // If no API key, try session authentication
+        if (!ownerId) {
+            const { getSupabaseServerClient } = await import("@lastbrain/core/server");
+            const supabaseAuth = await getSupabaseServerClient();
+            const { data: { user }, } = await supabaseAuth.auth.getUser();
+            if (user) {
+                ownerId = user.id;
+            }
+        }
+        // If still no authentication, return error
+        if (!ownerId) {
+            const { response, status } = createErrorResponse("UNAUTHORIZED", "Authentication required (API key or session)", requestId, undefined, 401);
+            return NextResponse.json(response, { status });
+        }
+        // 2. Fetch artifact from database
+        const supabase = getSupabaseServiceClient();
+        const { data: artifact, error } = await supabase
+            .from("ai_artifacts")
+            .select("*")
+            .eq("id", artifactId)
+            .single();
+        if (error || !artifact) {
+            const { response, status } = createErrorResponse("INTERNAL_ERROR", "Artifact not found", requestId, undefined, 404);
+            return NextResponse.json(response, { status });
+        }
+        // 3. Verify ownership
+        if (artifact.owner_id !== ownerId) {
+            const { response, status } = createErrorResponse("INTERNAL_ERROR", "You don't have access to this artifact", requestId, undefined, 403);
+            return NextResponse.json(response, { status });
+        }
+        // 4. Build response based on artifact kind
+        const baseResponse = {
+            id: artifact.id,
+            kind: artifact.kind,
+            provider: artifact.provider,
+            model: artifact.model,
+            endpoint: artifact.endpoint,
+            tokens_total: artifact.tokens_total,
+            status_code: artifact.status_code,
+            mime_type: artifact.mime_type,
+            storage_path: artifact.storage_path,
+            size_bytes: artifact.size_bytes,
+            created_at: artifact.created_at,
+            meta: artifact.meta,
+        };
+        // For text artifacts, return full text_content
+        if (artifact.kind === "text") {
+            return NextResponse.json({
+                request_id: requestId,
+                artifact: {
+                    ...baseResponse,
+                    text_content: artifact.text_content,
+                },
+            });
+        }
+        // For file-based artifacts (image, pdf, file), generate signed URL
+        if (artifact.storage_path && artifact.storage_bucket) {
+            const { url, error: urlError } = await getSignedDownloadUrl(artifact.storage_path, 60 // 60 seconds TTL
+            );
+            if (urlError || !url) {
+                logger.error("[history/[id]] Failed to generate signed URL", {
+                    artifactId,
+                    error: urlError,
+                });
+                return NextResponse.json({
+                    request_id: requestId,
+                    artifact: {
+                        ...baseResponse,
+                        download_error: "Failed to generate download URL",
+                    },
+                });
+            }
+            return NextResponse.json({
+                request_id: requestId,
+                artifact: {
+                    ...baseResponse,
+                    download_url: url,
+                    expires_in: 60,
+                },
+            });
+        }
+        // Artifact exists but has no storage
+        return NextResponse.json({
+            request_id: requestId,
+            artifact: {
+                ...baseResponse,
+                note: "No storage file available for this artifact",
+            },
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Internal server error";
+        logger.error("[history/[id]] Unexpected error", error);
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", errorMessage, requestId, undefined, 500);
+        return NextResponse.json(response, { status });
+    }
+}
+export async function DELETE(request, { params }) {
+    const requestId = randomUUID();
+    try {
+        const { id: artifactId } = await params;
+        const authHeader = request.headers.get("Authorization");
+        // 1. Validate API key OR session auth
+        let ownerId = null;
+        if (authHeader) {
+            // Try API key authentication
+            const authResult = await validateApiKey(authHeader);
+            if (authResult.success && authResult.apiKey) {
+                ownerId = authResult.apiKey.owner_id;
+            }
+        }
+        // If no API key, try session authentication
+        if (!ownerId) {
+            const { getSupabaseServerClient } = await import("@lastbrain/core/server");
+            const supabaseAuth = await getSupabaseServerClient();
+            const { data: { user }, } = await supabaseAuth.auth.getUser();
+            if (user) {
+                ownerId = user.id;
+            }
+        }
+        // If still no authentication, return error
+        if (!ownerId) {
+            const { response, status } = createErrorResponse("UNAUTHORIZED", "Authentication required (API key or session)", requestId, undefined, 401);
+            return NextResponse.json(response, { status });
+        }
+        // 2. Delete artifact (includes ownership check and storage cleanup)
+        const deleteResult = await deleteArtifact(artifactId, ownerId);
+        if (!deleteResult.success) {
+            const { response, status } = createErrorResponse("INTERNAL_ERROR", deleteResult.error || "Failed to delete artifact", requestId, undefined, deleteResult.error === "Artifact not found"
+                ? 404
+                : deleteResult.error === "Unauthorized"
+                    ? 403
+                    : 500);
+            return NextResponse.json(response, { status });
+        }
+        return NextResponse.json({
+            request_id: requestId,
+            deleted: true,
+            artifact_id: artifactId,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Internal server error";
+        logger.error("[history/[id]] DELETE unexpected error", error);
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", errorMessage, requestId, undefined, 500);
+        return NextResponse.json(response, { status });
+    }
+}

package/dist/api/public/v1/history.d.ts

@@ -0,0 +1,30 @@
+/**
+ * GET /api/public/v1/history
+ * List AI artifacts history with pagination
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<import("./_lib/errors").ApiError> | NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    items: {
+        id: any;
+        kind: any;
+        provider: any;
+        model: any;
+        endpoint: any;
+        tokens_total: any;
+        status_code: any;
+        has_storage: boolean;
+        mime_type: any;
+        storage_path: any;
+        size_bytes: any;
+        created_at: any;
+        meta: any;
+        text_excerpt: string | undefined;
+    }[];
+    pagination: {
+        limit: number;
+        has_more: boolean;
+        next_cursor: string | undefined;
+    };
+}>>;
+//# sourceMappingURL=history.d.ts.map

package/dist/api/public/v1/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/history.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiBxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;IA0K7C"}

package/dist/api/public/v1/history.js

@@ -0,0 +1,142 @@
+/**
+ * GET /api/public/v1/history
+ * List AI artifacts history with pagination
+ */
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { randomUUID } from "crypto";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { validateApiKey } from "./_lib/auth";
+import { createErrorResponse } from "./_lib/errors";
+const HistoryQuerySchema = z.object({
+    kind: z
+        .enum(["all", "text", "image", "pdf", "file"])
+        .optional()
+        .default("all"),
+    limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+    cursor: z.string().optional(),
+});
+export async function GET(request) {
+    const requestId = randomUUID();
+    try {
+        const authHeader = request.headers.get("Authorization");
+        // 1. Validate API key OR session auth
+        let ownerId = null;
+        if (authHeader) {
+            // Try API key authentication
+            const authResult = await validateApiKey(authHeader);
+            if (authResult.success && authResult.apiKey) {
+                ownerId = authResult.apiKey.owner_id;
+            }
+        }
+        // If no API key, try session authentication
+        if (!ownerId) {
+            const { getSupabaseServerClient } = await import("@lastbrain/core/server");
+            const supabaseAuth = await getSupabaseServerClient();
+            const { data: { user }, } = await supabaseAuth.auth.getUser();
+            if (user) {
+                ownerId = user.id;
+            }
+        }
+        // If still no authentication, return error
+        if (!ownerId) {
+            const { response, status } = createErrorResponse("UNAUTHORIZED", "Authentication required (API key or session)", requestId, undefined, 401);
+            return NextResponse.json(response, { status });
+        }
+        // 2. Parse query params
+        const { searchParams } = new URL(request.url);
+        const queryData = {
+            kind: searchParams.get("kind") || "all",
+            limit: searchParams.get("limit") || undefined,
+            cursor: searchParams.get("cursor") || undefined,
+        };
+        const validation = HistoryQuerySchema.safeParse(queryData);
+        if (!validation.success) {
+            const { response, status } = createErrorResponse("VALIDATION_ERROR", validation.error.errors.map((e) => e.message).join(", "), requestId, undefined, 400);
+            return NextResponse.json(response, { status });
+        }
+        const { kind, limit, cursor } = validation.data;
+        // 3. Query artifacts from database
+        const supabase = getSupabaseServiceClient();
+        let query = supabase
+            .from("ai_artifacts")
+            .select("id, kind, provider, model, endpoint,storage_path, tokens_total, status_code, storage_path, mime_type, size_bytes, created_at, meta")
+            .eq("owner_id", ownerId)
+            .order("created_at", { ascending: false })
+            .limit(limit + 1); // Fetch one extra to determine if there are more
+        // Filter by kind if not "all"
+        if (kind !== "all") {
+            query = query.eq("kind", kind);
+        }
+        // Handle cursor-based pagination
+        if (cursor) {
+            try {
+                const [cursorDate, cursorId] = cursor.split("_");
+                query = query.or(`created_at.lt.${cursorDate},and(created_at.eq.${cursorDate},id.lt.${cursorId})`);
+            }
+            catch {
+                logger.warn("[history] Invalid cursor format", { cursor });
+            }
+        }
+        const { data: artifacts, error } = await query;
+        if (error) {
+            logger.error("[history] Database query failed", error);
+            const { response, status } = createErrorResponse("INTERNAL_ERROR", "Failed to fetch history", requestId, undefined, 500);
+            return NextResponse.json(response, { status });
+        }
+        // 4. Determine if there are more results
+        const hasMore = artifacts.length > limit;
+        const items = hasMore ? artifacts.slice(0, limit) : artifacts;
+        // 5. Format response
+        const formattedItems = items.map((artifact) => {
+            // For text artifacts, include excerpt
+            let textExcerpt;
+            if (artifact.kind === "text") {
+                const fullText = artifact.text_content;
+                if (fullText && typeof fullText === "string") {
+                    textExcerpt = fullText.substring(0, 200);
+                    if (fullText.length > 200) {
+                        textExcerpt += "...";
+                    }
+                }
+            }
+            return {
+                id: artifact.id,
+                kind: artifact.kind,
+                provider: artifact.provider,
+                model: artifact.model,
+                endpoint: artifact.endpoint,
+                tokens_total: artifact.tokens_total,
+                status_code: artifact.status_code,
+                has_storage: !!artifact.storage_path,
+                mime_type: artifact.mime_type,
+                storage_path: artifact.storage_path,
+                size_bytes: artifact.size_bytes,
+                created_at: artifact.created_at,
+                meta: artifact.meta,
+                text_excerpt: textExcerpt,
+            };
+        });
+        // 6. Generate next cursor
+        let nextCursor;
+        if (hasMore && items.length > 0) {
+            const lastItem = items[items.length - 1];
+            nextCursor = `${lastItem.created_at}_${lastItem.id}`;
+        }
+        return NextResponse.json({
+            request_id: requestId,
+            items: formattedItems,
+            pagination: {
+                limit,
+                has_more: hasMore,
+                next_cursor: nextCursor,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[history] Unexpected error", error);
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", error.message || "Internal server error", requestId, undefined, 500);
+        return NextResponse.json(response, { status });
+    }
+}

package/dist/api/public/v1/image-ai.d.ts

@@ -0,0 +1,24 @@
+/**
+ * POST /api/public/v1/image-ai
+ * Generate images using AI
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<import("./_lib/errors").ApiError> | NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    image_url: string | undefined;
+    model: string | undefined;
+    provider: string | undefined;
+    tokens: {
+        used: number;
+    };
+    balance: {
+        remaining_quota: number;
+        remaining_purchased: any;
+        total: any;
+    };
+    artifact: {
+        id: string | undefined;
+        stored: boolean;
+    } | undefined;
+}>>;
+//# sourceMappingURL=image-ai.d.ts.map

package/dist/api/public/v1/image-ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-ai.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/image-ai.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAsBxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;IA8R9C"}

package/dist/api/public/v1/image-ai.js

@@ -0,0 +1,233 @@
+/**
+ * POST /api/public/v1/image-ai
+ * Generate images using AI
+ */
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { randomUUID } from "crypto";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { validateApiKey, verifyScope } from "./_lib/auth";
+import { createErrorResponse } from "./_lib/errors";
+import { logApiCall, updateApiKeyLastUsed } from "./_lib/log";
+import { generateImage } from "./_lib/router";
+import { shouldStoreOutputs, createArtifact } from "./_lib/artifacts";
+const ImageGenerationSchema = z.object({
+    prompt: z.string().min(1).max(5000),
+    model: z.string().optional(),
+    size: z
+        .enum(["256x256", "512x512", "1024x1024", "1024x1792", "1792x1024"])
+        .optional(),
+    quality: z.enum(["standard", "hd"]).optional(),
+    store_outputs: z.boolean().optional(),
+    artifact_title: z.string().max(200).optional(),
+});
+export async function POST(request) {
+    const startTime = Date.now();
+    const requestId = randomUUID();
+    let apiKeyId = null;
+    let ownerId = null;
+    let statusCode = 200;
+    let errorCode = null;
+    try {
+        const authHeader = request.headers.get("Authorization");
+        // 1. Validate API key
+        const authResult = await validateApiKey(authHeader);
+        if (!authResult.success || !authResult.apiKey) {
+            const { response, status } = createErrorResponse(authResult.errorCode, authResult.error || "Authentication failed", requestId, undefined, 401);
+            statusCode = status;
+            errorCode = authResult.errorCode || null;
+            return NextResponse.json(response, { status });
+        }
+        const apiKey = authResult.apiKey;
+        apiKeyId = apiKey.id;
+        ownerId = apiKey.owner_id;
+        // 2. Verify scope
+        const scopeResult = verifyScope(apiKey, "image");
+        if (!scopeResult.success) {
+            const { response, status } = createErrorResponse("INSUFFICIENT_SCOPE", scopeResult.error || "Missing required scope", requestId, undefined, 403);
+            statusCode = status;
+            errorCode = "INSUFFICIENT_SCOPE";
+            return NextResponse.json(response, { status });
+        }
+        // 3. Parse and validate request body
+        let body;
+        try {
+            body = await request.json();
+        }
+        catch (parseError) {
+            const { response, status } = createErrorResponse("VALIDATION_ERROR", "Invalid JSON in request body", requestId, undefined, 400);
+            statusCode = status;
+            errorCode = "VALIDATION_ERROR";
+            return NextResponse.json(response, { status });
+        }
+        if (!body || typeof body !== "object") {
+            const { response, status } = createErrorResponse("VALIDATION_ERROR", "Request body must be a valid JSON object", requestId, undefined, 400);
+            statusCode = status;
+            errorCode = "VALIDATION_ERROR";
+            return NextResponse.json(response, { status });
+        }
+        const validation = ImageGenerationSchema.safeParse(body);
+        if (!validation.success) {
+            const { response, status } = createErrorResponse("VALIDATION_ERROR", validation.error.errors.map((e) => e.message).join(", "), requestId, undefined, 400);
+            statusCode = status;
+            errorCode = "VALIDATION_ERROR";
+            return NextResponse.json(response, { status });
+        }
+        const data = validation.data;
+        // 4. Check token balance BEFORE calling model (prevent free consumption)
+        const estimatedTokens = 6000; // Conservative estimate for images
+        const supabase = getSupabaseServiceClient();
+        const { data: balanceData } = await supabase
+            .from("user_token_balance_v")
+            .select("balance")
+            .eq("owner_id", ownerId)
+            .single();
+        const currentBalance = balanceData?.balance || 0;
+        if (currentBalance < estimatedTokens) {
+            logger.warn(`[image-ai] Insufficient balance: have ${currentBalance}, need ~${estimatedTokens}`);
+            const purchaseUrl = process.env.NEXT_PUBLIC_APP_URL + "/auth/module-ai/tokens";
+            const { response, status } = createErrorResponse("INSUFFICIENT_TOKENS", `Insufficient token balance. You have ${currentBalance} tokens, estimated ${estimatedTokens} needed.`, requestId, purchaseUrl, 402);
+            statusCode = status;
+            errorCode = "INSUFFICIENT_TOKENS";
+            return NextResponse.json(response, { status });
+        }
+        // 5. Generate image via router (handles model validation and token estimation)
+        const generateResult = await generateImage(ownerId, {
+            prompt: data.prompt,
+            model: data.model, // Can be provider/model or just model name
+            size: data.size,
+            quality: data.quality,
+        });
+        if (!generateResult.success) {
+            const { response, status } = createErrorResponse("PROVIDER_ERROR", generateResult.error || "Image generation failed", requestId, undefined, 500);
+            statusCode = status;
+            errorCode = "PROVIDER_ERROR";
+            return NextResponse.json(response, { status });
+        }
+        // Token debit already handled by computeAndDebitAIUsage() in generateImage()
+        const tokensUsed = generateResult.tokensUsed || 0;
+        logger.info(`[image-ai] ✅ Success: billing handled via computeAndDebitAIUsage()`);
+        // 6. Log API call
+        const latencyMs = Date.now() - startTime;
+        await logApiCall({
+            apiKeyId,
+            ownerId,
+            endpoint: "image",
+            provider: generateResult.provider || null,
+            model: generateResult.model || null,
+            tokensIn: null,
+            tokensOut: null,
+            tokensTotal: tokensUsed,
+            latencyMs,
+            statusCode,
+            errorCode: null,
+            requestId,
+            meta: {
+                prompt_length: data.prompt.length,
+                size: data.size,
+                quality: data.quality,
+            },
+        });
+        // 8. Update API key last used
+        await updateApiKeyLastUsed(apiKey);
+        // 9. Store artifact if enabled
+        let artifactId;
+        let artifactStored = false;
+        const shouldStore = await shouldStoreOutputs(ownerId, body.store_outputs);
+        if (shouldStore && generateResult.imageUrl) {
+            try {
+                // Download image from URL
+                const imageResponse = await fetch(generateResult.imageUrl);
+                if (imageResponse.ok) {
+                    const arrayBuffer = await imageResponse.arrayBuffer();
+                    const imageBuffer = Buffer.from(arrayBuffer);
+                    const artifactResult = await createArtifact({
+                        apiKey,
+                        kind: "image",
+                        endpoint: "image-ai",
+                        provider: generateResult.provider,
+                        model: generateResult.model,
+                        tokensTotal: tokensUsed,
+                        statusCode: 200,
+                        fileBuffer: imageBuffer,
+                        mimeType: "image/png",
+                        ext: "png",
+                        meta: {
+                            request_id: requestId,
+                            title: body.artifact_title,
+                            size: data.size,
+                            quality: data.quality,
+                        },
+                    });
+                    if (artifactResult.success) {
+                        artifactId = artifactResult.artifactId;
+                        artifactStored = true;
+                        logger.debug("[image-ai] Artifact stored", { artifactId });
+                    }
+                    else {
+                        logger.warn("[image-ai] Failed to store artifact", {
+                            error: artifactResult.error,
+                        });
+                    }
+                }
+            }
+            catch (downloadError) {
+                logger.error("[image-ai] Failed to download image for storage", downloadError);
+            }
+        }
+        // 7. Get updated balance for response
+        const { data: finalBalanceData } = await supabase
+            .from("user_token_balance_v")
+            .select("balance")
+            .eq("owner_id", ownerId)
+            .single();
+        const totalBalance = finalBalanceData?.balance || 0;
+        // 8. Return response
+        return NextResponse.json({
+            request_id: requestId,
+            image_url: generateResult.imageUrl,
+            model: generateResult.model,
+            provider: generateResult.provider,
+            tokens: {
+                used: tokensUsed,
+            },
+            balance: {
+                remaining_quota: 0,
+                remaining_purchased: totalBalance,
+                total: totalBalance,
+            },
+            artifact: artifactStored
+                ? {
+                    id: artifactId,
+                    stored: true,
+                }
+                : undefined,
+        });
+    }
+    catch (error) {
+        logger.error("[image-ai] Unexpected error", error);
+        statusCode = 500;
+        errorCode = "INTERNAL_ERROR";
+        // Log error even in catch
+        if (apiKeyId && ownerId) {
+            const latencyMs = Date.now() - startTime;
+            await logApiCall({
+                apiKeyId,
+                ownerId,
+                endpoint: "image",
+                provider: null,
+                model: null,
+                tokensIn: null,
+                tokensOut: null,
+                tokensTotal: null,
+                latencyMs,
+                statusCode,
+                errorCode,
+                requestId,
+            });
+        }
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", error.message || "Internal server error", requestId, undefined, 500);
+        return NextResponse.json(response, { status });
+    }
+}

package/dist/api/public/v1/prompts.d.ts

@@ -0,0 +1,19 @@
+/**
+ * GET /api/public/v1/prompts
+ * Get user's prompts via Bearer token authentication
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<import("./_lib/errors").ApiError> | NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    prompts: {
+        id: any;
+        title: any;
+        content: any;
+        type: any;
+        tags: any;
+        is_public: any;
+        favorite: any;
+        created_at: any;
+    }[];
+}>>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/api/public/v1/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;IAkI7C"}