@vertesia/workflow 0.81.1 → 1.0.0-dev.20260203.130115Z

package/src/activities/media/prepareAudio.ts

@@ -0,0 +1,334 @@
+import { log } from '@temporalio/activity';
+import { DSLActivityExecutionPayload, DSLActivitySpec, AudioMetadata, AUDIO_RENDITION_NAME, ContentNature, Rendition } from '@vertesia/common';
+import { exec } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { promisify } from 'util';
+import { setupActivity } from '../../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError, InvalidContentTypeError } from '../../errors.js';
+import { saveBlobToTempFile } from '../../utils/blobs.js';
+import { VertesiaClient } from '@vertesia/client';
+import { RequestError } from '@vertesia/api-fetch-client';
+
+const execAsync = promisify(exec);
+
+// Default configuration constants
+const DEFAULT_AUDIO_BITRATE = '128k'; // Default audio bitrate for AAC encoding
+const FFMPEG_MAX_BUFFER = 1024 * 1024 * 10; // 10MB buffer for ffmpeg output
+
+export interface PrepareAudioParams {
+    audioBitrate?: string; // Audio bitrate for AAC encoding, default '128k'
+}
+
+export interface PrepareAudio extends DSLActivitySpec<PrepareAudioParams> {
+    name: 'prepareAudio';
+}
+
+interface AudioMetadataExtended {
+    duration: number;
+    codec: string;
+    bitrate: number;
+    sampleRate: number;
+    channels: number;
+}
+
+interface FFProbeStream {
+    codec_type: string;
+    codec_name?: string;
+    sample_rate?: string;
+    channels?: number;
+    bit_rate?: string;
+}
+
+interface FFProbeFormat {
+    duration?: string;
+    bit_rate?: string;
+}
+
+interface FFProbeOutput {
+    streams: FFProbeStream[];
+    format: FFProbeFormat;
+}
+
+export interface PrepareAudioMetadata {
+    duration: number;
+    codec: string;
+    bitrate: number;
+    sampleRate: number;
+    channels: number;
+}
+
+export interface PrepareAudioResult {
+    objectId: string;
+    metadata: PrepareAudioMetadata;
+    renditions: Rendition[];
+    status: 'success';
+}
+
+/**
+ * Extract comprehensive audio metadata using ffprobe
+ */
+async function getAudioMetadata(audioPath: string): Promise<AudioMetadataExtended> {
+    try {
+        const command = `ffprobe -v quiet -print_format json -show_format -show_streams "${audioPath}"`;
+        const { stdout } = await execAsync(command);
+        const metadata = JSON.parse(stdout) as FFProbeOutput;
+
+        const audioStream = metadata.streams.find(
+            (stream) => stream.codec_type === 'audio',
+        );
+
+        if (!audioStream) {
+            throw new Error('No audio stream found in file');
+        }
+
+        const duration = parseFloat(metadata.format.duration ?? '0') || 0;
+        const codec = audioStream.codec_name || 'unknown';
+        const bitrate = parseInt(audioStream.bit_rate ?? metadata.format.bit_rate ?? '0', 10) || 0;
+        const sampleRate = parseInt(audioStream.sample_rate ?? '0', 10) || 0;
+        const channels = audioStream.channels || 0;
+
+        return { duration, codec, bitrate, sampleRate, channels };
+    } catch (error) {
+        log.error(
+            `Failed to get audio metadata: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        );
+        throw new Error(
+            `Failed to probe audio metadata: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        );
+    }
+}
+
+/**
+ * Generate a web-compatible audio rendition (AAC in M4A container)
+ * Ensures broad browser compatibility for HTML5 audio playback
+ */
+async function generateAudioRendition(
+    audioPath: string,
+    outputDir: string,
+    audioBitrate: string,
+): Promise<string | null> {
+    const outputFile = path.join(outputDir, 'audio.m4a');
+
+    const command = [
+        'ffmpeg',
+        '-y', // Overwrite output
+        '-i', `"${audioPath}"`,
+        '-c:a', 'aac', // AAC codec
+        '-b:a', audioBitrate, // Audio bitrate
+        '-movflags', '+faststart', // Enable streaming
+        `"${outputFile}"`,
+    ].join(' ');
+
+    log.info('Generating web audio rendition (AAC M4A)', { command, audioBitrate });
+
+    try {
+        const { stderr } = await execAsync(command, { maxBuffer: FFMPEG_MAX_BUFFER });
+
+        if (stderr && !stderr.includes('frame=')) {
+            log.debug(`FFmpeg stderr for audio rendition: ${stderr}`);
+        }
+
+        // Verify output file was created
+        try {
+            await fs.promises.access(outputFile, fs.constants.F_OK);
+            log.info(`Generated web audio rendition: ${outputFile}`);
+            return outputFile;
+        } catch {
+            log.warn('Audio rendition not generated');
+            return null;
+        }
+    } catch (error) {
+        log.error(
+            `Failed to generate audio rendition: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        );
+        return null;
+    }
+}
+
+/**
+ * Upload a file to the storage and return its URI
+ */
+async function uploadFile(
+    client: VertesiaClient,
+    filePath: string,
+    mimeType: string,
+    fileName: string,
+    storagePath: string,
+): Promise<string> {
+    const { NodeStreamSource } = await import('@vertesia/client/node');
+    const fileStream = fs.createReadStream(filePath);
+    const source = new NodeStreamSource(fileStream, fileName, mimeType, storagePath);
+
+    const result = await client.files.uploadFile(source);
+    log.info(`Uploaded file to ${storagePath}`, { result });
+
+    return result;
+}
+
+/**
+ * Upload audio file and create a rendition entry
+ */
+async function uploadAudioAsRendition(
+    client: VertesiaClient,
+    audioFile: string,
+    renditionName: string,
+    fileName: string,
+    mimeType: string,
+    etag: string,
+): Promise<Rendition> {
+    const storagePath = `renditions/${etag}/audio/${fileName}`;
+    const uri = await uploadFile(client, audioFile, mimeType, fileName, storagePath);
+
+    return {
+        name: renditionName,
+        content: {
+            source: uri,
+            type: mimeType,
+            name: fileName,
+        },
+    };
+}
+
+/**
+ * Main activity: Prepare audio by extracting metadata and generating web rendition
+ */
+export async function prepareAudio(
+    payload: DSLActivityExecutionPayload<PrepareAudioParams>,
+): Promise<PrepareAudioResult> {
+    const {
+        client,
+        objectId,
+        params,
+    } = await setupActivity<PrepareAudioParams>(payload);
+
+    const audioBitrate = params.audioBitrate ?? DEFAULT_AUDIO_BITRATE;
+
+    log.info(`Preparing audio for ${objectId}`, { audioBitrate });
+
+    // Retrieve the content object
+    const inputObject = await client.objects.retrieve(objectId).catch((err: unknown) => {
+        log.error(`Failed to retrieve document ${objectId}`, { err });
+        if (err instanceof RequestError && err.status === 404) {
+            throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
+        }
+        throw err;
+    });
+
+    if (!inputObject.content?.source) {
+        log.error(`Document ${objectId} has no source`);
+        throw new DocumentNotFoundError(`Document ${objectId} has no source`, [objectId]);
+    }
+
+    if (!inputObject.content.type || !inputObject.content.type.startsWith('audio/')) {
+        log.error(`Document ${objectId} is not an audio file: ${inputObject.content.type}`);
+        throw new InvalidContentTypeError(
+            objectId,
+            'audio/*',
+            inputObject.content.type || 'unknown',
+        );
+    }
+
+    // Download audio to temp file
+    const audioFile = await saveBlobToTempFile(client, inputObject.content.source);
+    const tempOutputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prepare-audio-'));
+
+    try {
+        // Step 1: Extract audio metadata
+        log.info('Extracting audio metadata');
+        const metadata = await getAudioMetadata(audioFile);
+
+        // Step 2: Generate web audio rendition (AAC M4A)
+        log.info('Generating web audio rendition');
+        const renditionFile = await generateAudioRendition(
+            audioFile,
+            tempOutputDir,
+            audioBitrate,
+        );
+
+        // Step 3: Upload generated rendition
+        const renditions: Rendition[] = [];
+        const etag = inputObject.content.etag ?? inputObject.id;
+
+        if (renditionFile) {
+            const audioRendition = await uploadAudioAsRendition(
+                client,
+                renditionFile,
+                AUDIO_RENDITION_NAME,
+                'audio.m4a',
+                'audio/mp4',
+                etag,
+            );
+            renditions.push(audioRendition);
+        }
+
+        // Step 4: Update content object with metadata and renditions
+        const audioMetadata: AudioMetadata = {
+            type: ContentNature.Audio,
+            duration: metadata.duration,
+            renditions,
+            generation_runs: inputObject.metadata?.generation_runs || [],
+        };
+
+        await client.objects.update(objectId, {
+            metadata: audioMetadata,
+        });
+
+        log.info(`Successfully prepared audio ${objectId}`, {
+            duration: metadata.duration,
+            codec: metadata.codec,
+            bitrate: metadata.bitrate,
+            sampleRate: metadata.sampleRate,
+            channels: metadata.channels,
+            renditionsGenerated: renditions.length,
+        });
+
+        return {
+            objectId,
+            metadata: {
+                duration: metadata.duration,
+                codec: metadata.codec,
+                bitrate: metadata.bitrate,
+                sampleRate: metadata.sampleRate,
+                channels: metadata.channels,
+            },
+            renditions: renditions,
+            status: 'success',
+        };
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        log.error(`Error preparing audio: ${errorMessage}`, { error });
+
+        // Re-throw known errors as-is
+        if (error instanceof DocumentNotFoundError || error instanceof InvalidContentTypeError) {
+            throw error;
+        }
+
+        // Wrap unknown errors in Error
+        throw new Error(
+            `Failed to prepare audio ${objectId}: ${errorMessage}`,
+        );
+    } finally {
+        // Clean up temporary files
+        const cleanupPromises: Promise<void>[] = [];
+
+        if (audioFile) {
+            cleanupPromises.push(
+                fs.promises.unlink(audioFile).catch((err) => {
+                    log.warn(`Failed to cleanup audio file: ${audioFile}`, { err });
+                }),
+            );
+        }
+
+        if (tempOutputDir) {
+            cleanupPromises.push(
+                fs.promises.rm(tempOutputDir, { recursive: true, force: true }).catch((err) => {
+                    log.warn(`Failed to cleanup temp directory: ${tempOutputDir}`, { err });
+                }),
+            );
+        }
+
+        await Promise.allSettled(cleanupPromises);
+    }
+}

package/src/activities/mergeChildArtifacts.ts

@@ -0,0 +1,189 @@
+import { log } from "@temporalio/activity";
+import { NodeStreamSource } from "@vertesia/client/node";
+import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { Readable } from "stream";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+
+/**
+ * Directories to merge from child to parent.
+ * Only out/ and files/ are merged to avoid overwriting parent's scripts/skills.
+ */
+const MERGE_DIRECTORIES = ['out', 'files'];
+
+/**
+ * Files that should never be merged.
+ */
+const EXCLUDED_FILES = ['conversation.json', 'tools.json'];
+
+export interface MergeChildArtifactsParams {
+    child_run_id: string;
+    parent_run_id: string;
+    directories?: string[];  // defaults to MERGE_DIRECTORIES
+}
+
+export interface MergeChildArtifacts extends DSLActivitySpec<MergeChildArtifactsParams> {
+    name: 'mergeChildArtifacts';
+    projection?: never;
+}
+
+/**
+ * Merge artifacts from child workflow's agent space to parent workflow's agent space.
+ *
+ * Files are namespaced by child run ID to avoid conflicts:
+ * - Child's `files/output.json` → Parent's `files/{childRunId}/output.json`
+ * - Child's `out/report.pdf` → Parent's `out/{childRunId}/report.pdf`
+ *
+ * Returns the list of merged paths in the parent's space for the model to access.
+ */
+export async function mergeChildArtifacts(
+    payload: DSLActivityExecutionPayload<MergeChildArtifactsParams>
+): Promise<{ merged: number; files: string[] }> {
+    const { client, params } = await setupActivity<MergeChildArtifactsParams>(payload);
+    const childRunId = params.child_run_id;
+    const parentRunId = params.parent_run_id;
+    const directories = params.directories || MERGE_DIRECTORIES;
+
+    log.info(`Merging artifacts from child ${childRunId} to parent ${parentRunId}`, { directories });
+
+    // List all files in child's agent space
+    const childFiles = await client.files.listArtifacts(childRunId);
+
+    if (childFiles.length === 0) {
+        log.info("No artifacts in child agent space");
+        return { merged: 0, files: [] };
+    }
+
+    const mergedFiles: string[] = [];
+
+    for (const fullPath of childFiles) {
+        const relativePath = extractRelativePath(fullPath, childRunId);
+        if (!relativePath) continue;
+
+        // Only merge specified directories
+        const dir = relativePath.split('/')[0];
+        if (!directories.includes(dir)) continue;
+
+        // Skip excluded files
+        const fileName = relativePath.split('/').pop() || '';
+        if (EXCLUDED_FILES.includes(fileName)) continue;
+
+        try {
+            // Create namespaced path: files/output.json -> files/{childRunId}/output.json
+            const namespacedPath = createNamespacedPath(relativePath, childRunId);
+            await copyArtifact(client, childRunId, parentRunId, relativePath, namespacedPath);
+            mergedFiles.push(namespacedPath);
+        } catch (err: any) {
+            log.warn(`Failed to merge ${relativePath}: ${err.message}`);
+        }
+    }
+
+    log.info(`Merged ${mergedFiles.length} artifacts from child to parent`, { files: mergedFiles });
+    return { merged: mergedFiles.length, files: mergedFiles };
+}
+
+/**
+ * Create a namespaced path by inserting the child run ID after the directory.
+ * files/output.json -> files/{childRunId}/output.json
+ * out/subdir/report.pdf -> out/{childRunId}/subdir/report.pdf
+ */
+function createNamespacedPath(relativePath: string, childRunId: string): string {
+    const parts = relativePath.split('/');
+    if (parts.length < 2) {
+        // Single file at root (shouldn't happen, but handle it)
+        return `${childRunId}/${relativePath}`;
+    }
+    // Insert childRunId after the first directory
+    const dir = parts[0];
+    const rest = parts.slice(1).join('/');
+    return `${dir}/${childRunId}/${rest}`;
+}
+
+/**
+ * Extract relative path from full artifact storage path.
+ * Storage paths can be: "store_xxx/agents/{runId}/..." or "agents/{runId}/..."
+ */
+function extractRelativePath(fullPath: string, runId: string): string | null {
+    // Look for the pattern: agents/{runId}/
+    const marker = `/agents/${runId}/`;
+    const idx = fullPath.lastIndexOf(marker);
+    if (idx >= 0) {
+        return fullPath.slice(idx + marker.length);
+    }
+
+    // Also try without leading slash
+    const legacyPrefix = `agents/${runId}/`;
+    if (fullPath.startsWith(legacyPrefix)) {
+        return fullPath.slice(legacyPrefix.length);
+    }
+
+    // If path contains the runId, try to extract after it
+    const runIdIdx = fullPath.indexOf(runId);
+    if (runIdIdx >= 0) {
+        const afterRunId = fullPath.slice(runIdIdx + runId.length);
+        if (afterRunId.startsWith('/')) {
+            return afterRunId.slice(1);
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Copy a single artifact from child to parent agent space with a new path
+ */
+async function copyArtifact(
+    client: any,
+    childRunId: string,
+    parentRunId: string,
+    sourcePath: string,
+    destPath: string
+): Promise<void> {
+    // Download from child's agent space
+    const stream = await client.files.downloadArtifact(childRunId, sourcePath);
+
+    // Convert web stream to node stream for upload
+    const nodeStream = Readable.fromWeb(stream as any);
+
+    // Determine mime type from extension
+    const mimeType = getMimeType(sourcePath);
+    const fileName = sourcePath.split('/').pop() || sourcePath;
+
+    // Upload to parent's agent space at the namespaced path
+    const source = new NodeStreamSource(
+        nodeStream,
+        fileName,
+        mimeType
+    );
+
+    await client.files.uploadArtifact(parentRunId, destPath, source);
+}
+
+/**
+ * Get mime type from file extension
+ */
+function getMimeType(filePath: string): string {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const mimeTypes: Record<string, string> = {
+        'json': 'application/json',
+        'txt': 'text/plain',
+        'md': 'text/markdown',
+        'html': 'text/html',
+        'csv': 'text/csv',
+        'png': 'image/png',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'gif': 'image/gif',
+        'svg': 'image/svg+xml',
+        'pdf': 'application/pdf',
+        'xml': 'application/xml',
+        'zip': 'application/zip',
+        'js': 'application/javascript',
+        'ts': 'application/typescript',
+        'py': 'text/x-python',
+        'sh': 'text/x-shellscript',
+        'bash': 'text/x-shellscript',
+        'yaml': 'text/yaml',
+        'yml': 'text/yaml',
+    };
+    return mimeTypes[ext || ''] || 'application/octet-stream';
+}

package/src/activities/setDocumentStatus.ts

@@ -1,3 +1,4 @@
+import { log } from "@temporalio/activity";
 import { ContentObjectStatus, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
 
@@ -18,8 +19,15 @@ export interface SetDocumentStatus extends DSLActivitySpec<SetDocumentStatusPara
 export async function setDocumentStatus(payload: DSLActivityExecutionPayload<SetDocumentStatusParams>) {
     const { client, params, objectId } = await setupActivity<SetDocumentStatusParams>(payload);
 
-    const res = await client.objects.update(objectId, { status: params.status });
-
-    return res.status;
-
+    try {
+        const res = await client.objects.update(objectId, { status: params.status });
+        return res.status;
+    } catch (err: any) {
+        // If document was deleted, nothing to update - log warning and continue
+        if (err.status === 404 || err.name === 'ZenoClientNotFoundError') {
+            log.warn(`Document ${objectId} not found - may have been deleted. Skipping status update to '${params.status}'`);
+            return undefined; // Signal that document wasn't found
+        }
+        throw err;
+    }
 }

package/src/dsl/dsl-workflow.ts

@@ -153,6 +153,10 @@ async function handleError(originalError: any, basePayload: BaseActivityPayload,
 }
 
 async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkflowExecutionPayload, vars: Vars, debug_mode?: boolean) {
+    if (step.condition && !vars.match(step.condition)) {
+        log.info("Child workflow skipped: condition not satisfied", { workflow: step.name, condition: step.condition });
+        return;
+    }
     const resolvedVars = vars.resolve();
     if (step.vars) {
         // copy user vars (from step definition) to the resolved vars, resolving any expressions
@@ -162,12 +166,13 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
     if (debug_mode) {
         log.debug(`Workflow vars before starting child workflow ${step.name}`, { vars: resolvedVars });
     }
+
     const handle = await startChild(step.name, {
         ...step.options,
         args: [{
             ...payload,
             workflow: step.spec,
-            vars: resolvedVars
+            vars: resolvedVars,
         }],
         memo: {
             InitiatedBy: payload.initiated_by,
@@ -186,6 +191,10 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
 }
 
 async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkflowExecutionPayload, vars: Vars, debug_mode?: boolean) {
+    if (step.condition && !vars.match(step.condition)) {
+        log.info("Child workflow skipped: condition not satisfied", { workflow: step.name, condition: step.condition });
+        return;
+    }
     const resolvedVars = vars.resolve();
     if (step.vars) {
         // copy user vars (from step definition) to the resolved vars, resolving any expressions
@@ -195,6 +204,7 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
     if (debug_mode) {
         log.debug(`Workflow vars before executing child workflow ${step.name}`, { vars: resolvedVars });
     }
+
     const result = await executeChild(step.name, {
         ...step.options,
         args: [{

package/src/errors.ts

@@ -78,10 +78,25 @@ export class InvalidContentTypeError extends ApplicationFailure {
     }
 }
 
+export class TokenExpiredError extends ApplicationFailure {
+    constructor(
+        public statusCode: number,
+        message?: string,
+    ) {
+        super(
+            message || "Token expired: Authentication required",
+            "TokenExpiredError",
+            true, // non-retryable
+        );
+    }
+}
+
 export const WF_NON_RETRYABLE_ERRORS = [
     "DocumentNotFoundError",
     "ActivityParamInvalidError",
     "ActivityParamNotFoundError",
     "WorkflowParamNotFoundError",
     "InvalidContentTypeError",
+    "TokenExpiredError",
+    "ZenoClientNotFoundError",
 ];

package/src/index.ts

@@ -26,6 +26,7 @@ export * from "./activities/rateLimiter.js";
 export * from "./activities/setDocumentStatus.js";
 export * from "./iterative-generation/activities/index.js";
 export * from "./activities/media/prepareVideo.js";
+export * from "./activities/media/prepareAudio.js";
 
 export * from "./dsl/setup/ActivityContext.js";
 export * from "./errors.js";

package/lib/cjs/activities/advanced/createDocumentTypeFromInteractionRun.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDocumentTypeFromInteractionRun = createDocumentTypeFromInteractionRun;
-const activity_1 = require("@temporalio/activity");
-const client_1 = require("@vertesia/client");
-const projections_js_1 = require("../../dsl/projections.js");
-const ActivityContext_js_1 = require("../../dsl/setup/ActivityContext.js");
-const errors_js_1 = require("../../errors.js");
-async function createDocumentTypeFromInteractionRun(payload) {
-    const { params, client } = await (0, ActivityContext_js_1.setupActivity)(payload);
-    if (!params.run) {
-        throw new errors_js_1.ActivityParamNotFoundError("run", payload.activity);
-    }
-    const jsonResult = client_1.InteractionOutput.from(params.run.result).object();
-    if (!jsonResult.document_type) {
-        activity_1.log.error("No name generated for type: " + JSON.stringify(jsonResult), jsonResult);
-        throw new Error("No name generated for type");
-    }
-    activity_1.log.info("Generated schema for type", jsonResult.metadata_schema);
-    const typeData = {
-        name: jsonResult.document_type,
-        object_schema: jsonResult.metadata_schema,
-        is_chunkable: !!jsonResult.is_chunkable,
-    };
-    const type = await client.types.create(typeData);
-    if (params.updateObjectId) {
-        await client.objects.update(params.updateObjectId, {
-            type: type.id,
-        });
-    }
-    return (0, projections_js_1.projectResult)(payload, params, type, { id: type.id, name: type.name });
-}
-//# sourceMappingURL=createDocumentTypeFromInteractionRun.js.map

package/lib/cjs/activities/advanced/createDocumentTypeFromInteractionRun.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createDocumentTypeFromInteractionRun.js","sourceRoot":"","sources":["../../../../src/activities/advanced/createDocumentTypeFromInteractionRun.ts"],"names":[],"mappings":";;AAwBA,oFA8BC;AAtDD,mDAA2C;AAC3C,6CAAqD;AAErD,6DAAyD;AACzD,2EAAmE;AACnE,+CAA6D;AAmBtD,KAAK,UAAU,oCAAoC,CAAC,OAAgF;IACvI,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,IAAA,kCAAa,EAA6C,OAAO,CAAC,CAAC;IAEpG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QACd,MAAM,IAAI,sCAA0B,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,UAAU,GAAG,0BAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;IAEtE,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;QAC5B,cAAG,CAAC,KAAK,CAAC,8BAA8B,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC;QACnF,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAClD,CAAC;IAED,cAAG,CAAC,IAAI,CAAC,2BAA2B,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IAClE,MAAM,QAAQ,GAAmC;QAC7C,IAAI,EAAE,UAAU,CAAC,aAAa;QAC9B,aAAa,EAAE,UAAU,CAAC,eAAe;QACzC,YAAY,EAAE,CAAC,CAAC,UAAU,CAAC,YAAY;KAC1C,CAAA;IAED,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAEjD,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;QACxB,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,EAAE;SAChB,CAAC,CAAC;IACP,CAAC;IAED,OAAO,IAAA,8BAAa,EAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;AAClF,CAAC"}