@acorex/components 21.0.3-next.21 → 21.0.3-next.22

package/fesm2022/acorex-components-conversation2.mjs

@@ -3,14 +3,14 @@ import { AXTabsComponent, AXTabItemComponent } from '@acorex/components/tabs';
 import * as i1$4 from '@angular/common';
 import { isPlatformBrowser, AsyncPipe, CommonModule, NgComponentOutlet, DOCUMENT } from '@angular/common';
 import * as i0 from '@angular/core';
-import { InjectionToken, signal, computed, inject, Injectable, input, output, ChangeDetectionStrategy, Component, model, ElementRef, afterNextRender, PLATFORM_ID, DestroyRef, Injector, runInInjectionContext, effect, viewChild, untracked, viewChildren, SecurityContext, ViewContainerRef, EventEmitter, HostListener, Directive, NgModule } from '@angular/core';
+import { Injectable, InjectionToken, signal, computed, inject, input, output, ChangeDetectionStrategy, Component, model, ElementRef, afterNextRender, PLATFORM_ID, DestroyRef, Injector, runInInjectionContext, effect, viewChild, untracked, viewChildren, SecurityContext, ViewContainerRef, EventEmitter, HostListener, Directive, NgModule } from '@angular/core';
+import { AXUploaderBrowseDirective, AXUploaderZoneDirective, AXUploaderService } from '@acorex/cdk/uploader';
 import { AXDialogService } from '@acorex/components/dialog';
 import { AXPopupService } from '@acorex/components/popup';
+import { createFileTypeMetadata, AXFileTypeInfoProvider, resolveFileTypeExtension, runFileTypeUtility, formatFileSizeBytes, AXFileService, AXFileTypeRegistryService, runFileTypeUtilityForFile, provideFileValidationRules, provideFileTypeInfoProvider, getFileExtension, runFileTypeCopy, resolveFileCopyText, runFileTypeOpen } from '@acorex/core/file';
 import * as i3 from '@acorex/core/translation';
 import { translateSync, AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
 import { Subject, BehaviorSubject, Observable, filter, firstValueFrom, takeUntil, catchError, EMPTY } from 'rxjs';
-import { AXUploaderBrowseDirective, AXUploaderZoneDirective, AXUploaderService } from '@acorex/cdk/uploader';
-import { createFileTypeMetadata, AXFileTypeInfoProvider, resolveFileTypeExtension, runFileTypeUtility, formatFileSizeBytes, AXFileService, AXFileTypeRegistryService, runFileTypeUtilityForFile, provideFileValidationRules, provideFileTypeInfoProvider, getFileExtension, runFileTypeCopy, resolveFileCopyText, runFileTypeOpen } from '@acorex/core/file';
 import * as i1$2 from '@acorex/components/progress-bar';
 import { AXProgressBarModule } from '@acorex/components/progress-bar';
 import { AXToastService } from '@acorex/components/toast';
@@ -260,163 +260,6 @@ class AXUserApi {
  */
 // Shared types
 
-/**
- * Conversation Configuration Interface
- * Centralized configuration values to avoid magic numbers
- */
-
-/**
- * Default Configuration Values
- * Centralized defaults to avoid magic numbers throughout the codebase
- */
-/**
- * Default conversation configuration
- * All values are explicitly defined here for easy maintenance and documentation
- */
-const AX_DEFAULT_CONVERSATION_CONFIG = {
-    // Pagination
-    messagePageSize: 30,
-    conversationPageSize: 20,
-    // Scroll Configuration
-    scrollThreshold: 100,
-    infiniteScrollThreshold: 200,
-    // Timeout Durations (milliseconds)
-    typingIndicatorTimeout: 3000,
-    typingIndicatorThrottle: 1000,
-    messageHighlightDuration: 2000,
-    debounceSearch: 300,
-    // Message Storage Limits
-    maxMessagesPerConversation: 1000,
-    maxTotalMessages: 10000,
-    maxCachedConversations: 50,
-    // UI Dimensions (pixels)
-    minSidebarWidth: 250,
-    maxSidebarWidth: 500,
-    defaultSidebarWidth: 320,
-    // Cache
-    filterCacheSize: 100,
-    // Message Validation
-    maxMessageLength: 10000,
-    minMessageLength: 1,
-    maxFilesPerMessage: 3,
-    // Intersection Observer
-    messageReadThreshold: 0.3,
-    // Message list
-    messageListBackground: '',
-};
-/**
- * Helper function to merge user config with defaults
- * Properly handles array merging to avoid reference issues
- * @param userConfig - User-provided configuration
- * @returns Merged configuration with all required fields
- */
-function mergeWithDefaults(userConfig) {
-    if (!userConfig) {
-        return { ...AX_DEFAULT_CONVERSATION_CONFIG };
-    }
-    return {
-        ...AX_DEFAULT_CONVERSATION_CONFIG,
-        ...userConfig,
-    };
-}
-
-/**
- * Dependency Injection Tokens
- * InjectionTokens for configuration and dependencies
- */
-/**
- * Configuration token for conversation component
- * Uses centralized defaults from AX_DEFAULT_CONVERSATION_CONFIG
- */
-const CONVERSATION_CONFIG = new InjectionToken('CONVERSATION_CONFIG', {
-    providedIn: 'root',
-    factory: () => mergeWithDefaults(),
-});
-/**
- * Token for configuring AXErrorHandlerService
- */
-const ERROR_HANDLER_CONFIG = new InjectionToken('ERROR_HANDLER_CONFIG', {
-    providedIn: 'root',
-    factory: () => ({}),
-});
-
-/**
- * Pluggable avatar components for the conversation UI.
- * Register via `provideConversation({ avatarComponents: { user, conversation } })`.
- */
-const AX_CONVERSATION_USER_AVATAR_COMPONENT = new InjectionToken('AX_CONVERSATION_USER_AVATAR_COMPONENT');
-const AX_CONVERSATION_CONVERSATION_AVATAR_COMPONENT = new InjectionToken('AX_CONVERSATION_CONVERSATION_AVATAR_COMPONENT');
-
-/**
- * Registry Configuration Tokens
- * Injection tokens for configuring default registry values
- */
-/**
- * Additional message renderers configuration
- * Provide this token to add custom message renderers in addition to built-in ones
- * Note: Built-in renderers (text, system, fallback) are registered by default; other types are provided via plugins/constants.
- */
-const DEFAULT_MESSAGE_RENDERERS = new InjectionToken('DEFAULT_MESSAGE_RENDERERS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Default message actions configuration
- * Provide this token to override default message actions
- */
-const DEFAULT_MESSAGE_ACTIONS = new InjectionToken('DEFAULT_MESSAGE_ACTIONS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Default composer tabs configuration
- * Provide this token to override default composer tabs (emoji, stickers, etc.)
- */
-const DEFAULT_COMPOSER_TABS = new InjectionToken('DEFAULT_COMPOSER_TABS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Default composer actions configuration
- * Provide this token to override default composer actions (attach, voice, etc.)
- */
-const DEFAULT_COMPOSER_ACTIONS = new InjectionToken('DEFAULT_COMPOSER_ACTIONS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Default conversation tabs configuration
- * Provide this token to override default conversation tabs (all, private, groups, etc.)
- */
-const DEFAULT_CONVERSATION_TABS = new InjectionToken('DEFAULT_CONVERSATION_TABS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Default info bar actions configuration
- * Provide this token to override default info bar actions (mute, archive, block, etc.)
- */
-const DEFAULT_INFO_BAR_ACTIONS = new InjectionToken('DEFAULT_INFO_BAR_ACTIONS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Default conversation item actions configuration
- * Provide this token to override default conversation item actions (mute, delete, archive, etc.)
- */
-const DEFAULT_CONVERSATION_ITEM_ACTIONS = new InjectionToken('DEFAULT_CONVERSATION_ITEM_ACTIONS', {
-    providedIn: 'root',
-    factory: () => [],
-});
-/**
- * Complete registry configuration token
- * Provide this for comprehensive registry configuration
- */
-const REGISTRY_CONFIG = new InjectionToken('REGISTRY_CONFIG', {
-    providedIn: 'root',
-    factory: () => ({}),
-});
-
 /** Inline or session-only URLs that must not be stored on message payloads or sent to APIs. */
 function isNonPersistableMediaUrl(url) {
     if (!url) {
@@ -463,20 +306,22 @@ function str$3(value) {
 function num$2(value, fallback = 0) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
-function sanitizeAudioItem(item) {
+function sanitizeImageItem(item) {
     const url = resolvePersistableMediaUrl(item.url);
-    if (url === item.url) {
+    const thumbnailUrl = resolvePersistedThumbnailUrl(item.thumbnailUrl, url);
+    if (url === item.url && thumbnailUrl === item.thumbnailUrl) {
         return item;
     }
-    return { ...item, url };
+    return { ...item, url, thumbnailUrl };
 }
-function normalizeAudioPayload(payload) {
+/** Format image message payload for rendering (array shape, safe thumbnails). */
+function normalizeImagePayload(payload) {
     const raw = loose$3(payload);
-    const existing = raw['audios'];
+    const existing = raw['images'];
     if (Array.isArray(existing) && existing.length > 0) {
         return {
-            type: 'audio',
-            audios: existing.map(sanitizeAudioItem),
+            type: 'image',
+            images: existing.map(sanitizeImageItem),
             caption: payload.caption,
         };
     }
@@ -484,24 +329,27 @@ function normalizeAudioPayload(payload) {
     const mediaId = str$3(raw['mediaId']);
     if (url || mediaId) {
         return {
-            type: 'audio',
+            type: 'image',
             caption: payload.caption,
-            audios: [
+            images: [
                 {
                     ...(url ? { url } : {}),
-                    title: str$3(raw['title']),
-                    duration: num$2(raw['duration']),
+                    thumbnailUrl: resolvePersistedThumbnailUrl(str$3(raw['thumbnailUrl']), url),
+                    width: num$2(raw['width']),
+                    height: num$2(raw['height']),
                     mimeType: str$3(raw['mimeType']),
                     size: typeof raw['size'] === 'number' ? raw['size'] : undefined,
                     mediaId,
-                    artist: str$3(raw['artist']),
-                    coverUrl: str$3(raw['coverUrl']),
-                    waveform: Array.isArray(raw['waveform']) ? raw['waveform'] : undefined,
+                    blurhash: str$3(raw['blurhash']),
                 },
             ],
         };
     }
-    return { type: 'audio', audios: [], caption: payload.caption };
+    return { type: 'image', images: [], caption: payload.caption };
+}
+/** Preferred URL for grid / lightbox (never inline base64 thumbnails). */
+function resolveImageDisplayUrl(image) {
+    return resolvePersistedThumbnailUrl(image.thumbnailUrl, image.url) ?? image.url;
 }
 
 function loose$2(payload) {
@@ -510,21 +358,23 @@ function loose$2(payload) {
 function str$2(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
-function sanitizeFileItem(item) {
+function num$1(value, fallback = 0) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function sanitizeAudioItem(item) {
     const url = resolvePersistableMediaUrl(item.url);
-    const thumbnailUrl = resolvePersistedThumbnailUrl(item.thumbnailUrl, url);
-    if (url === item.url && thumbnailUrl === item.thumbnailUrl) {
+    if (url === item.url) {
         return item;
     }
-    return { ...item, url, thumbnailUrl };
+    return { ...item, url };
 }
-function normalizeFilePayload(payload) {
+function normalizeAudioPayload(payload) {
     const raw = loose$2(payload);
-    const existing = raw['files'];
+    const existing = raw['audios'];
     if (Array.isArray(existing) && existing.length > 0) {
         return {
-            type: 'file',
-            files: existing.map(sanitizeFileItem),
+            type: 'audio',
+            audios: existing.map(sanitizeAudioItem),
             caption: payload.caption,
         };
     }
@@ -532,49 +382,207 @@ function normalizeFilePayload(payload) {
     const mediaId = str$2(raw['mediaId']);
     if (url || mediaId) {
         return {
-            type: 'file',
+            type: 'audio',
             caption: payload.caption,
-            files: [
+            audios: [
                 {
                     ...(url ? { url } : {}),
-                    name: str$2(raw['name']) ?? 'file',
-                    mimeType: str$2(raw['mimeType']) ?? 'application/octet-stream',
+                    title: str$2(raw['title']),
+                    duration: num$1(raw['duration']),
+                    mimeType: str$2(raw['mimeType']),
                     size: typeof raw['size'] === 'number' ? raw['size'] : undefined,
                     mediaId,
-                    thumbnailUrl: resolvePersistedThumbnailUrl(str$2(raw['thumbnailUrl']), url),
-                    extension: str$2(raw['extension']),
+                    artist: str$2(raw['artist']),
+                    coverUrl: str$2(raw['coverUrl']),
+                    waveform: Array.isArray(raw['waveform']) ? raw['waveform'] : undefined,
                 },
             ],
         };
     }
-    return { type: 'file', files: [], caption: payload.caption };
+    return { type: 'audio', audios: [], caption: payload.caption };
 }
 
-function loose$1(payload) {
-    return payload;
-}
-function str$1(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
-function num$1(value, fallback = 0) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+function formatDuration(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
 }
-function sanitizeImageItem(item) {
-    const url = resolvePersistableMediaUrl(item.url);
-    const thumbnailUrl = resolvePersistedThumbnailUrl(item.thumbnailUrl, url);
-    if (url === item.url && thumbnailUrl === item.thumbnailUrl) {
-        return item;
+
+const CONVERSATION_AUDIO_CATALOG = 'conversation-audio';
+const MB$4 = 1024 * 1024;
+const CONVERSATION_AUDIO_PRESENTATION = {
+    icon: 'fa-light fa-music text-amber-500',
+    title: 'Audio',
+};
+const AUDIO_UTILITY = {
+    preview: 'preview',
+    duration: 'duration',
+    formatSize: 'formatSize',
+    formatDuration: 'formatDuration',
+    createLocalPreviewUrl: 'createLocalPreviewUrl',
+};
+function blobUrl$4(ctx, blob) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return '';
     }
-    return { ...item, url, thumbnailUrl };
+    return URL.createObjectURL(blob);
 }
-/** Format image message payload for rendering (array shape, safe thumbnails). */
-function normalizeImagePayload(payload) {
+function mediaDuration$2(ctx, file) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return Promise.resolve(0);
+    }
+    return new Promise((resolve, reject) => {
+        const el = document.createElement('audio');
+        el.preload = 'metadata';
+        el.onloadedmetadata = () => {
+            URL.revokeObjectURL(el.src);
+            resolve(el.duration);
+        };
+        el.onerror = () => {
+            URL.revokeObjectURL(el.src);
+            reject(new Error('Failed to load audio metadata'));
+        };
+        el.src = URL.createObjectURL(file);
+    });
+}
+function conversationAudioUtilities() {
+    return {
+        [AUDIO_UTILITY.preview]: (ctx, file) => ctx.readAsDataUrl(file),
+        [AUDIO_UTILITY.duration]: (ctx, file) => mediaDuration$2(ctx, file),
+        [AUDIO_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
+        [AUDIO_UTILITY.formatDuration]: (_ctx, seconds) => formatDuration(seconds),
+        [AUDIO_UTILITY.createLocalPreviewUrl]: (ctx, source) => blobUrl$4(ctx, source),
+    };
+}
+function createConversationAudioFileType() {
+    const presentation = CONVERSATION_AUDIO_PRESENTATION;
+    return {
+        name: CONVERSATION_AUDIO_CATALOG,
+        metadata: createFileTypeMetadata('conversation'),
+        title: presentation.title,
+        icon: presentation.icon,
+        validations: {
+            mimeTypes: ['audio/*'],
+            minSize: 1,
+            maxSize: 50 * MB$4,
+        },
+        extensions: [
+            { name: 'mp3', title: 'MP3' },
+            { name: 'wav', title: 'WAV', validations: { maxSize: 30 * MB$4 } },
+            { name: 'ogg', title: 'OGG' },
+            { name: 'm4a', title: 'M4A' },
+        ],
+        utilities: conversationAudioUtilities(),
+        copy: (payload) => {
+            const audio = normalizeAudioPayload(payload);
+            const caption = audio.caption?.trim();
+            const items = audio.audios.map((item) => ({
+                url: item.url?.trim(),
+                title: item.title?.trim(),
+            }));
+            return {
+                text: caption ?? '',
+                meta: { kind: 'audio', caption, items, count: audio.audios.length },
+            };
+        },
+    };
+}
+class AXConversationAudioFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([createConversationAudioFileType()]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationAudioFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationAudioFileTypeProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationAudioFileTypeProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function audioItemFromUpload(file, result, duration) {
+    const url = resolvePersistableMediaUrl(result.url);
+    const item = {
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        duration,
+        title: file.name,
+        metadata: result.metadata,
+    };
+    if (url) {
+        item.url = url;
+    }
+    return item;
+}
+function mergeAudioUploadResult(payload, result) {
+    const base = normalizeAudioPayload(payload);
+    const audios = [...base.audios];
+    const i = audios.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const slot = i >= 0 ? audios[i] : undefined;
+    const url = resolvePersistableMediaUrl(result.url);
+    const next = {
+        ...(slot ?? { duration: 0 }),
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        metadata: result.metadata,
+    };
+    if (url) {
+        next.url = url;
+    }
+    if (i >= 0)
+        audios[i] = next;
+    else
+        audios.push(next);
+    return { ...base, type: 'audio', audios };
+}
+function applyAudioLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
+    const base = normalizeAudioPayload(payload);
+    const audios = [...base.audios];
+    const slot = audios.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const preview = { url: localUrl, duration: 0, mimeType };
+    if (slot >= 0) {
+        audios[slot] = { ...audios[slot], ...preview };
+    }
+    else if (audios.length === 0) {
+        audios.push(preview);
+    }
+    else {
+        audios[0] = { ...audios[0], ...preview };
+    }
+    return { ...base, type: 'audio', audios };
+}
+
+function loose$1(payload) {
+    return payload;
+}
+function str$1(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function sanitizeFileItem(item) {
+    const url = resolvePersistableMediaUrl(item.url);
+    const thumbnailUrl = resolvePersistedThumbnailUrl(item.thumbnailUrl, url);
+    if (url === item.url && thumbnailUrl === item.thumbnailUrl) {
+        return item;
+    }
+    return { ...item, url, thumbnailUrl };
+}
+function normalizeFilePayload(payload) {
     const raw = loose$1(payload);
-    const existing = raw['images'];
+    const existing = raw['files'];
     if (Array.isArray(existing) && existing.length > 0) {
         return {
-            type: 'image',
-            images: existing.map(sanitizeImageItem),
+            type: 'file',
+            files: existing.map(sanitizeFileItem),
             caption: payload.caption,
         };
     }
@@ -582,28 +590,99 @@ function normalizeImagePayload(payload) {
     const mediaId = str$1(raw['mediaId']);
     if (url || mediaId) {
         return {
-            type: 'image',
+            type: 'file',
             caption: payload.caption,
-            images: [
+            files: [
                 {
                     ...(url ? { url } : {}),
-                    thumbnailUrl: resolvePersistedThumbnailUrl(str$1(raw['thumbnailUrl']), url),
-                    width: num$1(raw['width']),
-                    height: num$1(raw['height']),
-                    mimeType: str$1(raw['mimeType']),
+                    name: str$1(raw['name']) ?? 'file',
+                    mimeType: str$1(raw['mimeType']) ?? 'application/octet-stream',
                     size: typeof raw['size'] === 'number' ? raw['size'] : undefined,
                     mediaId,
-                    blurhash: str$1(raw['blurhash']),
+                    thumbnailUrl: resolvePersistedThumbnailUrl(str$1(raw['thumbnailUrl']), url),
+                    extension: str$1(raw['extension']),
                 },
             ],
         };
     }
-    return { type: 'image', images: [], caption: payload.caption };
+    return { type: 'file', files: [], caption: payload.caption };
 }
-/** Preferred URL for grid / lightbox (never inline base64 thumbnails). */
-function resolveImageDisplayUrl(image) {
-    return resolvePersistedThumbnailUrl(image.thumbnailUrl, image.url) ?? image.url;
+
+const CONVERSATION_IMAGE_CATALOG = 'conversation-image';
+const MB$3 = 1024 * 1024;
+const CONVERSATION_IMAGE_PRESENTATION = {
+    icon: 'fa-light fa-image text-purple-500',
+    title: 'Image',
+};
+const IMAGE_UTILITY = {
+    preview: 'preview',
+    formatSize: 'formatSize',
+    createLocalPreviewUrl: 'createLocalPreviewUrl',
+};
+function blobUrl$3(ctx, blob) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return '';
+    }
+    return URL.createObjectURL(blob);
+}
+function conversationImageUtilities() {
+    return {
+        [IMAGE_UTILITY.preview]: (ctx, file) => ctx.readAsDataUrl(file),
+        [IMAGE_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
+        [IMAGE_UTILITY.createLocalPreviewUrl]: (ctx, source) => {
+            const blob = source;
+            if (blob.type.startsWith('image/')) {
+                return ctx.readAsDataUrl(blob);
+            }
+            return blobUrl$3(ctx, blob);
+        },
+    };
+}
+function createConversationImageFileType() {
+    const presentation = CONVERSATION_IMAGE_PRESENTATION;
+    return {
+        name: CONVERSATION_IMAGE_CATALOG,
+        metadata: createFileTypeMetadata('conversation'),
+        title: presentation.title,
+        icon: presentation.icon,
+        validations: {
+            mimeTypes: ['image/*'],
+            minSize: 1,
+            maxSize: 100 * MB$3,
+        },
+        extensions: [
+            { name: 'jpg', title: 'JPEG' },
+            { name: 'jpeg', title: 'JPEG', validations: { maxSize: 5 * MB$3 } },
+            { name: 'png', title: 'PNG' },
+            { name: 'gif', title: 'GIF' },
+            { name: 'webp', title: 'WebP' },
+            { name: 'svg', title: 'SVG', validations: { maxSize: 2 * MB$3 } },
+        ],
+        utilities: conversationImageUtilities(),
+        copy: (payload) => {
+            const image = normalizeImagePayload(payload);
+            const caption = image.caption?.trim();
+            const urls = image.images
+                .map((item) => item.url?.trim() || item.thumbnailUrl?.trim())
+                .filter((url) => !!url);
+            return {
+                text: caption ?? '',
+                meta: { kind: 'image', caption, urls, count: image.images.length },
+            };
+        },
+    };
 }
+class AXConversationImageFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([createConversationImageFileType()]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationImageFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationImageFileTypeProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationImageFileTypeProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 function loose(payload) {
     return payload;
@@ -655,2173 +734,2097 @@ function normalizeVideoPayload(payload) {
     return { type: 'video', videos: [], caption: payload.caption };
 }
 
-function normalizeMessagePayload(payload) {
-    switch (payload.type) {
-        case 'image':
-            return normalizeImagePayload(payload);
-        case 'video':
-            return normalizeVideoPayload(payload);
-        case 'audio':
-            return normalizeAudioPayload(payload);
-        case 'file':
-            return normalizeFilePayload(payload);
-        default:
-            return payload;
-    }
-}
-
-/**
- * Validation Utilities
- * Centralized validation functions for messages and user input
- */
-/**
- * Validate message text content
- * @param text - Text to validate
- * @param config - Configuration for validation rules
- * @returns Validation result
- */
-function validateMessageText(text, config) {
-    // Check for empty text
-    if (!text || text.trim().length === 0) {
-        return {
-            valid: false,
-            error: 'Message text cannot be empty',
-            errorCode: 'EMPTY_MESSAGE',
-        };
-    }
-    // Check minimum length
-    const minLength = config.minMessageLength ?? 1;
-    if (text.trim().length < minLength) {
-        return {
-            valid: false,
-            error: `Message must be at least ${minLength} character(s)`,
-            errorCode: 'MESSAGE_TOO_SHORT',
-        };
-    }
-    // Check maximum length
-    const maxLength = config.maxMessageLength ?? 10000;
-    if (text.length > maxLength) {
-        return {
-            valid: false,
-            error: `Message exceeds ${maxLength} character limit`,
-            errorCode: 'MESSAGE_TOO_LONG',
-        };
+const CONVERSATION_VIDEO_CATALOG = 'conversation-video';
+const MB$2 = 1024 * 1024;
+const CONVERSATION_VIDEO_PRESENTATION = {
+    icon: 'fa-light fa-video ax-text-blue-500',
+    title: 'Video',
+};
+const VIDEO_UTILITY = {
+    preview: 'preview',
+    duration: 'duration',
+    formatSize: 'formatSize',
+    formatDuration: 'formatDuration',
+    createLocalPreviewUrl: 'createLocalPreviewUrl',
+};
+function blobUrl$2(ctx, blob) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return '';
     }
-    return { valid: true };
+    return URL.createObjectURL(blob);
 }
-/**
- * Validate conversation ID
- * @param conversationId - Conversation ID to validate
- * @returns Validation result
- */
-function validateConversationId(conversationId) {
-    if (!conversationId || typeof conversationId !== 'string' || conversationId.trim().length === 0) {
-        return {
-            valid: false,
-            error: 'Conversation ID is required',
-            errorCode: 'MISSING_CONVERSATION_ID',
-        };
+function mediaDuration$1(ctx, file, tag) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return Promise.resolve(0);
     }
-    // Check for reasonable length
-    if (conversationId.length > 255) {
-        return {
-            valid: false,
-            error: 'Conversation ID is too long',
-            errorCode: 'MISSING_CONVERSATION_ID',
+    return new Promise((resolve, reject) => {
+        const el = document.createElement(tag);
+        el.preload = 'metadata';
+        el.onloadedmetadata = () => {
+            URL.revokeObjectURL(el.src);
+            resolve(el.duration);
         };
-    }
-    return { valid: true };
-}
-/**
- * Validate message type
- * @param type - Message type to validate
- * @returns Validation result
- */
-function validateMessageType(type) {
-    if (!type || type.trim().length === 0) {
-        return {
-            valid: false,
-            error: 'Message type is required',
-            errorCode: 'MISSING_MESSAGE_TYPE',
+        el.onerror = () => {
+            URL.revokeObjectURL(el.src);
+            reject(new Error(`Failed to load ${tag} metadata`));
         };
-    }
-    return { valid: true };
+        el.src = URL.createObjectURL(file);
+    });
 }
-function validateMediaItems(items, label) {
-    if (!Array.isArray(items) || items.length === 0) {
-        return {
-            valid: false,
-            error: `${label} message must include at least one attachment`,
-            errorCode: 'INVALID_MEDIA_PAYLOAD',
-        };
-    }
-    for (const item of items) {
-        const ok = (typeof item.url === 'string' && item.url.length > 0) ||
-            (typeof item.mediaId === 'string' && item.mediaId.length > 0);
-        if (!ok) {
+function conversationVideoUtilities() {
+    return {
+        [VIDEO_UTILITY.preview]: (ctx, file) => ctx.readAsDataUrl(file),
+        [VIDEO_UTILITY.duration]: (ctx, file) => mediaDuration$1(ctx, file, 'video'),
+        [VIDEO_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
+        [VIDEO_UTILITY.formatDuration]: (_ctx, seconds) => formatDuration(seconds),
+        [VIDEO_UTILITY.createLocalPreviewUrl]: async (ctx, source) => {
+            const blob = source;
+            if (blob.type.startsWith('image/')) {
+                return ctx.readAsDataUrl(blob);
+            }
+            return blobUrl$2(ctx, blob);
+        },
+    };
+}
+function createConversationVideoFileType() {
+    const presentation = CONVERSATION_VIDEO_PRESENTATION;
+    return {
+        name: CONVERSATION_VIDEO_CATALOG,
+        metadata: createFileTypeMetadata('conversation'),
+        title: presentation.title,
+        icon: presentation.icon,
+        validations: {
+            mimeTypes: ['video/*'],
+            minSize: 1,
+            maxSize: 500 * MB$2,
+        },
+        extensions: [
+            { name: 'mp4', title: 'MP4' },
+            { name: 'webm', title: 'WebM', validations: { maxSize: 200 * MB$2 } },
+            { name: 'ogg', title: 'OGG' },
+        ],
+        utilities: conversationVideoUtilities(),
+        copy: (payload) => {
+            const video = normalizeVideoPayload(payload);
+            const caption = video.caption?.trim();
+            const urls = video.videos.map((item) => item.url?.trim()).filter((url) => !!url);
             return {
-                valid: false,
-                error: `Each ${label.toLowerCase()} attachment must have a url or mediaId`,
-                errorCode: 'INVALID_MEDIA_PAYLOAD',
+                text: caption ?? '',
+                meta: { kind: 'video', caption, urls, count: video.videos.length },
             };
-        }
+        },
+    };
+}
+class AXConversationVideoFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([createConversationVideoFileType()]);
     }
-    return { valid: true };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVideoFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVideoFileTypeProvider, providedIn: 'root' }); }
 }
-/**
- * Validate message payload
- * @param payload - Message payload to validate
- * @param type - Message type
- * @returns Validation result
- */
-function validateMessagePayload(payload, type) {
-    if (!payload) {
-        return {
-            valid: false,
-            error: 'Message payload is required',
-            errorCode: 'MISSING_PAYLOAD',
-        };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVideoFileTypeProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const CONVERSATION_FILE_CATALOG = 'conversation-file';
+const MB$1 = 1024 * 1024;
+const CONVERSATION_FILE_PRESENTATION = {
+    icon: 'fa-light fa-file text-neutral-500',
+    title: 'File',
+};
+const CONVERSATION_FILE_ALLOWED_MIME_TYPES = [
+    'image/*',
+    'video/*',
+    'audio/*',
+    'application/pdf',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/zip',
+    'application/x-zip-compressed',
+    'application/x-7z-compressed',
+    'application/vnd.rar',
+    'application/octet-stream',
+    'text/plain',
+];
+const FILE_UTILITY = {
+    preview: 'preview',
+    formatSize: 'formatSize',
+    createLocalPreviewUrl: 'createLocalPreviewUrl',
+    pickerCatalog: 'pickerCatalog',
+};
+function blobUrl$1(ctx, blob) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return '';
     }
-    const normalized = type === 'image' || type === 'video' || type === 'audio' || type === 'file'
-        ? normalizeMessagePayload(payload)
-        : payload;
-    // Type-specific validation
-    switch (type) {
-        case 'text':
-            if (!('text' in payload) || typeof payload.text !== 'string') {
-                return {
-                    valid: false,
-                    error: 'Text message must have a text property',
-                    errorCode: 'INVALID_TEXT_PAYLOAD',
-                };
-            }
-            break;
-        case 'image':
-            return validateMediaItems(normalized.images, 'Image');
-        case 'video':
-            return validateMediaItems(normalized.videos, 'Video');
-        case 'audio':
-            return validateMediaItems(normalized.audios, 'Audio');
-        case 'file':
-            return validateMediaItems(normalized.files, 'File');
-        case 'voice':
-        case 'sticker': {
-            const media = payload;
-            const hasUrl = typeof media.url === 'string' && media.url.length > 0;
-            const hasMediaId = typeof media.mediaId === 'string' && media.mediaId.length > 0;
-            if (!hasUrl && !hasMediaId) {
-                return {
-                    valid: false,
-                    error: `${type} message must have a url or mediaId`,
-                    errorCode: 'INVALID_MEDIA_PAYLOAD',
-                };
+    return URL.createObjectURL(blob);
+}
+function conversationFileUtilities() {
+    return {
+        [FILE_UTILITY.preview]: async (ctx, file) => {
+            const f = file;
+            if (f.type.startsWith('image/')) {
+                return ctx.readAsDataUrl(f);
             }
-            break;
-        }
-        case 'location':
-            if (!('latitude' in payload) ||
-                !('longitude' in payload) ||
-                typeof payload.latitude !== 'number' ||
-                typeof payload.longitude !== 'number') {
-                return {
-                    valid: false,
-                    error: 'Location message must have latitude and longitude properties',
-                    errorCode: 'INVALID_LOCATION_PAYLOAD',
-                };
-            }
-            break;
-    }
-    return { valid: true };
+            return undefined;
+        },
+        [FILE_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
+        [FILE_UTILITY.createLocalPreviewUrl]: (ctx, source) => blobUrl$1(ctx, source),
+        [FILE_UTILITY.pickerCatalog]: (_ctx, file) => {
+            const f = file;
+            if (f.type.startsWith('image/'))
+                return CONVERSATION_IMAGE_CATALOG;
+            if (f.type.startsWith('video/'))
+                return CONVERSATION_VIDEO_CATALOG;
+            if (f.type.startsWith('audio/'))
+                return CONVERSATION_AUDIO_CATALOG;
+            return CONVERSATION_FILE_CATALOG;
+        },
+    };
 }
-/**
- * Validate user ID
- * @param userId - User ID to validate
- * @returns Validation result
- */
-function validateUserId(userId) {
-    if (!userId || typeof userId !== 'string' || userId.trim().length === 0) {
-        return {
-            valid: false,
-            error: 'User ID is required',
-            errorCode: 'MISSING_USER_ID',
-        };
+function createConversationFileFileType() {
+    const presentation = CONVERSATION_FILE_PRESENTATION;
+    return {
+        name: CONVERSATION_FILE_CATALOG,
+        metadata: createFileTypeMetadata('conversation'),
+        title: presentation.title,
+        icon: presentation.icon,
+        validations: {
+            mimeTypes: [...CONVERSATION_FILE_ALLOWED_MIME_TYPES],
+            minSize: 1,
+            maxSize: 100 * MB$1,
+        },
+        extensions: [
+            { name: 'pdf', title: 'PDF', validations: { mimeTypes: ['application/pdf'], maxSize: 25 * MB$1 } },
+            { name: 'doc', title: 'Word' },
+            { name: 'docx', title: 'Word' },
+            { name: 'txt', title: 'Text', validations: { mimeTypes: ['text/plain'], maxSize: 5 * MB$1 } },
+            {
+                name: 'zip',
+                title: 'ZIP',
+                validations: {
+                    mimeTypes: ['application/zip', 'application/x-zip-compressed', 'application/octet-stream'],
+                    maxSize: 50 * MB$1,
+                },
+            },
+        ],
+        utilities: conversationFileUtilities(),
+        copy: (payload) => {
+            const file = normalizeFilePayload(payload);
+            const caption = file.caption?.trim();
+            const items = file.files.map((item) => {
+                const name = item.name?.trim();
+                const url = item.url?.trim();
+                const line = name && url ? `${name} — ${url}` : url || name;
+                return { name, url, line };
+            });
+            return {
+                text: caption ?? '',
+                meta: { kind: 'file', caption, items, count: file.files.length },
+            };
+        },
+    };
+}
+class AXConversationFileFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([createConversationFileFileType()]);
     }
-    // Check for reasonable length (prevent extremely long IDs)
-    if (userId.length > 255) {
-        return {
-            valid: false,
-            error: 'User ID is too long',
-            errorCode: 'INVALID_USER_ID',
-        };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationFileFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationFileFileTypeProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationFileFileTypeProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function fileItemFromUpload(file, result) {
+    const extension = file.name.includes('.') ? file.name.split('.').pop() : undefined;
+    const url = resolvePersistableMediaUrl(result.url);
+    const item = {
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        name: file.name,
+        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl, url),
+        extension,
+        metadata: result.metadata,
+    };
+    if (url) {
+        item.url = url;
     }
-    return { valid: true };
+    return item;
 }
-/**
- * Validate array of user IDs
- * @param userIds - Array of user IDs to validate
- * @param minCount - Minimum number of users required
- * @param maxCount - Maximum number of users allowed
- * @returns Validation result
- */
-function validateUserIds(userIds, minCount = 1, maxCount) {
-    if (!userIds || !Array.isArray(userIds)) {
-        return {
-            valid: false,
-            error: 'User IDs must be an array',
-            errorCode: 'INVALID_USER_IDS',
-        };
+function mergeFileUploadResult(payload, result) {
+    const base = normalizeFilePayload(payload);
+    const files = [...base.files];
+    const i = files.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const slot = i >= 0 ? files[i] : undefined;
+    const name = slot?.name ?? result.metadata?.['fileName'] ?? 'file';
+    const url = resolvePersistableMediaUrl(result.url);
+    const next = {
+        ...(slot ?? { name, mimeType: result.mimeType }),
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        name,
+        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl ?? slot?.thumbnailUrl, url),
+        metadata: result.metadata,
+    };
+    if (url) {
+        next.url = url;
     }
-    if (userIds.length < minCount) {
-        return {
-            valid: false,
-            error: `At least ${minCount} user(s) required`,
-            errorCode: 'TOO_FEW_USERS',
-        };
+    if (i >= 0)
+        files[i] = next;
+    else
+        files.push(next);
+    return { ...base, type: 'file', files };
+}
+function applyFileLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
+    const base = normalizeFilePayload(payload);
+    const files = [...base.files];
+    const slot = files.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const preview = { url: localUrl, name: 'upload', mimeType };
+    if (slot >= 0) {
+        files[slot] = { ...files[slot], ...preview };
     }
-    if (maxCount && userIds.length > maxCount) {
-        return {
-            valid: false,
-            error: `Maximum ${maxCount} user(s) allowed`,
-            errorCode: 'TOO_MANY_USERS',
-        };
+    else if (files.length === 0) {
+        files.push(preview);
     }
-    // Check for empty or invalid IDs
-    const invalidIds = userIds.filter((id) => !id || id.trim().length === 0);
-    if (invalidIds.length > 0) {
-        return {
-            valid: false,
-            error: 'All user IDs must be non-empty strings',
-            errorCode: 'INVALID_USER_ID',
-        };
+    else {
+        files[0] = { ...files[0], ...preview };
     }
-    return { valid: true };
+    return { ...base, type: 'file', files };
 }
-/**
- * Validate email address
- * @param email - Email to validate
- * @returns Validation result
- */
-function validateEmail(email) {
-    if (!email || email.trim().length === 0) {
-        return {
-            valid: false,
-            error: 'Email is required',
-            errorCode: 'MISSING_EMAIL',
-        };
-    }
-    // Trim whitespace
-    const trimmedEmail = email.trim();
-    // Check length constraints
-    if (trimmedEmail.length > 254) {
-        return {
-            valid: false,
-            error: 'Email is too long',
-            errorCode: 'INVALID_EMAIL',
-        };
+
+function videoItemFromUpload(file, result, duration) {
+    const url = resolvePersistableMediaUrl(result.url);
+    const item = {
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl, url),
+        duration,
+        width: 0,
+        height: 0,
+        metadata: result.metadata,
+    };
+    if (url) {
+        item.url = url;
     }
-    // Enhanced email regex with better validation
-    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-    if (!emailRegex.test(trimmedEmail)) {
-        return {
-            valid: false,
-            error: 'Invalid email format',
-            errorCode: 'INVALID_EMAIL',
-        };
+    return item;
+}
+function mergeVideoUploadResult(payload, result) {
+    const base = normalizeVideoPayload(payload);
+    const videos = [...base.videos];
+    const i = videos.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const slot = i >= 0 ? videos[i] : undefined;
+    const url = resolvePersistableMediaUrl(result.url);
+    const next = {
+        ...(slot ?? { duration: 0, width: 0, height: 0 }),
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl ?? slot?.thumbnailUrl, url),
+        metadata: result.metadata,
+    };
+    if (url) {
+        next.url = url;
     }
-    return { valid: true };
+    if (i >= 0)
+        videos[i] = next;
+    else
+        videos.push(next);
+    return { ...base, type: 'video', videos };
 }
-/**
- * Validate URL
- * @param url - URL to validate
- * @returns Validation result
- */
-function validateUrl(url) {
-    if (!url || url.trim().length === 0) {
-        return {
-            valid: false,
-            error: 'URL is required',
-            errorCode: 'MISSING_URL',
-        };
-    }
-    const trimmedUrl = url.trim();
-    // Check for common URL issues
-    if (trimmedUrl.length > 2048) {
-        return {
-            valid: false,
-            error: 'URL is too long',
-            errorCode: 'INVALID_URL',
-        };
+function applyVideoLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
+    const base = normalizeVideoPayload(payload);
+    const videos = [...base.videos];
+    const slot = videos.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const preview = { url: localUrl, duration: 0, width: 0, height: 0, mimeType };
+    if (slot >= 0) {
+        videos[slot] = { ...videos[slot], ...preview };
     }
-    try {
-        const urlObj = new URL(trimmedUrl);
-        // Validate protocol
-        if (!['http:', 'https:', 'ftp:', 'ftps:'].includes(urlObj.protocol)) {
-            return {
-                valid: false,
-                error: 'Invalid URL protocol',
-                errorCode: 'INVALID_URL',
-            };
-        }
-        return { valid: true };
+    else if (videos.length === 0) {
+        videos.push(preview);
     }
-    catch {
-        return {
-            valid: false,
-            error: 'Invalid URL format',
-            errorCode: 'INVALID_URL',
-        };
+    else {
+        videos[0] = { ...videos[0], ...preview };
     }
+    return { ...base, type: 'video', videos };
 }
-// =====================
-// Helper Functions
-// =====================
-/**
- * Sanitize user input to prevent XSS
- * Note: Angular provides built-in sanitization, but this is an additional layer
- * @param input - User input to sanitize
- * @returns Sanitized input
- */
-function sanitizeInput(input) {
-    if (!input)
+
+const CONVERSATION_VOICE_CATALOG = 'conversation-voice';
+const MB = 1024 * 1024;
+const CONVERSATION_VOICE_PRESENTATION = {
+    icon: 'fa-light fa-microphone text-green-500',
+    title: 'Voice message',
+};
+const VOICE_UTILITY = {
+    duration: 'duration',
+    formatDuration: 'formatDuration',
+    createLocalPreviewUrl: 'createLocalPreviewUrl',
+};
+function blobUrl(ctx, blob) {
+    if (!isPlatformBrowser(ctx.platformId)) {
         return '';
-    return input
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#x27;')
-        .replace(/\//g, '&#x2F;')
-        .replace(/`/g, '&#x60;')
-        .replace(/=/g, '&#x3D;');
-}
-/**
- * Validate latitude coordinate
- * @param latitude - Latitude to validate
- * @returns Validation result
- */
-function validateLatitude(latitude) {
-    if (latitude === undefined || latitude === null || typeof latitude !== 'number' || isNaN(latitude)) {
-        return {
-            valid: false,
-            error: 'Latitude is required',
-            errorCode: 'MISSING_LATITUDE',
-        };
-    }
-    if (latitude < -90 || latitude > 90) {
-        return {
-            valid: false,
-            error: 'Latitude must be between -90 and 90',
-            errorCode: 'INVALID_LATITUDE',
-        };
     }
-    return { valid: true };
+    return URL.createObjectURL(blob);
 }
-/**
- * Validate longitude coordinate
- * @param longitude - Longitude to validate
- * @returns Validation result
- */
-function validateLongitude(longitude) {
-    if (longitude === undefined || longitude === null || typeof longitude !== 'number' || isNaN(longitude)) {
-        return {
-            valid: false,
-            error: 'Longitude is required',
-            errorCode: 'MISSING_LONGITUDE',
-        };
+function mediaDuration(ctx, file) {
+    if (!isPlatformBrowser(ctx.platformId)) {
+        return Promise.resolve(0);
     }
-    if (longitude < -180 || longitude > 180) {
-        return {
-            valid: false,
-            error: 'Longitude must be between -180 and 180',
-            errorCode: 'INVALID_LONGITUDE',
+    return new Promise((resolve, reject) => {
+        const el = document.createElement('audio');
+        el.preload = 'metadata';
+        el.onloadedmetadata = () => {
+            URL.revokeObjectURL(el.src);
+            resolve(el.duration);
+        };
+        el.onerror = () => {
+            URL.revokeObjectURL(el.src);
+            reject(new Error('Failed to load audio metadata'));
         };
+        el.src = URL.createObjectURL(file);
+    });
+}
+function conversationVoiceUtilities() {
+    return {
+        [VOICE_UTILITY.duration]: (ctx, file) => mediaDuration(ctx, file),
+        [VOICE_UTILITY.formatDuration]: (_ctx, seconds) => formatDuration(seconds),
+        [VOICE_UTILITY.createLocalPreviewUrl]: (ctx, source) => blobUrl(ctx, source),
+    };
+}
+function createConversationVoiceFileType() {
+    const presentation = CONVERSATION_VOICE_PRESENTATION;
+    return {
+        name: CONVERSATION_VOICE_CATALOG,
+        metadata: createFileTypeMetadata('conversation'),
+        title: presentation.title,
+        icon: presentation.icon,
+        validations: {
+            mimeTypes: ['audio/webm', 'audio/ogg', 'audio/mp4', 'audio/*'],
+            minSize: 1,
+            maxSize: 50 * MB,
+        },
+        utilities: conversationVoiceUtilities(),
+        copy: (payload) => {
+            const voice = payload;
+            const url = voice.url?.trim() ?? '';
+            return {
+                text: '',
+                meta: {
+                    kind: 'voice',
+                    url,
+                    duration: voice.duration,
+                    mimeType: voice.mimeType,
+                },
+            };
+        },
+    };
+}
+class AXConversationVoiceFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([createConversationVoiceFileType()]);
     }
-    return { valid: true };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVoiceFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVoiceFileTypeProvider, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVoiceFileTypeProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
-class AXConversationMessageUtilsService {
-    /**
-     * Normalize optional avatar/icon values so empty or whitespace-only strings
-     * are treated as missing data.
-     */
-    static normalizeOptionalMediaValue(value) {
-        if (typeof value !== 'string') {
-            return undefined;
-        }
-        const normalized = value.trim();
-        return normalized.length > 0 ? normalized : undefined;
+function mergeVoiceUploadResult(payload, result) {
+    return {
+        ...payload,
+        type: 'voice',
+        url: result.url,
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        metadata: result.metadata,
+    };
+}
+function applyVoiceLocalPreview(payload, localUrl) {
+    return { ...payload, type: 'voice', url: localUrl };
+}
+
+const MESSAGE_TYPE_FILE_TYPE = {
+    image: CONVERSATION_IMAGE_CATALOG,
+    video: CONVERSATION_VIDEO_CATALOG,
+    audio: CONVERSATION_AUDIO_CATALOG,
+    file: CONVERSATION_FILE_CATALOG,
+    voice: CONVERSATION_VOICE_CATALOG,
+    sticker: CONVERSATION_IMAGE_CATALOG,
+};
+/** Resolves {@link AXMessage.fileType} from command or message type. */
+function resolveMessageFileType(type, fileType) {
+    return fileType ?? MESSAGE_TYPE_FILE_TYPE[type];
+}
+function mergeImageUploadResult(payload, result) {
+    const base = normalizeImagePayload(payload);
+    const images = [...base.images];
+    const i = images.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const slot = i >= 0 ? images[i] : undefined;
+    const url = resolvePersistableMediaUrl(result.url);
+    const next = {
+        ...(slot ?? { width: 0, height: 0 }),
+        mediaId: result.mediaId,
+        mimeType: result.mimeType,
+        size: result.size,
+        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl ?? slot?.thumbnailUrl, url),
+        metadata: result.metadata,
+    };
+    if (url) {
+        next.url = url;
     }
-    /**
-     * Get conversation avatar image URL.
-     */
-    static getConversationAvatar(conversation) {
-        return AXConversationMessageUtilsService.normalizeOptionalMediaValue(conversation.avatar);
+    if (i >= 0)
+        images[i] = next;
+    else
+        images.push(next);
+    return { ...base, type: 'image', images };
+}
+function applyImageLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
+    const base = normalizeImagePayload(payload);
+    const images = [...base.images];
+    const slot = images.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
+    const preview = { url: localUrl, width: 0, height: 0, mimeType };
+    if (slot >= 0) {
+        images[slot] = { ...images[slot], ...preview };
     }
-    /**
-     * Font Awesome icon class(es) for a conversation when there is no avatar image.
-     */
-    static getConversationAvatarIcon(conversation) {
-        if (AXConversationMessageUtilsService.getConversationAvatar(conversation)) {
-            return undefined;
-        }
-        return AXConversationMessageUtilsService.normalizeOptionalMediaValue(conversation.icon);
-    }
-    /**
-     * Get sender name from message
-     */
-    static getSenderName(message, conversation) {
-        const participant = conversation.participants.find((p) => p.id === message.senderId);
-        return participant?.name || translateSync('@acorex:chat.fallbacks.unknown-user');
-    }
-    /**
-     * Get sender avatar image URL (takes precedence over {@link getSenderAvatarIcon}).
-     */
-    static getSenderAvatar(message, conversation) {
-        const participant = conversation.participants.find((p) => p.id === message.senderId);
-        return AXConversationMessageUtilsService.normalizeOptionalMediaValue(participant?.avatar);
+    else if (images.length === 0) {
+        images.push(preview);
     }
-    /**
-     * Font Awesome icon class(es) for the sender when there is no avatar image:
-     * participant `icon` first, then conversation-level `icon`.
-     */
-    static getSenderAvatarIcon(message, conversation) {
-        const participant = conversation.participants.find((p) => p.id === message.senderId);
-        if (AXConversationMessageUtilsService.normalizeOptionalMediaValue(participant?.avatar)) {
-            return undefined;
-        }
-        return (AXConversationMessageUtilsService.normalizeOptionalMediaValue(participant?.icon) ??
-            AXConversationMessageUtilsService.getConversationAvatarIcon(conversation));
+    else {
+        images[0] = { ...images[0], ...preview };
     }
-    /**
-     * Get initials from name
-     */
-    static getInitials(name) {
-        if (!name)
-            return '?';
-        return name
-            .split(' ')
-            .map((n) => n[0])
-            .join('')
-            .toUpperCase()
-            .substring(0, 2);
+    return { ...base, type: 'image', images };
+}
+function mergeUploadResult(type, payload, result) {
+    switch (type) {
+        case 'image':
+            return mergeImageUploadResult(payload, result);
+        case 'video':
+            return mergeVideoUploadResult(payload, result);
+        case 'audio':
+            return mergeAudioUploadResult(payload, result);
+        case 'file':
+            return mergeFileUploadResult(payload, result);
+        case 'voice':
+            return mergeVoiceUploadResult(payload, result);
+        case 'sticker':
+            return {
+                ...payload,
+                type: 'sticker',
+                url: result.url,
+                mediaId: result.mediaId,
+            };
+        default:
+            return payload;
     }
-    /**
-     * Type guard for text payload
-     */
-    static isTextPayload(payload) {
-        return 'text' in payload && typeof payload.text === 'string';
+}
+function applyLocalPreview(type, payload, localUrl, mimeType = 'application/octet-stream') {
+    switch (type) {
+        case 'image':
+            return applyImageLocalPreview(payload, localUrl, mimeType);
+        case 'video':
+            return applyVideoLocalPreview(payload, localUrl, mimeType);
+        case 'audio':
+            return applyAudioLocalPreview(payload, localUrl, mimeType);
+        case 'file':
+            return applyFileLocalPreview(payload, localUrl, mimeType);
+        case 'voice':
+            return applyVoiceLocalPreview(payload, localUrl);
+        case 'sticker':
+            return { ...payload, type: 'sticker', url: localUrl };
+        default:
+            return payload;
     }
-    /**
-     * Get message text content
-     */
-    static getMessageText(message) {
-        if (message.type === 'text' && AXConversationMessageUtilsService.isTextPayload(message.payload)) {
-            return message.payload.text;
+}
+function toUploaderReference$1(payload) {
+    switch (payload.type) {
+        case 'image': {
+            const first = payload.images[0];
+            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
         }
-        return `[${message.type}]`;
-    }
-    /**
-     * Format message preview text
-     */
-    static getPreviewText(message, maxLength = 50) {
-        // Handle different message types
-        switch (message.type) {
-            case 'text': {
-                const textPayload = message.payload;
-                const text = textPayload.text || '';
-                const truncatedText = text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
-                return {
-                    value: truncatedText,
-                    type: 'text',
-                    icon: 'fa-light fa-message',
-                };
-            }
-            case 'image': {
-                const imagePayload = normalizeImagePayload(message.payload);
-                const first = imagePayload.images[0];
-                const label = imagePayload.caption?.trim() ||
-                    (imagePayload.images && imagePayload.images.length > 1
-                        ? `${imagePayload.images.length} images`
-                        : '');
-                return {
-                    value: label || first?.thumbnailUrl || first?.url || '',
-                    type: 'image',
-                    icon: 'fa-light fa-image',
-                };
-            }
-            case 'video': {
-                const videoPayload = normalizeVideoPayload(message.payload);
-                const first = videoPayload.videos[0];
-                const label = videoPayload.caption?.trim() ||
-                    (videoPayload.videos.length > 1 ? `${videoPayload.videos.length} videos` : '');
-                return {
-                    value: label || first?.url || '',
-                    type: 'video',
-                    icon: 'fa-light fa-video',
-                };
-            }
-            case 'audio': {
-                const audioPayload = normalizeAudioPayload(message.payload);
-                const names = audioPayload.audios.map((a) => a.title).filter(Boolean).join(', ');
-                const first = audioPayload.audios[0];
-                const label = audioPayload.caption?.trim() ||
-                    (audioPayload.audios.length > 1 ? `${audioPayload.audios.length} audio files` : names);
-                return {
-                    value: label || first?.url || '',
-                    type: 'audio',
-                    icon: 'fa-light fa-music',
-                };
-            }
-            case 'voice': {
-                const voicePayload = message.payload;
-                return {
-                    value: voicePayload.url || '',
-                    type: 'voice',
-                    icon: 'fa-light fa-microphone',
-                };
-            }
-            case 'file': {
-                const filePayload = normalizeFilePayload(message.payload);
-                const names = filePayload.files.map((f) => f.name).join(', ');
-                const label = filePayload.caption?.trim() ||
-                    (filePayload.files.length > 1 ? `${filePayload.files.length} files` : names);
-                return {
-                    value: label || names,
-                    type: 'file',
-                    icon: 'fa-light fa-file',
-                };
-            }
-            case 'location': {
-                const locationPayload = message.payload;
-                return {
-                    value: locationPayload.latitude && locationPayload.longitude
-                        ? `${locationPayload.latitude},${locationPayload.longitude}`
-                        : '',
-                    type: 'location',
-                    icon: 'fa-light fa-location-dot',
-                };
-            }
-            case 'sticker': {
-                const stickerPayload = message.payload;
-                return {
-                    value: stickerPayload.url || '',
-                    type: 'sticker',
-                    icon: 'fa-light fa-face-smile',
-                };
-            }
-            default:
-                return {
-                    value: '',
-                    type: message.type,
-                    icon: 'fa-light fa-message',
-                };
+        case 'video': {
+            const first = payload.videos[0];
+            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
+        }
+        case 'audio': {
+            const first = payload.audios[0];
+            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
         }
+        case 'file': {
+            const first = payload.files[0];
+            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
+        }
+        case 'voice':
+        case 'sticker':
+            return {
+                url: payload.url,
+                mediaId: payload.mediaId,
+                mimeType: payload.mimeType,
+                size: payload.size,
+            };
+        default:
+            return {};
     }
-    /**
-     * Check if message is from current user
-     */
-    static isOwnMessage(message, currentUserId) {
-        return message.senderId === currentUserId;
+}
+function createObjectUrl(platformId, blob) {
+    if (!isPlatformBrowser(platformId)) {
+        return '';
     }
-    /**
-     * Get message status icon class (Font Awesome)
-     */
-    static getStatusIcon(message) {
-        switch (message.status) {
-            case 'sending':
-                return 'fa-light fa-clock';
-            case 'sent':
-                return 'fa-light fa-check';
-            case 'delivered':
-                return 'fa-light fa-check-double';
-            case 'read':
-                return 'fa-light fa-check-double';
-            case 'failed':
-                return 'fa-light fa-circle-exclamation';
-            default:
-                return 'fa-light fa-check';
-        }
+    return URL.createObjectURL(blob);
+}
+function revokeObjectUrl(platformId, url) {
+    if (isPlatformBrowser(platformId) && url.startsWith('blob:')) {
+        URL.revokeObjectURL(url);
     }
-    /**
-     * Check if message should show avatar
-     */
-    static shouldShowAvatar(message, previousMessage, conversation) {
-        // Always show avatar for group conversations
-        if (conversation.type === 'group' || conversation.type === 'channel') {
-            // Don't show if same sender as previous message within 5 minutes
-            if (previousMessage && previousMessage.senderId === message.senderId) {
-                const timeDiff = message.timestamp.getTime() - previousMessage.timestamp.getTime();
-                return timeDiff > 5 * 60 * 1000; // 5 minutes
-            }
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Group messages by sender for consecutive messages
-     */
-    static shouldGroupWithPrevious(message, previousMessage) {
-        if (!previousMessage)
-            return false;
-        // Same sender
-        if (message.senderId !== previousMessage.senderId)
-            return false;
-        // Within 5 minutes
-        const timeDiff = message.timestamp.getTime() - previousMessage.timestamp.getTime();
-        return timeDiff < 5 * 60 * 1000;
-    }
-    /**
-     * Get conversation status for avatar (private conversations only)
-     */
-    static getConversationStatus(conversation) {
-        if (conversation.type === 'private') {
-            return conversation.status.presence;
-        }
+}
+async function createLocalPreviewUrl(fileService, platformId, source, messageType) {
+    const catalog = MESSAGE_TYPE_FILE_TYPE[messageType];
+    if (!catalog) {
         return undefined;
     }
-    /**
-     * Get typing indicator text for conversation
-     */
-    static getTypingText(conversation) {
-        const typingUsers = conversation.status.typingUsers;
-        if (typingUsers.length === 0)
-            return '';
-        if (conversation.type === 'private') {
-            return translateSync('@acorex:chat.status.typing');
-        }
-        const firstUser = conversation.participants.find((p) => p.id === typingUsers[0]);
-        if (typingUsers.length === 1) {
-            return translateSync('@acorex:chat.status.user-is-typing', {
-                params: { userName: firstUser?.name || translateSync('@acorex:chat.fallbacks.someone') },
-            });
-        }
-        return translateSync('@acorex:chat.status.people-typing', { params: { count: typingUsers.length } });
-    }
-    /**
-     * Format last seen time
-     */
-    static formatLastSeen(date) {
-        const now = new Date();
-        const diff = now.getTime() - date.getTime();
-        const seconds = Math.floor(diff / 1000);
-        if (seconds < 60)
-            return translateSync('@acorex:chat.time.just-now');
-        if (seconds < 3600)
-            return translateSync('@acorex:chat.time.minutes-ago', { params: { count: Math.floor(seconds / 60) } });
-        if (seconds < 86400)
-            return translateSync('@acorex:chat.time.hours-ago', { params: { count: Math.floor(seconds / 3600) } });
-        if (seconds < 604800)
-            return translateSync('@acorex:chat.time.days-ago', { params: { count: Math.floor(seconds / 86400) } });
-        return date.toLocaleDateString();
-    }
-    /**
-     * Get conversation subtitle (status or member count)
-     */
-    static getConversationSubtitle(conversation) {
-        if (conversation.status.isTyping) {
-            return AXConversationMessageUtilsService.getTypingText(conversation);
-        }
-        switch (conversation.type) {
-            case 'private':
-                if (conversation.status.presence === 'online') {
-                    return translateSync('@acorex:chat.status.online');
-                }
-                if (conversation.status.lastSeen) {
-                    return translateSync('@acorex:chat.status.last-seen', {
-                        params: { value: AXConversationMessageUtilsService.formatLastSeen(conversation.status.lastSeen) },
-                    });
-                }
-                return translateSync('@acorex:chat.status.offline');
-            case 'group':
-                return translateSync('@acorex:chat.members.count', { params: { count: conversation.participants.length } });
-            case 'channel':
-                return translateSync('@acorex:chat.members.subscribers-count', { params: { count: conversation.participants.length } });
-            case 'bot':
-                return translateSync('@acorex:chat.bot');
-            default:
-                return '';
-        }
+    const fileType = await fileService.getFileType(catalog);
+    if (!fileType) {
+        return undefined;
     }
+    const ctx = { readAsDataUrl: (f) => fileService.blobToBase64(f), platformId };
+    const extension = resolveFileTypeExtension(fileType, {
+        file: source instanceof File ? source : undefined,
+        mimeType: source.type,
+    });
+    const result = await runFileTypeUtility(fileType, ctx, extension, 'createLocalPreviewUrl', source);
+    return typeof result === 'string' ? result : undefined;
 }
 
-/** Other participant in a private chat (excludes the current user). */
-function resolvePrivatePeerUserId(conversation, currentUserId) {
-    if (conversation.type !== 'private') {
-        return undefined;
+function normalizeMessagePayload(payload) {
+    switch (payload.type) {
+        case 'image':
+            return normalizeImagePayload(payload);
+        case 'video':
+            return normalizeVideoPayload(payload);
+        case 'audio':
+            return normalizeAudioPayload(payload);
+        case 'file':
+            return normalizeFilePayload(payload);
+        default:
+            return payload;
     }
-    const currentId = currentUserId ?? 'current-user';
-    return conversation.participants.find((participant) => participant.id !== currentId)?.id;
-}
-/** Whether `auto` kind should render a user avatar for this conversation. */
-function shouldUseUserAvatarForConversation(conversation, currentUserId) {
-    return conversation.type === 'private' && !!resolvePrivatePeerUserId(conversation, currentUserId);
 }
-function resolveUserAvatarDisplay(userId, conversation, message) {
-    if (message && conversation) {
-        return {
-            name: AXConversationMessageUtilsService.getSenderName(message, conversation),
-            avatar: AXConversationMessageUtilsService.getSenderAvatar(message, conversation),
-            icon: AXConversationMessageUtilsService.getSenderAvatarIcon(message, conversation),
-        };
+
+/**
+ * Conversation Configuration Interface
+ * Centralized configuration values to avoid magic numbers
+ */
+
+/**
+ * Default Configuration Values
+ * Centralized defaults to avoid magic numbers throughout the codebase
+ */
+/**
+ * Default conversation configuration
+ * All values are explicitly defined here for easy maintenance and documentation
+ */
+const AX_DEFAULT_CONVERSATION_CONFIG = {
+    // Pagination
+    messagePageSize: 30,
+    conversationPageSize: 20,
+    // Scroll Configuration
+    scrollThreshold: 100,
+    infiniteScrollThreshold: 200,
+    // Timeout Durations (milliseconds)
+    typingIndicatorTimeout: 3000,
+    typingIndicatorThrottle: 1000,
+    messageHighlightDuration: 2000,
+    debounceSearch: 300,
+    // Message Storage Limits
+    maxMessagesPerConversation: 1000,
+    maxTotalMessages: 10000,
+    maxCachedConversations: 50,
+    // UI Dimensions (pixels)
+    minSidebarWidth: 250,
+    maxSidebarWidth: 500,
+    defaultSidebarWidth: 320,
+    // Cache
+    filterCacheSize: 100,
+    // Message Validation
+    maxMessageLength: 10000,
+    minMessageLength: 1,
+    maxFilesPerMessage: 3,
+    // Intersection Observer
+    messageReadThreshold: 0.3,
+    // Message list
+    messageListBackground: '',
+};
+/**
+ * Helper function to merge user config with defaults
+ * Properly handles array merging to avoid reference issues
+ * @param userConfig - User-provided configuration
+ * @returns Merged configuration with all required fields
+ */
+function mergeWithDefaults(userConfig) {
+    if (!userConfig) {
+        return { ...AX_DEFAULT_CONVERSATION_CONFIG };
     }
-    const participant = conversation?.participants.find((p) => p.id === userId);
-    return {
-        name: participant?.name ?? userId,
-        avatar: participant?.avatar,
-        icon: participant?.icon,
-    };
-}
-function resolveConversationAvatarDisplay(conversation, currentUserId) {
-    const title = currentUserId !== undefined
-        ? resolveConversationTitleForViewer(conversation, currentUserId)
-        : conversation.title;
     return {
-        name: title,
-        avatar: AXConversationMessageUtilsService.getConversationAvatar(conversation),
-        icon: AXConversationMessageUtilsService.getConversationAvatarIcon(conversation),
+        ...AX_DEFAULT_CONVERSATION_CONFIG,
+        ...userConfig,
     };
 }
 
-const GENERIC_PRIVATE_TITLES = new Set(['', 'new chat', 'new conversation']);
-/** True when the stored title is a placeholder, not a user-defined name. */
-function isGenericPrivateConversationTitle(title) {
-    return GENERIC_PRIVATE_TITLES.has((title ?? '').trim().toLowerCase());
-}
-/** Other participant in a private 1v1 chat (excludes the current viewer). */
-function resolvePrivatePeerParticipant(conversation, currentUserId) {
-    if (conversation.type !== 'private') {
-        return undefined;
-    }
-    const peerId = resolvePrivatePeerUserId(conversation, currentUserId);
-    if (!peerId) {
-        return undefined;
-    }
-    return conversation.participants.find((participant) => participant.id === peerId);
-}
 /**
- * Resolves the display title for the current viewer.
- * Private 1v1 chats show the other participant's name when no custom title is set.
+ * Dependency Injection Tokens
+ * InjectionTokens for configuration and dependencies
  */
-function resolveConversationTitleForViewer(conversation, currentUserId) {
-    if (conversation.type !== 'private') {
-        return conversation.title;
-    }
-    const peer = resolvePrivatePeerParticipant(conversation, currentUserId);
-    if (peer?.name) {
-        return peer.name;
-    }
-    if (isGenericPrivateConversationTitle(conversation.title)) {
-        return conversation.title || 'New Chat';
-    }
-    return conversation.title;
-}
 /**
- * Returns a viewer-scoped copy of a conversation with dynamic private title/avatar/icon.
- * Does not mutate the source object.
+ * Configuration token for conversation component
+ * Uses centralized defaults from AX_DEFAULT_CONVERSATION_CONFIG
  */
-function resolveConversationForViewer(conversation, currentUserId) {
-    if (conversation.type !== 'private' || !currentUserId) {
-        return conversation;
-    }
-    const peer = resolvePrivatePeerParticipant(conversation, currentUserId);
-    if (!peer) {
-        return conversation;
-    }
-    const title = resolveConversationTitleForViewer(conversation, currentUserId);
-    const avatar = conversation.avatar ?? peer.avatar;
-    const icon = conversation.icon ?? peer.icon;
-    if (title === conversation.title &&
-        avatar === conversation.avatar &&
-        icon === conversation.icon) {
-        return conversation;
-    }
-    return {
-        ...conversation,
-        title,
-        avatar,
-        icon,
-    };
-}
+const CONVERSATION_CONFIG = new InjectionToken('CONVERSATION_CONFIG', {
+    providedIn: 'root',
+    factory: () => mergeWithDefaults(),
+});
+/**
+ * Token for configuring AXErrorHandlerService
+ */
+const ERROR_HANDLER_CONFIG = new InjectionToken('ERROR_HANDLER_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({}),
+});
 
 /**
- * In-memory conversation and message graph (signal-based).
- * Plain class — not DI-registered; instantiated by `AXConversationService`.
+ * Pluggable avatar components for the conversation UI.
+ * Register via `provideConversation({ avatarComponents: { user, conversation } })`.
  */
-function withNormalizedPayload(message) {
-    return { ...message, payload: normalizeMessagePayload(message.payload) };
-}
-class ConversationState {
-    constructor(config) {
-        this.config = config;
-        this._conversations = signal(new Map(), ...(ngDevMode ? [{ debugName: "_conversations" }] : /* istanbul ignore next */ []));
-        this._messages = signal(new Map(), ...(ngDevMode ? [{ debugName: "_messages" }] : /* istanbul ignore next */ []));
-        this._conversationMessages = signal(new Map(), ...(ngDevMode ? [{ debugName: "_conversationMessages" }] : /* istanbul ignore next */ []));
-        this.conversations = computed(() => {
-            const convMap = this._conversations();
-            return Array.from(convMap.values());
-        }, { ...(ngDevMode ? { debugName: "conversations" } : /* istanbul ignore next */ {}), equal: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]) });
-    }
-    setConversations(conversations) {
-        const convMap = new Map();
-        conversations.forEach((conv) => convMap.set(conv.id, conv));
-        this._conversations.set(convMap);
-    }
-    addConversations(conversations) {
-        this._conversations.update((existingConversations) => {
-            const newConversations = new Map(existingConversations);
-            conversations.forEach((conv) => newConversations.set(conv.id, conv));
-            const maxCached = this.config.maxCachedConversations;
-            if (newConversations.size > maxCached) {
-                const sorted = Array.from(newConversations.values()).sort((a, b) => (b.lastMessageAt?.getTime() ?? 0) - (a.lastMessageAt?.getTime() ?? 0));
-                const toKeep = sorted.slice(0, maxCached);
-                const cleanedMap = new Map();
-                toKeep.forEach((conv) => cleanedMap.set(conv.id, conv));
-                return cleanedMap;
-            }
-            return newConversations;
-        });
+const AX_CONVERSATION_USER_AVATAR_COMPONENT = new InjectionToken('AX_CONVERSATION_USER_AVATAR_COMPONENT');
+const AX_CONVERSATION_CONVERSATION_AVATAR_COMPONENT = new InjectionToken('AX_CONVERSATION_CONVERSATION_AVATAR_COMPONENT');
+
+/**
+ * Registry Configuration Tokens
+ * Injection tokens for configuring default registry values
+ */
+/**
+ * Additional message renderers configuration
+ * Provide this token to add custom message renderers in addition to built-in ones
+ * Note: Built-in renderers (text, system, fallback) are registered by default; other types are provided via plugins/constants.
+ */
+const DEFAULT_MESSAGE_RENDERERS = new InjectionToken('DEFAULT_MESSAGE_RENDERERS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Default message actions configuration
+ * Provide this token to override default message actions
+ */
+const DEFAULT_MESSAGE_ACTIONS = new InjectionToken('DEFAULT_MESSAGE_ACTIONS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Default composer tabs configuration
+ * Provide this token to override default composer tabs (emoji, stickers, etc.)
+ */
+const DEFAULT_COMPOSER_TABS = new InjectionToken('DEFAULT_COMPOSER_TABS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Default composer actions configuration
+ * Provide this token to override default composer actions (attach, voice, etc.)
+ */
+const DEFAULT_COMPOSER_ACTIONS = new InjectionToken('DEFAULT_COMPOSER_ACTIONS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Default conversation tabs configuration
+ * Provide this token to override default conversation tabs (all, private, groups, etc.)
+ */
+const DEFAULT_CONVERSATION_TABS = new InjectionToken('DEFAULT_CONVERSATION_TABS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Default info bar actions configuration
+ * Provide this token to override default info bar actions (mute, archive, block, etc.)
+ */
+const DEFAULT_INFO_BAR_ACTIONS = new InjectionToken('DEFAULT_INFO_BAR_ACTIONS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Default conversation item actions configuration
+ * Provide this token to override default conversation item actions (mute, delete, archive, etc.)
+ */
+const DEFAULT_CONVERSATION_ITEM_ACTIONS = new InjectionToken('DEFAULT_CONVERSATION_ITEM_ACTIONS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+/**
+ * Complete registry configuration token
+ * Provide this for comprehensive registry configuration
+ */
+const REGISTRY_CONFIG = new InjectionToken('REGISTRY_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({}),
+});
+
+class AXConversationMessageUtilsService {
+    /**
+     * Normalize optional avatar/icon values so empty or whitespace-only strings
+     * are treated as missing data.
+     */
+    static normalizeOptionalMediaValue(value) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalized = value.trim();
+        return normalized.length > 0 ? normalized : undefined;
     }
-    setConversation(conversation) {
-        this._conversations.update((conversations) => {
-            const newConversations = new Map(conversations);
-            newConversations.set(conversation.id, conversation);
-            return newConversations;
-        });
+    /**
+     * Get conversation avatar image URL.
+     */
+    static getConversationAvatar(conversation) {
+        return AXConversationMessageUtilsService.normalizeOptionalMediaValue(conversation.avatar);
     }
-    getConversation(conversationId) {
-        return this._conversations().get(conversationId);
+    /**
+     * Font Awesome icon class(es) for a conversation when there is no avatar image.
+     */
+    static getConversationAvatarIcon(conversation) {
+        if (AXConversationMessageUtilsService.getConversationAvatar(conversation)) {
+            return undefined;
+        }
+        return AXConversationMessageUtilsService.normalizeOptionalMediaValue(conversation.icon);
     }
-    updateConversation(conversationId, updates) {
-        const conversation = this._conversations().get(conversationId);
-        if (!conversation)
-            return;
-        this.setConversation({ ...conversation, ...updates });
+    /**
+     * Get sender name from message
+     */
+    static getSenderName(message, conversation) {
+        const participant = conversation.participants.find((p) => p.id === message.senderId);
+        return participant?.name || translateSync('@acorex:chat.fallbacks.unknown-user');
     }
-    deleteConversation(conversationId) {
-        this._conversations.update((conversations) => {
-            const newConversations = new Map(conversations);
-            newConversations.delete(conversationId);
-            return newConversations;
-        });
-        const messageIds = this._conversationMessages().get(conversationId) || [];
-        this._messages.update((messages) => {
-            const newMessages = new Map(messages);
-            messageIds.forEach((id) => newMessages.delete(id));
-            return newMessages;
-        });
-        this._conversationMessages.update((map) => {
-            const newMap = new Map(map);
-            newMap.delete(conversationId);
-            return newMap;
-        });
+    /**
+     * Get sender avatar image URL (takes precedence over {@link getSenderAvatarIcon}).
+     */
+    static getSenderAvatar(message, conversation) {
+        const participant = conversation.participants.find((p) => p.id === message.senderId);
+        return AXConversationMessageUtilsService.normalizeOptionalMediaValue(participant?.avatar);
     }
-    updateLastMessage(message) {
-        this.updateConversation(message.conversationId, {
-            lastMessage: message,
-            lastMessageAt: message.timestamp,
-            updatedAt: message.timestamp,
-        });
+    /**
+     * Font Awesome icon class(es) for the sender when there is no avatar image:
+     * participant `icon` first, then conversation-level `icon`.
+     */
+    static getSenderAvatarIcon(message, conversation) {
+        const participant = conversation.participants.find((p) => p.id === message.senderId);
+        if (AXConversationMessageUtilsService.normalizeOptionalMediaValue(participant?.avatar)) {
+            return undefined;
+        }
+        return (AXConversationMessageUtilsService.normalizeOptionalMediaValue(participant?.icon) ??
+            AXConversationMessageUtilsService.getConversationAvatarIcon(conversation));
     }
-    incrementUnreadCount(conversationId) {
-        const conversation = this._conversations().get(conversationId);
-        if (!conversation)
-            return;
-        this.updateConversation(conversationId, { unreadCount: conversation.unreadCount + 1 });
+    /**
+     * Get initials from name
+     */
+    static getInitials(name) {
+        if (!name)
+            return '?';
+        return name
+            .split(' ')
+            .map((n) => n[0])
+            .join('')
+            .toUpperCase()
+            .substring(0, 2);
     }
-    resetUnreadCount(conversationId) {
-        this.updateConversation(conversationId, { unreadCount: 0 });
+    /**
+     * Type guard for text payload
+     */
+    static isTextPayload(payload) {
+        return 'text' in payload && typeof payload.text === 'string';
     }
-    updateSettings(conversationId, settings) {
-        const conversation = this._conversations().get(conversationId);
-        if (!conversation)
-            return;
-        this.updateConversation(conversationId, {
-            settings: { ...conversation.settings, ...settings },
-            updatedAt: new Date(),
-        });
+    /**
+     * Get message text content
+     */
+    static getMessageText(message) {
+        if (message.type === 'text' && AXConversationMessageUtilsService.isTextPayload(message.payload)) {
+            return message.payload.text;
+        }
+        return `[${message.type}]`;
     }
-    updateTitle(conversationId, title) {
-        this.updateConversation(conversationId, { title, updatedAt: new Date() });
-    }
-    updateMetadata(conversationId, metadata) {
-        const conversation = this._conversations().get(conversationId);
-        if (!conversation)
-            return;
-        this.updateConversation(conversationId, {
-            metadata: { ...conversation.metadata, ...metadata },
-            updatedAt: new Date(),
-        });
-    }
-    updateTypingIndicator(conversationId, userId, isTyping) {
-        const conversation = this._conversations().get(conversationId);
-        if (!conversation)
-            return;
-        let typingUsers = [...conversation.status.typingUsers];
-        if (isTyping) {
-            if (!typingUsers.includes(userId)) {
-                typingUsers.push(userId);
+    /**
+     * Format message preview text
+     */
+    static getPreviewText(message, maxLength = 50) {
+        // Handle different message types
+        switch (message.type) {
+            case 'text': {
+                const textPayload = message.payload;
+                const text = textPayload.text || '';
+                const truncatedText = text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
+                return {
+                    value: truncatedText,
+                    type: 'text',
+                    icon: 'fa-light fa-message',
+                };
             }
-        }
-        else {
-            typingUsers = typingUsers.filter((id) => id !== userId);
-        }
-        this.updateConversation(conversationId, {
-            status: {
-                ...conversation.status,
-                isTyping: typingUsers.length > 0,
-                typingUsers,
-            },
-        });
-    }
-    updateParticipantPresence(userId, status, lastSeen) {
-        this._conversations.update((conversations) => {
-            const newConversations = new Map(conversations);
-            for (const [id, conv] of conversations) {
-                const participant = conv.participants.find((p) => p.id === userId);
-                if (participant) {
-                    const updatedConversation = {
-                        ...conv,
-                        participants: conv.participants.map((p) => (p.id === userId ? { ...p, status, lastSeen } : p)),
-                        status: conv.type === 'private' ? { ...conv.status, presence: status, lastSeen } : conv.status,
-                    };
-                    newConversations.set(id, updatedConversation);
-                }
+            case 'image': {
+                const imagePayload = normalizeImagePayload(message.payload);
+                const first = imagePayload.images[0];
+                const label = imagePayload.caption?.trim() ||
+                    (imagePayload.images && imagePayload.images.length > 1
+                        ? `${imagePayload.images.length} images`
+                        : '');
+                return {
+                    value: label || first?.thumbnailUrl || first?.url || '',
+                    type: 'image',
+                    icon: 'fa-light fa-image',
+                };
             }
-            return newConversations;
-        });
-    }
-    addMessage(message) {
-        const normalized = withNormalizedPayload(message);
-        this._messages.update((messages) => {
-            const newMessages = new Map(messages);
-            newMessages.set(normalized.id, normalized);
-            return newMessages;
-        });
-        this._conversationMessages.update((map) => {
-            const newMap = new Map(map);
-            const existing = newMap.get(normalized.conversationId) || [];
-            if (existing.includes(normalized.id)) {
-                return newMap;
+            case 'video': {
+                const videoPayload = normalizeVideoPayload(message.payload);
+                const first = videoPayload.videos[0];
+                const label = videoPayload.caption?.trim() ||
+                    (videoPayload.videos.length > 1 ? `${videoPayload.videos.length} videos` : '');
+                return {
+                    value: label || first?.url || '',
+                    type: 'video',
+                    icon: 'fa-light fa-video',
+                };
             }
-            const updated = [...existing, normalized.id].sort((a, b) => {
-                const msgA = this._messages().get(a);
-                const msgB = this._messages().get(b);
-                if (!msgA || !msgB)
-                    return 0;
-                return msgA.timestamp.getTime() - msgB.timestamp.getTime();
-            });
-            newMap.set(normalized.conversationId, updated);
-            return newMap;
-        });
-    }
-    /**
-     * Replace all messages for a conversation (initial page load).
-     */
-    setConversationMessages(conversationId, messages) {
-        const sorted = [...messages].map(withNormalizedPayload).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-        const sortedIds = sorted.map((m) => m.id);
-        this._messages.update((msgs) => {
-            const newMessages = new Map(msgs);
-            const previousIds = this._conversationMessages().get(conversationId) || [];
-            for (const id of previousIds) {
-                newMessages.delete(id);
+            case 'audio': {
+                const audioPayload = normalizeAudioPayload(message.payload);
+                const names = audioPayload.audios.map((a) => a.title).filter(Boolean).join(', ');
+                const first = audioPayload.audios[0];
+                const label = audioPayload.caption?.trim() ||
+                    (audioPayload.audios.length > 1 ? `${audioPayload.audios.length} audio files` : names);
+                return {
+                    value: label || first?.url || '',
+                    type: 'audio',
+                    icon: 'fa-light fa-music',
+                };
             }
-            for (const msg of sorted) {
-                newMessages.set(msg.id, msg);
+            case 'voice': {
+                const voicePayload = message.payload;
+                return {
+                    value: voicePayload.url || '',
+                    type: 'voice',
+                    icon: 'fa-light fa-microphone',
+                };
             }
-            return newMessages;
-        });
-        this._conversationMessages.update((map) => {
-            const newMap = new Map(map);
-            newMap.set(conversationId, sortedIds);
-            return newMap;
-        });
-        this.cleanupOldMessages();
-    }
-    addMessages(messages) {
-        if (messages.length === 0)
-            return;
-        const normalized = messages.map(withNormalizedPayload);
-        this._messages.update((msgs) => {
-            const newMessages = new Map(msgs);
-            normalized.forEach((msg) => newMessages.set(msg.id, msg));
-            return newMessages;
-        });
-        const conversationGroups = new Map();
-        normalized.forEach((msg) => {
-            const existing = conversationGroups.get(msg.conversationId) || [];
-            existing.push(msg.id);
-            conversationGroups.set(msg.conversationId, existing);
-        });
-        this._conversationMessages.update((map) => {
-            const newMap = new Map(map);
-            for (const [conversationId, newMsgIds] of conversationGroups) {
-                const existing = newMap.get(conversationId) || [];
-                const idSet = new Set(existing);
-                const merged = [...existing];
-                for (const id of newMsgIds) {
-                    if (!idSet.has(id)) {
-                        merged.push(id);
-                        idSet.add(id);
-                    }
-                }
-                const sorted = merged.sort((a, b) => {
-                    const msgA = this._messages().get(a);
-                    const msgB = this._messages().get(b);
-                    if (!msgA || !msgB)
-                        return 0;
-                    return msgA.timestamp.getTime() - msgB.timestamp.getTime();
-                });
-                newMap.set(conversationId, sorted);
+            case 'file': {
+                const filePayload = normalizeFilePayload(message.payload);
+                const names = filePayload.files.map((f) => f.name).join(', ');
+                const label = filePayload.caption?.trim() ||
+                    (filePayload.files.length > 1 ? `${filePayload.files.length} files` : names);
+                return {
+                    value: label || names,
+                    type: 'file',
+                    icon: 'fa-light fa-file',
+                };
             }
-            return newMap;
-        });
-        this.cleanupOldMessages();
-        this.cleanupConversationMessages();
-    }
-    getMessage(messageId) {
-        return this._messages().get(messageId);
+            case 'location': {
+                const locationPayload = message.payload;
+                return {
+                    value: locationPayload.latitude && locationPayload.longitude
+                        ? `${locationPayload.latitude},${locationPayload.longitude}`
+                        : '',
+                    type: 'location',
+                    icon: 'fa-light fa-location-dot',
+                };
+            }
+            case 'sticker': {
+                const stickerPayload = message.payload;
+                return {
+                    value: stickerPayload.url || '',
+                    type: 'sticker',
+                    icon: 'fa-light fa-face-smile',
+                };
+            }
+            default:
+                return {
+                    value: '',
+                    type: message.type,
+                    icon: 'fa-light fa-message',
+                };
+        }
     }
-    getConversationMessages(conversationId) {
-        const messageIds = this._conversationMessages().get(conversationId) || [];
-        return messageIds.map((id) => this._messages().get(id)).filter((msg) => msg !== undefined);
+    /**
+     * Check if message is from current user
+     */
+    static isOwnMessage(message, currentUserId) {
+        return message.senderId === currentUserId;
     }
-    updateMessage(messageId, updates) {
-        const message = this._messages().get(messageId);
-        if (!message)
-            return;
-        const merged = { ...message, ...updates };
-        if (updates.payload) {
-            merged.payload = normalizeMessagePayload(merged.payload);
+    /**
+     * Get message status icon class (Font Awesome)
+     */
+    static getStatusIcon(message) {
+        switch (message.status) {
+            case 'sending':
+                return 'fa-light fa-clock';
+            case 'sent':
+                return 'fa-light fa-check';
+            case 'delivered':
+                return 'fa-light fa-check-double';
+            case 'read':
+                return 'fa-light fa-check-double';
+            case 'failed':
+                return 'fa-light fa-circle-exclamation';
+            default:
+                return 'fa-light fa-check';
         }
-        this.addMessage(merged);
-    }
-    deleteMessage(messageId) {
-        const message = this._messages().get(messageId);
-        if (!message)
-            return;
-        this._messages.update((messages) => {
-            const newMessages = new Map(messages);
-            newMessages.delete(messageId);
-            return newMessages;
-        });
-        this._conversationMessages.update((map) => {
-            const newMap = new Map(map);
-            const existing = newMap.get(message.conversationId);
-            if (existing) {
-                newMap.set(message.conversationId, existing.filter((id) => id !== messageId));
-            }
-            return newMap;
-        });
-    }
-    cleanupOldMessages() {
-        const totalMessages = this._messages().size;
-        if (totalMessages > this.config.maxTotalMessages) {
-            const allMessages = Array.from(this._messages().values()).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-            const toKeep = allMessages.slice(0, this.config.maxTotalMessages);
-            const toKeepIds = new Set(toKeep.map((m) => m.id));
-            this._messages.update(() => {
-                const newMessages = new Map();
-                toKeep.forEach((msg) => newMessages.set(msg.id, msg));
-                return newMessages;
-            });
-            this._conversationMessages.update((map) => {
-                const newMap = new Map(map);
-                for (const [convId, messageIds] of newMap) {
-                    const filteredIds = messageIds.filter((id) => toKeepIds.has(id));
-                    newMap.set(convId, filteredIds);
-                }
-                return newMap;
-            });
-        }
-    }
-    cleanupConversationMessages() {
-        const maxMessages = this.config.maxMessagesPerConversation;
-        const idsToRemove = [];
-        this._conversationMessages.update((map) => {
-            const newMap = new Map(map);
-            for (const [convId, messageIds] of newMap) {
-                if (messageIds.length > maxMessages) {
-                    idsToRemove.push(...messageIds.slice(0, messageIds.length - maxMessages));
-                    newMap.set(convId, messageIds.slice(-maxMessages));
-                }
-            }
-            return newMap;
-        });
-        if (idsToRemove.length > 0) {
-            this._messages.update((messages) => {
-                const newMessages = new Map(messages);
-                idsToRemove.forEach((id) => newMessages.delete(id));
-                return newMessages;
-            });
-        }
-    }
-}
-
-/**
- * Error Handler Service
- * Centralized error handling and logging
- */
-/**
- * Error Handler Service
- */
-class AXErrorHandlerService {
-    constructor() {
-        this.injectedConfig = inject(ERROR_HANDLER_CONFIG);
-        this._errors$ = new Subject();
-        this._config = {
-            logToConsole: true,
-            showUserMessages: true,
-            autoRetry: false,
-            maxRetries: 3,
-        };
-        /** Error stream */
-        this.errors$ = this._errors$.asObservable();
-        this.configure(this.injectedConfig);
     }
     /**
-     * Configure error handler
+     * Check if message should show avatar
      */
-    configure(config) {
-        Object.assign(this._config, config);
+    static shouldShowAvatar(message, previousMessage, conversation) {
+        // Always show avatar for group conversations
+        if (conversation.type === 'group' || conversation.type === 'channel') {
+            // Don't show if same sender as previous message within 5 minutes
+            if (previousMessage && previousMessage.senderId === message.senderId) {
+                const timeDiff = message.timestamp.getTime() - previousMessage.timestamp.getTime();
+                return timeDiff > 5 * 60 * 1000; // 5 minutes
+            }
+            return true;
+        }
+        return false;
     }
     /**
-     * Handle an error
+     * Group messages by sender for consecutive messages
      */
-    handle(error, operation, context) {
-        const conversationError = this.normalizeError(error, operation, context);
-        this.publish(conversationError);
-        return conversationError;
+    static shouldGroupWithPrevious(message, previousMessage) {
+        if (!previousMessage)
+            return false;
+        // Same sender
+        if (message.senderId !== previousMessage.senderId)
+            return false;
+        // Within 5 minutes
+        const timeDiff = message.timestamp.getTime() - previousMessage.timestamp.getTime();
+        return timeDiff < 5 * 60 * 1000;
     }
     /**
-     * Handle API error (same pipeline as {@link handle}, for typed API failures)
+     * Get conversation status for avatar (private conversations only)
      */
-    handleApiError(apiError, operation, context) {
-        const conversationError = this.conversationErrorFromApi(apiError, operation, context);
-        this.publish(conversationError);
-        return conversationError;
-    }
-    publish(conversationError) {
-        this._errors$.next(conversationError);
-        if (this._config.logToConsole) {
-            this.logError(conversationError);
-        }
-        if (this._config.customHandler) {
-            this._config.customHandler(conversationError);
+    static getConversationStatus(conversation) {
+        if (conversation.type === 'private') {
+            return conversation.status.presence;
         }
+        return undefined;
     }
     /**
-     * Normalize any error to conversation error format (does not publish — use {@link handle})
+     * Get typing indicator text for conversation
      */
-    normalizeError(error, operation, context) {
-        if (this.isApiError(error)) {
-            return this.conversationErrorFromApi(error, operation, context);
+    static getTypingText(conversation) {
+        const typingUsers = conversation.status.typingUsers;
+        if (typingUsers.length === 0)
+            return '';
+        if (conversation.type === 'private') {
+            return translateSync('@acorex:chat.status.typing');
         }
-        const errorObj = error;
-        const message = (typeof errorObj['message'] === 'string' && errorObj['message']) ||
-            (error instanceof Error ? error.message : String(error)) ||
-            'An unknown error occurred';
-        const code = (typeof errorObj['code'] === 'string' && errorObj['code']) || 'UNKNOWN_ERROR';
-        const statusCodeRaw = errorObj['statusCode'] ?? errorObj['status'];
-        const statusCode = typeof statusCodeRaw === 'number' ? statusCodeRaw : undefined;
-        return {
-            code,
-            message,
-            severity: 'error',
-            operation,
-            originalError: error,
-            statusCode,
-            context,
-            timestamp: new Date(),
-            handled: false,
-            recoverySuggestions: this.getDefaultRecoverySuggestions(code),
-        };
-    }
-    conversationErrorFromApi(apiError, operation, context) {
-        return {
-            code: apiError.code,
-            message: apiError.message,
-            severity: this.determineSeverity(apiError.statusCode),
-            operation,
-            originalError: apiError,
-            statusCode: apiError.statusCode,
-            context,
-            timestamp: apiError.timestamp ?? new Date(),
-            handled: false,
-            recoverySuggestions: this.getRecoverySuggestions(apiError),
-        };
-    }
-    isApiError(error) {
-        return (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            'message' in error &&
-            typeof error.code === 'string' &&
-            typeof error.message === 'string');
+        const firstUser = conversation.participants.find((p) => p.id === typingUsers[0]);
+        if (typingUsers.length === 1) {
+            return translateSync('@acorex:chat.status.user-is-typing', {
+                params: { userName: firstUser?.name || translateSync('@acorex:chat.fallbacks.someone') },
+            });
+        }
+        return translateSync('@acorex:chat.status.people-typing', { params: { count: typingUsers.length } });
     }
     /**
-     * Determine severity based on status code
+     * Format last seen time
      */
-    determineSeverity(statusCode) {
-        if (!statusCode)
-            return 'error';
-        if (statusCode >= 500)
-            return 'critical';
-        if (statusCode >= 400)
-            return 'error';
-        if (statusCode >= 300)
-            return 'warning';
-        return 'info';
+    static formatLastSeen(date) {
+        const now = new Date();
+        const diff = now.getTime() - date.getTime();
+        const seconds = Math.floor(diff / 1000);
+        if (seconds < 60)
+            return translateSync('@acorex:chat.time.just-now');
+        if (seconds < 3600)
+            return translateSync('@acorex:chat.time.minutes-ago', { params: { count: Math.floor(seconds / 60) } });
+        if (seconds < 86400)
+            return translateSync('@acorex:chat.time.hours-ago', { params: { count: Math.floor(seconds / 3600) } });
+        if (seconds < 604800)
+            return translateSync('@acorex:chat.time.days-ago', { params: { count: Math.floor(seconds / 86400) } });
+        return date.toLocaleDateString();
     }
     /**
-     * Get recovery suggestions based on error
+     * Get conversation subtitle (status or member count)
      */
-    getRecoverySuggestions(error) {
-        const suggestions = [];
-        if (error.statusCode === 401 || error.code === 'UNAUTHORIZED') {
-            suggestions.push('Please log in again');
-            suggestions.push('Check if your session has expired');
-        }
-        else if (error.statusCode === 403 || error.code === 'FORBIDDEN') {
-            suggestions.push('You do not have permission for this action');
-            suggestions.push('Ask your administrator for access');
-        }
-        else if (error.statusCode === 404 || error.code === 'NOT_FOUND') {
-            suggestions.push('The requested resource was not found');
-            suggestions.push('It may have been deleted or moved');
+    static getConversationSubtitle(conversation) {
+        if (conversation.status.isTyping) {
+            return AXConversationMessageUtilsService.getTypingText(conversation);
         }
-        else if (error.statusCode === 429 || error.code === 'RATE_LIMIT_EXCEEDED') {
-            suggestions.push('Too many requests. Please wait and try again');
+        switch (conversation.type) {
+            case 'private':
+                if (conversation.status.presence === 'online') {
+                    return translateSync('@acorex:chat.status.online');
+                }
+                if (conversation.status.lastSeen) {
+                    return translateSync('@acorex:chat.status.last-seen', {
+                        params: { value: AXConversationMessageUtilsService.formatLastSeen(conversation.status.lastSeen) },
+                    });
+                }
+                return translateSync('@acorex:chat.status.offline');
+            case 'group':
+                return translateSync('@acorex:chat.members.count', { params: { count: conversation.participants.length } });
+            case 'channel':
+                return translateSync('@acorex:chat.members.subscribers-count', { params: { count: conversation.participants.length } });
+            case 'bot':
+                return translateSync('@acorex:chat.bot');
+            default:
+                return '';
         }
-        else if (error.statusCode && error.statusCode >= 500) {
-            suggestions.push('Server error occurred');
-            suggestions.push('Please try again later');
-            suggestions.push('If the problem persists, reach out to support');
-        }
-        else if (error.code === 'NETWORK_ERROR') {
-            suggestions.push('Check your internet connection');
-            suggestions.push('Try refreshing the page');
-        }
-        return suggestions;
-    }
-    /**
-     * Get default recovery suggestions
-     */
-    getDefaultRecoverySuggestions(code) {
-        const suggestions = [];
-        if (code.includes('NETWORK') || code.includes('CONNECTION')) {
-            suggestions.push('Check your internet connection');
-            suggestions.push('Try refreshing the page');
-        }
-        else if (code.includes('TIMEOUT')) {
-            suggestions.push('The operation took too long');
-            suggestions.push('Please try again');
-        }
-        else {
-            suggestions.push('Please try again');
-            suggestions.push('If the problem persists, reach out to support');
-        }
-        return suggestions;
-    }
-    /**
-     * Log error to console
-     */
-    logError(error) {
-        const isError = error.severity === 'critical' || error.severity === 'error';
-        const header = `[Conversation ${error.severity.toUpperCase()}] ${error.operation}:`;
-        if (isError) {
-            console.error(header, error.message, error.context || '');
-        }
-        else {
-            console.warn(header, error.message, error.context || '');
-        }
-        if (error.originalError && error.severity !== 'info') {
-            console.error('Original error:', error.originalError);
-        }
-        if (error.recoverySuggestions && error.recoverySuggestions.length > 0) {
-            console.info('Recovery suggestions:', error.recoverySuggestions);
-        }
-    }
-    /**
-     * Get user-friendly error message
-     */
-    getUserFriendlyMessage(error) {
-        // Map technical errors to user-friendly messages
-        const messageMap = {
-            NETWORK_ERROR: 'Unable to connect. Please check your internet connection.',
-            UNAUTHORIZED: 'You are not authorized. Please log in again.',
-            FORBIDDEN: 'You do not have permission to perform this action.',
-            NOT_FOUND: 'The requested item could not be found.',
-            RATE_LIMIT_EXCEEDED: 'Too many requests. Please slow down.',
-            VALIDATION_ERROR: 'The provided data is invalid.',
-            SERVER_ERROR: 'A server error occurred. Please try again later.',
-            TIMEOUT: 'The operation timed out. Please try again.',
-        };
-        return messageMap[error.code] || error.message || 'An unexpected error occurred.';
-    }
-    /**
-     * Check if error is retryable
-     */
-    isRetryable(error) {
-        const retryableCodes = ['NETWORK_ERROR', 'TIMEOUT', 'RATE_LIMIT_EXCEEDED', 'SERVER_ERROR'];
-        const retryableStatusCodes = [408, 429, 500, 502, 503, 504];
-        return (retryableCodes.includes(error.code) ||
-            (error.statusCode !== undefined && retryableStatusCodes.includes(error.statusCode)));
-    }
-    /**
-     * Execute an operation with automatic retry logic
-     * @param operation - The async operation to execute
-     * @param operationName - Name of the operation for error tracking
-     * @param context - Additional context for error handling
-     * @returns Promise resolving to the operation result
-     * @throws {AXConversationError} If all retries fail
-     */
-    async executeWithRetry(operation, operationName, context) {
-        if (!this._config.autoRetry) {
-            // If auto-retry is disabled, just execute once
-            return operation();
-        }
-        const maxRetries = this._config.maxRetries ?? 3;
-        let lastError;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                lastError = error;
-                const conversationError = this.handle(error, operationName, { ...context, attempt });
-                // Don't retry if error is not retryable or if this was the last attempt
-                if (!this.isRetryable(conversationError) || attempt >= maxRetries) {
-                    throw conversationError;
-                }
-                // Exponential backoff: 1s, 2s, 4s, 8s...
-                const delayMs = Math.pow(2, attempt) * 1000;
-                await this.delay(delayMs);
-            }
-        }
-        throw this.handle(lastError, operationName, context);
-    }
-    /**
-     * Delay helper for retry backoff
-     * @param ms - Milliseconds to delay
-     */
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXErrorHandlerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXErrorHandlerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-
-function formatFileSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    if (bytes < 1024 * 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-function formatDuration(seconds) {
-    const mins = Math.floor(seconds / 60);
-    const secs = Math.floor(seconds % 60);
-    return `${mins}:${secs.toString().padStart(2, '0')}`;
 }
 
-const CONVERSATION_AUDIO_CATALOG = 'conversation-audio';
-const MB$4 = 1024 * 1024;
-const CONVERSATION_AUDIO_PRESENTATION = {
-    icon: 'fa-light fa-music text-amber-500',
-    title: 'Audio',
-};
-const AUDIO_UTILITY = {
-    preview: 'preview',
-    duration: 'duration',
-    formatSize: 'formatSize',
-    formatDuration: 'formatDuration',
-    createLocalPreviewUrl: 'createLocalPreviewUrl',
-};
-function blobUrl$4(ctx, blob) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return '';
+/** Other participant in a private chat (excludes the current user). */
+function resolvePrivatePeerUserId(conversation, currentUserId) {
+    if (conversation.type !== 'private') {
+        return undefined;
     }
-    return URL.createObjectURL(blob);
+    const currentId = currentUserId ?? 'current-user';
+    return conversation.participants.find((participant) => participant.id !== currentId)?.id;
 }
-function mediaDuration$2(ctx, file) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return Promise.resolve(0);
-    }
-    return new Promise((resolve, reject) => {
-        const el = document.createElement('audio');
-        el.preload = 'metadata';
-        el.onloadedmetadata = () => {
-            URL.revokeObjectURL(el.src);
-            resolve(el.duration);
-        };
-        el.onerror = () => {
-            URL.revokeObjectURL(el.src);
-            reject(new Error('Failed to load audio metadata'));
-        };
-        el.src = URL.createObjectURL(file);
-    });
+/** Whether `auto` kind should render a user avatar for this conversation. */
+function shouldUseUserAvatarForConversation(conversation, currentUserId) {
+    return conversation.type === 'private' && !!resolvePrivatePeerUserId(conversation, currentUserId);
 }
-function conversationAudioUtilities() {
+function resolveUserAvatarDisplay(userId, conversation, message) {
+    if (message && conversation) {
+        return {
+            name: AXConversationMessageUtilsService.getSenderName(message, conversation),
+            avatar: AXConversationMessageUtilsService.getSenderAvatar(message, conversation),
+            icon: AXConversationMessageUtilsService.getSenderAvatarIcon(message, conversation),
+        };
+    }
+    const participant = conversation?.participants.find((p) => p.id === userId);
     return {
-        [AUDIO_UTILITY.preview]: (ctx, file) => ctx.readAsDataUrl(file),
-        [AUDIO_UTILITY.duration]: (ctx, file) => mediaDuration$2(ctx, file),
-        [AUDIO_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
-        [AUDIO_UTILITY.formatDuration]: (_ctx, seconds) => formatDuration(seconds),
-        [AUDIO_UTILITY.createLocalPreviewUrl]: (ctx, source) => blobUrl$4(ctx, source),
+        name: participant?.name ?? userId,
+        avatar: participant?.avatar,
+        icon: participant?.icon,
     };
 }
-function createConversationAudioFileType() {
-    const presentation = CONVERSATION_AUDIO_PRESENTATION;
+function resolveConversationAvatarDisplay(conversation, currentUserId) {
+    const title = currentUserId !== undefined
+        ? resolveConversationTitleForViewer(conversation, currentUserId)
+        : conversation.title;
     return {
-        name: CONVERSATION_AUDIO_CATALOG,
-        metadata: createFileTypeMetadata('conversation'),
-        title: presentation.title,
-        icon: presentation.icon,
-        validations: {
-            mimeTypes: ['audio/*'],
-            minSize: 1,
-            maxSize: 50 * MB$4,
-        },
-        extensions: [
-            { name: 'mp3', title: 'MP3' },
-            { name: 'wav', title: 'WAV', validations: { maxSize: 30 * MB$4 } },
-            { name: 'ogg', title: 'OGG' },
-            { name: 'm4a', title: 'M4A' },
-        ],
-        utilities: conversationAudioUtilities(),
-        copy: (payload) => {
-            const audio = normalizeAudioPayload(payload);
-            const caption = audio.caption?.trim();
-            const items = audio.audios.map((item) => ({
-                url: item.url?.trim(),
-                title: item.title?.trim(),
-            }));
-            return {
-                text: caption ?? '',
-                meta: { kind: 'audio', caption, items, count: audio.audios.length },
-            };
-        },
+        name: title,
+        avatar: AXConversationMessageUtilsService.getConversationAvatar(conversation),
+        icon: AXConversationMessageUtilsService.getConversationAvatarIcon(conversation),
     };
 }
-class AXConversationAudioFileTypeProvider extends AXFileTypeInfoProvider {
-    items() {
-        return Promise.resolve([createConversationAudioFileType()]);
+
+const GENERIC_PRIVATE_TITLES = new Set(['', 'new chat', 'new conversation']);
+/** True when the stored title is a placeholder, not a user-defined name. */
+function isGenericPrivateConversationTitle(title) {
+    return GENERIC_PRIVATE_TITLES.has((title ?? '').trim().toLowerCase());
+}
+/** Other participant in a private 1v1 chat (excludes the current viewer). */
+function resolvePrivatePeerParticipant(conversation, currentUserId) {
+    if (conversation.type !== 'private') {
+        return undefined;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationAudioFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationAudioFileTypeProvider, providedIn: 'root' }); }
+    const peerId = resolvePrivatePeerUserId(conversation, currentUserId);
+    if (!peerId) {
+        return undefined;
+    }
+    return conversation.participants.find((participant) => participant.id === peerId);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationAudioFileTypeProvider, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-function audioItemFromUpload(file, result, duration) {
-    const url = resolvePersistableMediaUrl(result.url);
-    const item = {
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        duration,
-        title: file.name,
-        metadata: result.metadata,
-    };
-    if (url) {
-        item.url = url;
+/**
+ * Resolves the display title for the current viewer.
+ * Private 1v1 chats show the other participant's name when no custom title is set.
+ */
+function resolveConversationTitleForViewer(conversation, currentUserId) {
+    if (conversation.type !== 'private') {
+        return conversation.title;
     }
-    return item;
-}
-function mergeAudioUploadResult(payload, result) {
-    const base = normalizeAudioPayload(payload);
-    const audios = [...base.audios];
-    const i = audios.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const slot = i >= 0 ? audios[i] : undefined;
-    const url = resolvePersistableMediaUrl(result.url);
-    const next = {
-        ...(slot ?? { duration: 0 }),
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        metadata: result.metadata,
-    };
-    if (url) {
-        next.url = url;
+    const peer = resolvePrivatePeerParticipant(conversation, currentUserId);
+    if (peer?.name) {
+        return peer.name;
     }
-    if (i >= 0)
-        audios[i] = next;
-    else
-        audios.push(next);
-    return { ...base, type: 'audio', audios };
-}
-function applyAudioLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
-    const base = normalizeAudioPayload(payload);
-    const audios = [...base.audios];
-    const slot = audios.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const preview = { url: localUrl, duration: 0, mimeType };
-    if (slot >= 0) {
-        audios[slot] = { ...audios[slot], ...preview };
+    if (isGenericPrivateConversationTitle(conversation.title)) {
+        return conversation.title || 'New Chat';
     }
-    else if (audios.length === 0) {
-        audios.push(preview);
+    return conversation.title;
+}
+/**
+ * Returns a viewer-scoped copy of a conversation with dynamic private title/avatar/icon.
+ * Does not mutate the source object.
+ */
+function resolveConversationForViewer(conversation, currentUserId) {
+    if (conversation.type !== 'private' || !currentUserId) {
+        return conversation;
     }
-    else {
-        audios[0] = { ...audios[0], ...preview };
+    const peer = resolvePrivatePeerParticipant(conversation, currentUserId);
+    if (!peer) {
+        return conversation;
     }
-    return { ...base, type: 'audio', audios };
-}
-
-const CONVERSATION_IMAGE_CATALOG = 'conversation-image';
-const MB$3 = 1024 * 1024;
-const CONVERSATION_IMAGE_PRESENTATION = {
-    icon: 'fa-light fa-image text-purple-500',
-    title: 'Image',
-};
-const IMAGE_UTILITY = {
-    preview: 'preview',
-    formatSize: 'formatSize',
-    createLocalPreviewUrl: 'createLocalPreviewUrl',
-};
-function blobUrl$3(ctx, blob) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return '';
+    const title = resolveConversationTitleForViewer(conversation, currentUserId);
+    const avatar = conversation.avatar ?? peer.avatar;
+    const icon = conversation.icon ?? peer.icon;
+    if (title === conversation.title &&
+        avatar === conversation.avatar &&
+        icon === conversation.icon) {
+        return conversation;
     }
-    return URL.createObjectURL(blob);
-}
-function conversationImageUtilities() {
-    return {
-        [IMAGE_UTILITY.preview]: (ctx, file) => ctx.readAsDataUrl(file),
-        [IMAGE_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
-        [IMAGE_UTILITY.createLocalPreviewUrl]: (ctx, source) => {
-            const blob = source;
-            if (blob.type.startsWith('image/')) {
-                return ctx.readAsDataUrl(blob);
-            }
-            return blobUrl$3(ctx, blob);
-        },
-    };
-}
-function createConversationImageFileType() {
-    const presentation = CONVERSATION_IMAGE_PRESENTATION;
     return {
-        name: CONVERSATION_IMAGE_CATALOG,
-        metadata: createFileTypeMetadata('conversation'),
-        title: presentation.title,
-        icon: presentation.icon,
-        validations: {
-            mimeTypes: ['image/*'],
-            minSize: 1,
-            maxSize: 100 * MB$3,
-        },
-        extensions: [
-            { name: 'jpg', title: 'JPEG' },
-            { name: 'jpeg', title: 'JPEG', validations: { maxSize: 5 * MB$3 } },
-            { name: 'png', title: 'PNG' },
-            { name: 'gif', title: 'GIF' },
-            { name: 'webp', title: 'WebP' },
-            { name: 'svg', title: 'SVG', validations: { maxSize: 2 * MB$3 } },
-        ],
-        utilities: conversationImageUtilities(),
-        copy: (payload) => {
-            const image = normalizeImagePayload(payload);
-            const caption = image.caption?.trim();
-            const urls = image.images
-                .map((item) => item.url?.trim() || item.thumbnailUrl?.trim())
-                .filter((url) => !!url);
-            return {
-                text: caption ?? '',
-                meta: { kind: 'image', caption, urls, count: image.images.length },
-            };
-        },
+        ...conversation,
+        title,
+        avatar,
+        icon,
     };
 }
-class AXConversationImageFileTypeProvider extends AXFileTypeInfoProvider {
-    items() {
-        return Promise.resolve([createConversationImageFileType()]);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationImageFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationImageFileTypeProvider, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationImageFileTypeProvider, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
 
-const CONVERSATION_VIDEO_CATALOG = 'conversation-video';
-const MB$2 = 1024 * 1024;
-const CONVERSATION_VIDEO_PRESENTATION = {
-    icon: 'fa-light fa-video ax-text-blue-500',
-    title: 'Video',
-};
-const VIDEO_UTILITY = {
-    preview: 'preview',
-    duration: 'duration',
-    formatSize: 'formatSize',
-    formatDuration: 'formatDuration',
-    createLocalPreviewUrl: 'createLocalPreviewUrl',
-};
-function blobUrl$2(ctx, blob) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return '';
+/**
+ * Validation Utilities
+ * Centralized validation functions for messages and user input
+ */
+/**
+ * Validate message text content
+ * @param text - Text to validate
+ * @param config - Configuration for validation rules
+ * @returns Validation result
+ */
+function validateMessageText(text, config) {
+    // Check for empty text
+    if (!text || text.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Message text cannot be empty',
+            errorCode: 'EMPTY_MESSAGE',
+        };
     }
-    return URL.createObjectURL(blob);
-}
-function mediaDuration$1(ctx, file, tag) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return Promise.resolve(0);
+    // Check minimum length
+    const minLength = config.minMessageLength ?? 1;
+    if (text.trim().length < minLength) {
+        return {
+            valid: false,
+            error: `Message must be at least ${minLength} character(s)`,
+            errorCode: 'MESSAGE_TOO_SHORT',
+        };
     }
-    return new Promise((resolve, reject) => {
-        const el = document.createElement(tag);
-        el.preload = 'metadata';
-        el.onloadedmetadata = () => {
-            URL.revokeObjectURL(el.src);
-            resolve(el.duration);
+    // Check maximum length
+    const maxLength = config.maxMessageLength ?? 10000;
+    if (text.length > maxLength) {
+        return {
+            valid: false,
+            error: `Message exceeds ${maxLength} character limit`,
+            errorCode: 'MESSAGE_TOO_LONG',
         };
-        el.onerror = () => {
-            URL.revokeObjectURL(el.src);
-            reject(new Error(`Failed to load ${tag} metadata`));
+    }
+    return { valid: true };
+}
+/**
+ * Validate conversation ID
+ * @param conversationId - Conversation ID to validate
+ * @returns Validation result
+ */
+function validateConversationId(conversationId) {
+    if (!conversationId || typeof conversationId !== 'string' || conversationId.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Conversation ID is required',
+            errorCode: 'MISSING_CONVERSATION_ID',
         };
-        el.src = URL.createObjectURL(file);
-    });
+    }
+    // Check for reasonable length
+    if (conversationId.length > 255) {
+        return {
+            valid: false,
+            error: 'Conversation ID is too long',
+            errorCode: 'MISSING_CONVERSATION_ID',
+        };
+    }
+    return { valid: true };
 }
-function conversationVideoUtilities() {
-    return {
-        [VIDEO_UTILITY.preview]: (ctx, file) => ctx.readAsDataUrl(file),
-        [VIDEO_UTILITY.duration]: (ctx, file) => mediaDuration$1(ctx, file, 'video'),
-        [VIDEO_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
-        [VIDEO_UTILITY.formatDuration]: (_ctx, seconds) => formatDuration(seconds),
-        [VIDEO_UTILITY.createLocalPreviewUrl]: async (ctx, source) => {
-            const blob = source;
-            if (blob.type.startsWith('image/')) {
-                return ctx.readAsDataUrl(blob);
-            }
-            return blobUrl$2(ctx, blob);
-        },
-    };
+/**
+ * Validate message type
+ * @param type - Message type to validate
+ * @returns Validation result
+ */
+function validateMessageType(type) {
+    if (!type || type.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Message type is required',
+            errorCode: 'MISSING_MESSAGE_TYPE',
+        };
+    }
+    return { valid: true };
 }
-function createConversationVideoFileType() {
-    const presentation = CONVERSATION_VIDEO_PRESENTATION;
-    return {
-        name: CONVERSATION_VIDEO_CATALOG,
-        metadata: createFileTypeMetadata('conversation'),
-        title: presentation.title,
-        icon: presentation.icon,
-        validations: {
-            mimeTypes: ['video/*'],
-            minSize: 1,
-            maxSize: 500 * MB$2,
-        },
-        extensions: [
-            { name: 'mp4', title: 'MP4' },
-            { name: 'webm', title: 'WebM', validations: { maxSize: 200 * MB$2 } },
-            { name: 'ogg', title: 'OGG' },
-        ],
-        utilities: conversationVideoUtilities(),
-        copy: (payload) => {
-            const video = normalizeVideoPayload(payload);
-            const caption = video.caption?.trim();
-            const urls = video.videos.map((item) => item.url?.trim()).filter((url) => !!url);
+function validateMediaItems(items, label) {
+    if (!Array.isArray(items) || items.length === 0) {
+        return {
+            valid: false,
+            error: `${label} message must include at least one attachment`,
+            errorCode: 'INVALID_MEDIA_PAYLOAD',
+        };
+    }
+    for (const item of items) {
+        const ok = (typeof item.url === 'string' && item.url.length > 0) ||
+            (typeof item.mediaId === 'string' && item.mediaId.length > 0);
+        if (!ok) {
             return {
-                text: caption ?? '',
-                meta: { kind: 'video', caption, urls, count: video.videos.length },
+                valid: false,
+                error: `Each ${label.toLowerCase()} attachment must have a url or mediaId`,
+                errorCode: 'INVALID_MEDIA_PAYLOAD',
             };
-        },
-    };
-}
-class AXConversationVideoFileTypeProvider extends AXFileTypeInfoProvider {
-    items() {
-        return Promise.resolve([createConversationVideoFileType()]);
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVideoFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVideoFileTypeProvider, providedIn: 'root' }); }
+    return { valid: true };
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVideoFileTypeProvider, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-const CONVERSATION_FILE_CATALOG = 'conversation-file';
-const MB$1 = 1024 * 1024;
-const CONVERSATION_FILE_PRESENTATION = {
-    icon: 'fa-light fa-file text-neutral-500',
-    title: 'File',
-};
-const CONVERSATION_FILE_ALLOWED_MIME_TYPES = [
-    'image/*',
-    'video/*',
-    'audio/*',
-    'application/pdf',
-    'application/msword',
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    'application/vnd.ms-excel',
-    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    'application/zip',
-    'application/x-zip-compressed',
-    'application/x-7z-compressed',
-    'application/vnd.rar',
-    'application/octet-stream',
-    'text/plain',
-];
-const FILE_UTILITY = {
-    preview: 'preview',
-    formatSize: 'formatSize',
-    createLocalPreviewUrl: 'createLocalPreviewUrl',
-    pickerCatalog: 'pickerCatalog',
-};
-function blobUrl$1(ctx, blob) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return '';
+/**
+ * Validate message payload
+ * @param payload - Message payload to validate
+ * @param type - Message type
+ * @returns Validation result
+ */
+function validateMessagePayload(payload, type) {
+    if (!payload) {
+        return {
+            valid: false,
+            error: 'Message payload is required',
+            errorCode: 'MISSING_PAYLOAD',
+        };
     }
-    return URL.createObjectURL(blob);
-}
-function conversationFileUtilities() {
-    return {
-        [FILE_UTILITY.preview]: async (ctx, file) => {
-            const f = file;
-            if (f.type.startsWith('image/')) {
-                return ctx.readAsDataUrl(f);
+    const normalized = type === 'image' || type === 'video' || type === 'audio' || type === 'file'
+        ? normalizeMessagePayload(payload)
+        : payload;
+    // Type-specific validation
+    switch (type) {
+        case 'text':
+            if (!('text' in payload) || typeof payload.text !== 'string') {
+                return {
+                    valid: false,
+                    error: 'Text message must have a text property',
+                    errorCode: 'INVALID_TEXT_PAYLOAD',
+                };
             }
-            return undefined;
-        },
-        [FILE_UTILITY.formatSize]: (_ctx, bytes) => formatFileSize(bytes),
-        [FILE_UTILITY.createLocalPreviewUrl]: (ctx, source) => blobUrl$1(ctx, source),
-        [FILE_UTILITY.pickerCatalog]: (_ctx, file) => {
-            const f = file;
-            if (f.type.startsWith('image/'))
-                return CONVERSATION_IMAGE_CATALOG;
-            if (f.type.startsWith('video/'))
-                return CONVERSATION_VIDEO_CATALOG;
-            if (f.type.startsWith('audio/'))
-                return CONVERSATION_AUDIO_CATALOG;
-            return CONVERSATION_FILE_CATALOG;
-        },
-    };
-}
-function createConversationFileFileType() {
-    const presentation = CONVERSATION_FILE_PRESENTATION;
-    return {
-        name: CONVERSATION_FILE_CATALOG,
-        metadata: createFileTypeMetadata('conversation'),
-        title: presentation.title,
-        icon: presentation.icon,
-        validations: {
-            mimeTypes: [...CONVERSATION_FILE_ALLOWED_MIME_TYPES],
-            minSize: 1,
-            maxSize: 100 * MB$1,
-        },
-        extensions: [
-            { name: 'pdf', title: 'PDF', validations: { mimeTypes: ['application/pdf'], maxSize: 25 * MB$1 } },
-            { name: 'doc', title: 'Word' },
-            { name: 'docx', title: 'Word' },
-            { name: 'txt', title: 'Text', validations: { mimeTypes: ['text/plain'], maxSize: 5 * MB$1 } },
-            {
-                name: 'zip',
-                title: 'ZIP',
-                validations: {
-                    mimeTypes: ['application/zip', 'application/x-zip-compressed', 'application/octet-stream'],
-                    maxSize: 50 * MB$1,
-                },
-            },
-        ],
-        utilities: conversationFileUtilities(),
-        copy: (payload) => {
-            const file = normalizeFilePayload(payload);
-            const caption = file.caption?.trim();
-            const items = file.files.map((item) => {
-                const name = item.name?.trim();
-                const url = item.url?.trim();
-                const line = name && url ? `${name} — ${url}` : url || name;
-                return { name, url, line };
-            });
-            return {
-                text: caption ?? '',
-                meta: { kind: 'file', caption, items, count: file.files.length },
-            };
-        },
-    };
-}
-class AXConversationFileFileTypeProvider extends AXFileTypeInfoProvider {
-    items() {
-        return Promise.resolve([createConversationFileFileType()]);
+            break;
+        case 'image':
+            return validateMediaItems(normalized.images, 'Image');
+        case 'video':
+            return validateMediaItems(normalized.videos, 'Video');
+        case 'audio':
+            return validateMediaItems(normalized.audios, 'Audio');
+        case 'file':
+            return validateMediaItems(normalized.files, 'File');
+        case 'voice':
+        case 'sticker': {
+            const media = payload;
+            const hasUrl = typeof media.url === 'string' && media.url.length > 0;
+            const hasMediaId = typeof media.mediaId === 'string' && media.mediaId.length > 0;
+            if (!hasUrl && !hasMediaId) {
+                return {
+                    valid: false,
+                    error: `${type} message must have a url or mediaId`,
+                    errorCode: 'INVALID_MEDIA_PAYLOAD',
+                };
+            }
+            break;
+        }
+        case 'location':
+            if (!('latitude' in payload) ||
+                !('longitude' in payload) ||
+                typeof payload.latitude !== 'number' ||
+                typeof payload.longitude !== 'number') {
+                return {
+                    valid: false,
+                    error: 'Location message must have latitude and longitude properties',
+                    errorCode: 'INVALID_LOCATION_PAYLOAD',
+                };
+            }
+            break;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationFileFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationFileFileTypeProvider, providedIn: 'root' }); }
+    return { valid: true };
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationFileFileTypeProvider, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-function fileItemFromUpload(file, result) {
-    const extension = file.name.includes('.') ? file.name.split('.').pop() : undefined;
-    const url = resolvePersistableMediaUrl(result.url);
-    const item = {
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        name: file.name,
-        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl, url),
-        extension,
-        metadata: result.metadata,
-    };
-    if (url) {
-        item.url = url;
-    }
-    return item;
+/**
+ * Validate user ID
+ * @param userId - User ID to validate
+ * @returns Validation result
+ */
+function validateUserId(userId) {
+    if (!userId || typeof userId !== 'string' || userId.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'User ID is required',
+            errorCode: 'MISSING_USER_ID',
+        };
+    }
+    // Check for reasonable length (prevent extremely long IDs)
+    if (userId.length > 255) {
+        return {
+            valid: false,
+            error: 'User ID is too long',
+            errorCode: 'INVALID_USER_ID',
+        };
+    }
+    return { valid: true };
 }
-function mergeFileUploadResult(payload, result) {
-    const base = normalizeFilePayload(payload);
-    const files = [...base.files];
-    const i = files.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const slot = i >= 0 ? files[i] : undefined;
-    const name = slot?.name ?? result.metadata?.['fileName'] ?? 'file';
-    const url = resolvePersistableMediaUrl(result.url);
-    const next = {
-        ...(slot ?? { name, mimeType: result.mimeType }),
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        name,
-        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl ?? slot?.thumbnailUrl, url),
-        metadata: result.metadata,
-    };
-    if (url) {
-        next.url = url;
+/**
+ * Validate array of user IDs
+ * @param userIds - Array of user IDs to validate
+ * @param minCount - Minimum number of users required
+ * @param maxCount - Maximum number of users allowed
+ * @returns Validation result
+ */
+function validateUserIds(userIds, minCount = 1, maxCount) {
+    if (!userIds || !Array.isArray(userIds)) {
+        return {
+            valid: false,
+            error: 'User IDs must be an array',
+            errorCode: 'INVALID_USER_IDS',
+        };
     }
-    if (i >= 0)
-        files[i] = next;
-    else
-        files.push(next);
-    return { ...base, type: 'file', files };
+    if (userIds.length < minCount) {
+        return {
+            valid: false,
+            error: `At least ${minCount} user(s) required`,
+            errorCode: 'TOO_FEW_USERS',
+        };
+    }
+    if (maxCount && userIds.length > maxCount) {
+        return {
+            valid: false,
+            error: `Maximum ${maxCount} user(s) allowed`,
+            errorCode: 'TOO_MANY_USERS',
+        };
+    }
+    // Check for empty or invalid IDs
+    const invalidIds = userIds.filter((id) => !id || id.trim().length === 0);
+    if (invalidIds.length > 0) {
+        return {
+            valid: false,
+            error: 'All user IDs must be non-empty strings',
+            errorCode: 'INVALID_USER_ID',
+        };
+    }
+    return { valid: true };
 }
-function applyFileLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
-    const base = normalizeFilePayload(payload);
-    const files = [...base.files];
-    const slot = files.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const preview = { url: localUrl, name: 'upload', mimeType };
-    if (slot >= 0) {
-        files[slot] = { ...files[slot], ...preview };
+/**
+ * Validate email address
+ * @param email - Email to validate
+ * @returns Validation result
+ */
+function validateEmail(email) {
+    if (!email || email.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Email is required',
+            errorCode: 'MISSING_EMAIL',
+        };
     }
-    else if (files.length === 0) {
-        files.push(preview);
+    // Trim whitespace
+    const trimmedEmail = email.trim();
+    // Check length constraints
+    if (trimmedEmail.length > 254) {
+        return {
+            valid: false,
+            error: 'Email is too long',
+            errorCode: 'INVALID_EMAIL',
+        };
     }
-    else {
-        files[0] = { ...files[0], ...preview };
+    // Enhanced email regex with better validation
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    if (!emailRegex.test(trimmedEmail)) {
+        return {
+            valid: false,
+            error: 'Invalid email format',
+            errorCode: 'INVALID_EMAIL',
+        };
     }
-    return { ...base, type: 'file', files };
+    return { valid: true };
 }
-
-function videoItemFromUpload(file, result, duration) {
-    const url = resolvePersistableMediaUrl(result.url);
-    const item = {
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl, url),
-        duration,
-        width: 0,
-        height: 0,
-        metadata: result.metadata,
-    };
-    if (url) {
-        item.url = url;
+/**
+ * Validate URL
+ * @param url - URL to validate
+ * @returns Validation result
+ */
+function validateUrl(url) {
+    if (!url || url.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'URL is required',
+            errorCode: 'MISSING_URL',
+        };
+    }
+    const trimmedUrl = url.trim();
+    // Check for common URL issues
+    if (trimmedUrl.length > 2048) {
+        return {
+            valid: false,
+            error: 'URL is too long',
+            errorCode: 'INVALID_URL',
+        };
+    }
+    try {
+        const urlObj = new URL(trimmedUrl);
+        // Validate protocol
+        if (!['http:', 'https:', 'ftp:', 'ftps:'].includes(urlObj.protocol)) {
+            return {
+                valid: false,
+                error: 'Invalid URL protocol',
+                errorCode: 'INVALID_URL',
+            };
+        }
+        return { valid: true };
+    }
+    catch {
+        return {
+            valid: false,
+            error: 'Invalid URL format',
+            errorCode: 'INVALID_URL',
+        };
     }
-    return item;
 }
-function mergeVideoUploadResult(payload, result) {
-    const base = normalizeVideoPayload(payload);
-    const videos = [...base.videos];
-    const i = videos.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const slot = i >= 0 ? videos[i] : undefined;
-    const url = resolvePersistableMediaUrl(result.url);
-    const next = {
-        ...(slot ?? { duration: 0, width: 0, height: 0 }),
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl ?? slot?.thumbnailUrl, url),
-        metadata: result.metadata,
-    };
-    if (url) {
-        next.url = url;
+// =====================
+// Helper Functions
+// =====================
+/**
+ * Sanitize user input to prevent XSS
+ * Note: Angular provides built-in sanitization, but this is an additional layer
+ * @param input - User input to sanitize
+ * @returns Sanitized input
+ */
+function sanitizeInput(input) {
+    if (!input)
+        return '';
+    return input
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;')
+        .replace(/\//g, '&#x2F;')
+        .replace(/`/g, '&#x60;')
+        .replace(/=/g, '&#x3D;');
+}
+/**
+ * Validate latitude coordinate
+ * @param latitude - Latitude to validate
+ * @returns Validation result
+ */
+function validateLatitude(latitude) {
+    if (latitude === undefined || latitude === null || typeof latitude !== 'number' || isNaN(latitude)) {
+        return {
+            valid: false,
+            error: 'Latitude is required',
+            errorCode: 'MISSING_LATITUDE',
+        };
+    }
+    if (latitude < -90 || latitude > 90) {
+        return {
+            valid: false,
+            error: 'Latitude must be between -90 and 90',
+            errorCode: 'INVALID_LATITUDE',
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate longitude coordinate
+ * @param longitude - Longitude to validate
+ * @returns Validation result
+ */
+function validateLongitude(longitude) {
+    if (longitude === undefined || longitude === null || typeof longitude !== 'number' || isNaN(longitude)) {
+        return {
+            valid: false,
+            error: 'Longitude is required',
+            errorCode: 'MISSING_LONGITUDE',
+        };
+    }
+    if (longitude < -180 || longitude > 180) {
+        return {
+            valid: false,
+            error: 'Longitude must be between -180 and 180',
+            errorCode: 'INVALID_LONGITUDE',
+        };
+    }
+    return { valid: true };
+}
+
+/**
+ * In-memory conversation and message graph (signal-based).
+ * Plain class — not DI-registered; instantiated by `AXConversationService`.
+ */
+function withNormalizedPayload(message) {
+    const timestamp = message.timestamp instanceof Date ? message.timestamp : new Date(message.timestamp);
+    return { ...message, timestamp, payload: normalizeMessagePayload(message.payload) };
+}
+class ConversationState {
+    constructor(config) {
+        this.config = config;
+        this._conversations = signal(new Map(), ...(ngDevMode ? [{ debugName: "_conversations" }] : /* istanbul ignore next */ []));
+        this._messages = signal(new Map(), ...(ngDevMode ? [{ debugName: "_messages" }] : /* istanbul ignore next */ []));
+        this._conversationMessages = signal(new Map(), ...(ngDevMode ? [{ debugName: "_conversationMessages" }] : /* istanbul ignore next */ []));
+        this.conversations = computed(() => {
+            const convMap = this._conversations();
+            return Array.from(convMap.values());
+        }, { ...(ngDevMode ? { debugName: "conversations" } : /* istanbul ignore next */ {}), equal: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]) });
+    }
+    setConversations(conversations) {
+        const convMap = new Map();
+        conversations.forEach((conv) => convMap.set(conv.id, conv));
+        this._conversations.set(convMap);
+    }
+    addConversations(conversations) {
+        this._conversations.update((existingConversations) => {
+            const newConversations = new Map(existingConversations);
+            conversations.forEach((conv) => newConversations.set(conv.id, conv));
+            const maxCached = this.config.maxCachedConversations;
+            if (newConversations.size > maxCached) {
+                const sorted = Array.from(newConversations.values()).sort((a, b) => (b.lastMessageAt?.getTime() ?? 0) - (a.lastMessageAt?.getTime() ?? 0));
+                const toKeep = sorted.slice(0, maxCached);
+                const cleanedMap = new Map();
+                toKeep.forEach((conv) => cleanedMap.set(conv.id, conv));
+                return cleanedMap;
+            }
+            return newConversations;
+        });
+    }
+    setConversation(conversation) {
+        this._conversations.update((conversations) => {
+            const newConversations = new Map(conversations);
+            newConversations.set(conversation.id, conversation);
+            return newConversations;
+        });
+    }
+    getConversation(conversationId) {
+        return this._conversations().get(conversationId);
+    }
+    updateConversation(conversationId, updates) {
+        const conversation = this._conversations().get(conversationId);
+        if (!conversation)
+            return;
+        this.setConversation({ ...conversation, ...updates });
+    }
+    deleteConversation(conversationId) {
+        this._conversations.update((conversations) => {
+            const newConversations = new Map(conversations);
+            newConversations.delete(conversationId);
+            return newConversations;
+        });
+        const messageIds = this._conversationMessages().get(conversationId) || [];
+        this._messages.update((messages) => {
+            const newMessages = new Map(messages);
+            messageIds.forEach((id) => newMessages.delete(id));
+            return newMessages;
+        });
+        this._conversationMessages.update((map) => {
+            const newMap = new Map(map);
+            newMap.delete(conversationId);
+            return newMap;
+        });
+    }
+    updateLastMessage(message) {
+        this.updateConversation(message.conversationId, {
+            lastMessage: message,
+            lastMessageAt: message.timestamp,
+            updatedAt: message.timestamp,
+        });
+    }
+    incrementUnreadCount(conversationId) {
+        const conversation = this._conversations().get(conversationId);
+        if (!conversation)
+            return;
+        this.updateConversation(conversationId, { unreadCount: conversation.unreadCount + 1 });
+    }
+    resetUnreadCount(conversationId) {
+        this.updateConversation(conversationId, { unreadCount: 0 });
+    }
+    updateSettings(conversationId, settings) {
+        const conversation = this._conversations().get(conversationId);
+        if (!conversation)
+            return;
+        this.updateConversation(conversationId, {
+            settings: { ...conversation.settings, ...settings },
+            updatedAt: new Date(),
+        });
+    }
+    updateTitle(conversationId, title) {
+        this.updateConversation(conversationId, { title, updatedAt: new Date() });
+    }
+    updateMetadata(conversationId, metadata) {
+        const conversation = this._conversations().get(conversationId);
+        if (!conversation)
+            return;
+        this.updateConversation(conversationId, {
+            metadata: { ...conversation.metadata, ...metadata },
+            updatedAt: new Date(),
+        });
+    }
+    updateTypingIndicator(conversationId, userId, isTyping) {
+        const conversation = this._conversations().get(conversationId);
+        if (!conversation)
+            return;
+        let typingUsers = [...conversation.status.typingUsers];
+        if (isTyping) {
+            if (!typingUsers.includes(userId)) {
+                typingUsers.push(userId);
+            }
+        }
+        else {
+            typingUsers = typingUsers.filter((id) => id !== userId);
+        }
+        this.updateConversation(conversationId, {
+            status: {
+                ...conversation.status,
+                isTyping: typingUsers.length > 0,
+                typingUsers,
+            },
+        });
+    }
+    updateParticipantPresence(userId, status, lastSeen) {
+        this._conversations.update((conversations) => {
+            const newConversations = new Map(conversations);
+            for (const [id, conv] of conversations) {
+                const participant = conv.participants.find((p) => p.id === userId);
+                if (participant) {
+                    const updatedConversation = {
+                        ...conv,
+                        participants: conv.participants.map((p) => (p.id === userId ? { ...p, status, lastSeen } : p)),
+                        status: conv.type === 'private' ? { ...conv.status, presence: status, lastSeen } : conv.status,
+                    };
+                    newConversations.set(id, updatedConversation);
+                }
+            }
+            return newConversations;
+        });
+    }
+    addMessage(message) {
+        const normalized = withNormalizedPayload(message);
+        this._messages.update((messages) => {
+            const newMessages = new Map(messages);
+            newMessages.set(normalized.id, normalized);
+            return newMessages;
+        });
+        this._conversationMessages.update((map) => {
+            const newMap = new Map(map);
+            const existing = newMap.get(normalized.conversationId) || [];
+            if (existing.includes(normalized.id)) {
+                return newMap;
+            }
+            const updated = [...existing, normalized.id].sort((a, b) => {
+                const msgA = this._messages().get(a);
+                const msgB = this._messages().get(b);
+                if (!msgA || !msgB)
+                    return 0;
+                return msgA.timestamp.getTime() - msgB.timestamp.getTime();
+            });
+            newMap.set(normalized.conversationId, updated);
+            return newMap;
+        });
+    }
+    /**
+     * Replace all messages for a conversation (initial page load).
+     */
+    setConversationMessages(conversationId, messages) {
+        const sorted = [...messages]
+            .map(withNormalizedPayload)
+            .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        const sortedIds = sorted.map((m) => m.id);
+        this._messages.update((msgs) => {
+            const newMessages = new Map(msgs);
+            const previousIds = this._conversationMessages().get(conversationId) || [];
+            for (const id of previousIds) {
+                newMessages.delete(id);
+            }
+            for (const msg of sorted) {
+                newMessages.set(msg.id, msg);
+            }
+            return newMessages;
+        });
+        this._conversationMessages.update((map) => {
+            const newMap = new Map(map);
+            newMap.set(conversationId, sortedIds);
+            return newMap;
+        });
+        this.cleanupOldMessages();
+    }
+    addMessages(messages) {
+        if (messages.length === 0)
+            return;
+        const normalized = messages.map(withNormalizedPayload);
+        this._messages.update((msgs) => {
+            const newMessages = new Map(msgs);
+            normalized.forEach((msg) => newMessages.set(msg.id, msg));
+            return newMessages;
+        });
+        const conversationGroups = new Map();
+        normalized.forEach((msg) => {
+            const existing = conversationGroups.get(msg.conversationId) || [];
+            existing.push(msg.id);
+            conversationGroups.set(msg.conversationId, existing);
+        });
+        this._conversationMessages.update((map) => {
+            const newMap = new Map(map);
+            for (const [conversationId, newMsgIds] of conversationGroups) {
+                const existing = newMap.get(conversationId) || [];
+                const idSet = new Set(existing);
+                const merged = [...existing];
+                for (const id of newMsgIds) {
+                    if (!idSet.has(id)) {
+                        merged.push(id);
+                        idSet.add(id);
+                    }
+                }
+                const sorted = merged.sort((a, b) => {
+                    const msgA = this._messages().get(a);
+                    const msgB = this._messages().get(b);
+                    if (!msgA || !msgB)
+                        return 0;
+                    return msgA.timestamp.getTime() - msgB.timestamp.getTime();
+                });
+                newMap.set(conversationId, sorted);
+            }
+            return newMap;
+        });
+        this.cleanupOldMessages();
+        this.cleanupConversationMessages();
+    }
+    getMessage(messageId) {
+        return this._messages().get(messageId);
+    }
+    getConversationMessages(conversationId) {
+        const messageIds = this._conversationMessages().get(conversationId) || [];
+        return messageIds.map((id) => this._messages().get(id)).filter((msg) => msg !== undefined);
+    }
+    updateMessage(messageId, updates) {
+        const message = this._messages().get(messageId);
+        if (!message)
+            return;
+        const merged = { ...message, ...updates };
+        if (updates.payload) {
+            merged.payload = normalizeMessagePayload(merged.payload);
+        }
+        this.addMessage(merged);
+    }
+    deleteMessage(messageId) {
+        const message = this._messages().get(messageId);
+        if (!message)
+            return;
+        this._messages.update((messages) => {
+            const newMessages = new Map(messages);
+            newMessages.delete(messageId);
+            return newMessages;
+        });
+        this._conversationMessages.update((map) => {
+            const newMap = new Map(map);
+            const existing = newMap.get(message.conversationId);
+            if (existing) {
+                newMap.set(message.conversationId, existing.filter((id) => id !== messageId));
+            }
+            return newMap;
+        });
+    }
+    cleanupOldMessages() {
+        const totalMessages = this._messages().size;
+        if (totalMessages > this.config.maxTotalMessages) {
+            const allMessages = Array.from(this._messages().values()).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+            const toKeep = allMessages.slice(0, this.config.maxTotalMessages);
+            const toKeepIds = new Set(toKeep.map((m) => m.id));
+            this._messages.update(() => {
+                const newMessages = new Map();
+                toKeep.forEach((msg) => newMessages.set(msg.id, msg));
+                return newMessages;
+            });
+            this._conversationMessages.update((map) => {
+                const newMap = new Map(map);
+                for (const [convId, messageIds] of newMap) {
+                    const filteredIds = messageIds.filter((id) => toKeepIds.has(id));
+                    newMap.set(convId, filteredIds);
+                }
+                return newMap;
+            });
+        }
+    }
+    cleanupConversationMessages() {
+        const maxMessages = this.config.maxMessagesPerConversation;
+        const idsToRemove = [];
+        this._conversationMessages.update((map) => {
+            const newMap = new Map(map);
+            for (const [convId, messageIds] of newMap) {
+                if (messageIds.length > maxMessages) {
+                    idsToRemove.push(...messageIds.slice(0, messageIds.length - maxMessages));
+                    newMap.set(convId, messageIds.slice(-maxMessages));
+                }
+            }
+            return newMap;
+        });
+        if (idsToRemove.length > 0) {
+            this._messages.update((messages) => {
+                const newMessages = new Map(messages);
+                idsToRemove.forEach((id) => newMessages.delete(id));
+                return newMessages;
+            });
+        }
     }
-    if (i >= 0)
-        videos[i] = next;
-    else
-        videos.push(next);
-    return { ...base, type: 'video', videos };
 }
-function applyVideoLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
-    const base = normalizeVideoPayload(payload);
-    const videos = [...base.videos];
-    const slot = videos.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const preview = { url: localUrl, duration: 0, width: 0, height: 0, mimeType };
-    if (slot >= 0) {
-        videos[slot] = { ...videos[slot], ...preview };
+
+/**
+ * Error Handler Service
+ * Centralized error handling and logging
+ */
+/**
+ * Error Handler Service
+ */
+class AXErrorHandlerService {
+    constructor() {
+        this.injectedConfig = inject(ERROR_HANDLER_CONFIG);
+        this._errors$ = new Subject();
+        this._config = {
+            logToConsole: true,
+            showUserMessages: true,
+            autoRetry: false,
+            maxRetries: 3,
+        };
+        /** Error stream */
+        this.errors$ = this._errors$.asObservable();
+        this.configure(this.injectedConfig);
     }
-    else if (videos.length === 0) {
-        videos.push(preview);
+    /**
+     * Configure error handler
+     */
+    configure(config) {
+        Object.assign(this._config, config);
     }
-    else {
-        videos[0] = { ...videos[0], ...preview };
+    /**
+     * Handle an error
+     */
+    handle(error, operation, context) {
+        const conversationError = this.normalizeError(error, operation, context);
+        this.publish(conversationError);
+        return conversationError;
     }
-    return { ...base, type: 'video', videos };
-}
-
-const CONVERSATION_VOICE_CATALOG = 'conversation-voice';
-const MB = 1024 * 1024;
-const CONVERSATION_VOICE_PRESENTATION = {
-    icon: 'fa-light fa-microphone text-green-500',
-    title: 'Voice message',
-};
-const VOICE_UTILITY = {
-    duration: 'duration',
-    formatDuration: 'formatDuration',
-    createLocalPreviewUrl: 'createLocalPreviewUrl',
-};
-function blobUrl(ctx, blob) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return '';
+    /**
+     * Handle API error (same pipeline as {@link handle}, for typed API failures)
+     */
+    handleApiError(apiError, operation, context) {
+        const conversationError = this.conversationErrorFromApi(apiError, operation, context);
+        this.publish(conversationError);
+        return conversationError;
     }
-    return URL.createObjectURL(blob);
-}
-function mediaDuration(ctx, file) {
-    if (!isPlatformBrowser(ctx.platformId)) {
-        return Promise.resolve(0);
+    publish(conversationError) {
+        this._errors$.next(conversationError);
+        if (this._config.logToConsole) {
+            this.logError(conversationError);
+        }
+        if (this._config.customHandler) {
+            this._config.customHandler(conversationError);
+        }
     }
-    return new Promise((resolve, reject) => {
-        const el = document.createElement('audio');
-        el.preload = 'metadata';
-        el.onloadedmetadata = () => {
-            URL.revokeObjectURL(el.src);
-            resolve(el.duration);
-        };
-        el.onerror = () => {
-            URL.revokeObjectURL(el.src);
-            reject(new Error('Failed to load audio metadata'));
+    /**
+     * Normalize any error to conversation error format (does not publish — use {@link handle})
+     */
+    normalizeError(error, operation, context) {
+        if (this.isApiError(error)) {
+            return this.conversationErrorFromApi(error, operation, context);
+        }
+        const errorObj = error;
+        const message = (typeof errorObj['message'] === 'string' && errorObj['message']) ||
+            (error instanceof Error ? error.message : String(error)) ||
+            'An unknown error occurred';
+        const code = (typeof errorObj['code'] === 'string' && errorObj['code']) || 'UNKNOWN_ERROR';
+        const statusCodeRaw = errorObj['statusCode'] ?? errorObj['status'];
+        const statusCode = typeof statusCodeRaw === 'number' ? statusCodeRaw : undefined;
+        return {
+            code,
+            message,
+            severity: 'error',
+            operation,
+            originalError: error,
+            statusCode,
+            context,
+            timestamp: new Date(),
+            handled: false,
+            recoverySuggestions: this.getDefaultRecoverySuggestions(code),
         };
-        el.src = URL.createObjectURL(file);
-    });
-}
-function conversationVoiceUtilities() {
-    return {
-        [VOICE_UTILITY.duration]: (ctx, file) => mediaDuration(ctx, file),
-        [VOICE_UTILITY.formatDuration]: (_ctx, seconds) => formatDuration(seconds),
-        [VOICE_UTILITY.createLocalPreviewUrl]: (ctx, source) => blobUrl(ctx, source),
-    };
-}
-function createConversationVoiceFileType() {
-    const presentation = CONVERSATION_VOICE_PRESENTATION;
-    return {
-        name: CONVERSATION_VOICE_CATALOG,
-        metadata: createFileTypeMetadata('conversation'),
-        title: presentation.title,
-        icon: presentation.icon,
-        validations: {
-            mimeTypes: ['audio/webm', 'audio/ogg', 'audio/mp4', 'audio/*'],
-            minSize: 1,
-            maxSize: 50 * MB,
-        },
-        utilities: conversationVoiceUtilities(),
-        copy: (payload) => {
-            const voice = payload;
-            const url = voice.url?.trim() ?? '';
-            return {
-                text: '',
-                meta: {
-                    kind: 'voice',
-                    url,
-                    duration: voice.duration,
-                    mimeType: voice.mimeType,
-                },
-            };
-        },
-    };
-}
-class AXConversationVoiceFileTypeProvider extends AXFileTypeInfoProvider {
-    items() {
-        return Promise.resolve([createConversationVoiceFileType()]);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVoiceFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVoiceFileTypeProvider, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXConversationVoiceFileTypeProvider, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-function mergeVoiceUploadResult(payload, result) {
-    return {
-        ...payload,
-        type: 'voice',
-        url: result.url,
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        metadata: result.metadata,
-    };
-}
-function applyVoiceLocalPreview(payload, localUrl) {
-    return { ...payload, type: 'voice', url: localUrl };
-}
-
-const MESSAGE_TYPE_FILE_TYPE = {
-    image: CONVERSATION_IMAGE_CATALOG,
-    video: CONVERSATION_VIDEO_CATALOG,
-    audio: CONVERSATION_AUDIO_CATALOG,
-    file: CONVERSATION_FILE_CATALOG,
-    voice: CONVERSATION_VOICE_CATALOG,
-    sticker: CONVERSATION_IMAGE_CATALOG,
-};
-/** Resolves {@link AXMessage.fileType} from command or message type. */
-function resolveMessageFileType(type, fileType) {
-    return fileType ?? MESSAGE_TYPE_FILE_TYPE[type];
-}
-function mergeImageUploadResult(payload, result) {
-    const base = normalizeImagePayload(payload);
-    const images = [...base.images];
-    const i = images.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const slot = i >= 0 ? images[i] : undefined;
-    const url = resolvePersistableMediaUrl(result.url);
-    const next = {
-        ...(slot ?? { width: 0, height: 0 }),
-        mediaId: result.mediaId,
-        mimeType: result.mimeType,
-        size: result.size,
-        thumbnailUrl: resolvePersistedThumbnailUrl(result.thumbnailUrl ?? slot?.thumbnailUrl, url),
-        metadata: result.metadata,
-    };
-    if (url) {
-        next.url = url;
     }
-    if (i >= 0)
-        images[i] = next;
-    else
-        images.push(next);
-    return { ...base, type: 'image', images };
-}
-function applyImageLocalPreview(payload, localUrl, mimeType = 'application/octet-stream') {
-    const base = normalizeImagePayload(payload);
-    const images = [...base.images];
-    const slot = images.findIndex((x) => !x.mediaId && !resolvePersistableMediaUrl(x.url));
-    const preview = { url: localUrl, width: 0, height: 0, mimeType };
-    if (slot >= 0) {
-        images[slot] = { ...images[slot], ...preview };
+    conversationErrorFromApi(apiError, operation, context) {
+        return {
+            code: apiError.code,
+            message: apiError.message,
+            severity: this.determineSeverity(apiError.statusCode),
+            operation,
+            originalError: apiError,
+            statusCode: apiError.statusCode,
+            context,
+            timestamp: apiError.timestamp ?? new Date(),
+            handled: false,
+            recoverySuggestions: this.getRecoverySuggestions(apiError),
+        };
     }
-    else if (images.length === 0) {
-        images.push(preview);
+    isApiError(error) {
+        return (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            'message' in error &&
+            typeof error.code === 'string' &&
+            typeof error.message === 'string');
     }
-    else {
-        images[0] = { ...images[0], ...preview };
+    /**
+     * Determine severity based on status code
+     */
+    determineSeverity(statusCode) {
+        if (!statusCode)
+            return 'error';
+        if (statusCode >= 500)
+            return 'critical';
+        if (statusCode >= 400)
+            return 'error';
+        if (statusCode >= 300)
+            return 'warning';
+        return 'info';
     }
-    return { ...base, type: 'image', images };
-}
-function mergeUploadResult(type, payload, result) {
-    switch (type) {
-        case 'image':
-            return mergeImageUploadResult(payload, result);
-        case 'video':
-            return mergeVideoUploadResult(payload, result);
-        case 'audio':
-            return mergeAudioUploadResult(payload, result);
-        case 'file':
-            return mergeFileUploadResult(payload, result);
-        case 'voice':
-            return mergeVoiceUploadResult(payload, result);
-        case 'sticker':
-            return {
-                ...payload,
-                type: 'sticker',
-                url: result.url,
-                mediaId: result.mediaId,
-            };
-        default:
-            return payload;
+    /**
+     * Get recovery suggestions based on error
+     */
+    getRecoverySuggestions(error) {
+        const suggestions = [];
+        if (error.statusCode === 401 || error.code === 'UNAUTHORIZED') {
+            suggestions.push('Please log in again');
+            suggestions.push('Check if your session has expired');
+        }
+        else if (error.statusCode === 403 || error.code === 'FORBIDDEN') {
+            suggestions.push('You do not have permission for this action');
+            suggestions.push('Ask your administrator for access');
+        }
+        else if (error.statusCode === 404 || error.code === 'NOT_FOUND') {
+            suggestions.push('The requested resource was not found');
+            suggestions.push('It may have been deleted or moved');
+        }
+        else if (error.statusCode === 429 || error.code === 'RATE_LIMIT_EXCEEDED') {
+            suggestions.push('Too many requests. Please wait and try again');
+        }
+        else if (error.statusCode && error.statusCode >= 500) {
+            suggestions.push('Server error occurred');
+            suggestions.push('Please try again later');
+            suggestions.push('If the problem persists, reach out to support');
+        }
+        else if (error.code === 'NETWORK_ERROR') {
+            suggestions.push('Check your internet connection');
+            suggestions.push('Try refreshing the page');
+        }
+        return suggestions;
     }
-}
-function applyLocalPreview(type, payload, localUrl, mimeType = 'application/octet-stream') {
-    switch (type) {
-        case 'image':
-            return applyImageLocalPreview(payload, localUrl, mimeType);
-        case 'video':
-            return applyVideoLocalPreview(payload, localUrl, mimeType);
-        case 'audio':
-            return applyAudioLocalPreview(payload, localUrl, mimeType);
-        case 'file':
-            return applyFileLocalPreview(payload, localUrl, mimeType);
-        case 'voice':
-            return applyVoiceLocalPreview(payload, localUrl);
-        case 'sticker':
-            return { ...payload, type: 'sticker', url: localUrl };
-        default:
-            return payload;
+    /**
+     * Get default recovery suggestions
+     */
+    getDefaultRecoverySuggestions(code) {
+        const suggestions = [];
+        if (code.includes('NETWORK') || code.includes('CONNECTION')) {
+            suggestions.push('Check your internet connection');
+            suggestions.push('Try refreshing the page');
+        }
+        else if (code.includes('TIMEOUT')) {
+            suggestions.push('The operation took too long');
+            suggestions.push('Please try again');
+        }
+        else {
+            suggestions.push('Please try again');
+            suggestions.push('If the problem persists, reach out to support');
+        }
+        return suggestions;
     }
-}
-function toUploaderReference$1(payload) {
-    switch (payload.type) {
-        case 'image': {
-            const first = payload.images[0];
-            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
+    /**
+     * Log error to console
+     */
+    logError(error) {
+        const isError = error.severity === 'critical' || error.severity === 'error';
+        const header = `[Conversation ${error.severity.toUpperCase()}] ${error.operation}:`;
+        if (isError) {
+            console.error(header, error.message, error.context || '');
         }
-        case 'video': {
-            const first = payload.videos[0];
-            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
+        else {
+            console.warn(header, error.message, error.context || '');
         }
-        case 'audio': {
-            const first = payload.audios[0];
-            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
+        if (error.originalError && error.severity !== 'info') {
+            console.error('Original error:', error.originalError);
         }
-        case 'file': {
-            const first = payload.files[0];
-            return { url: first?.url, mediaId: first?.mediaId, mimeType: first?.mimeType, size: first?.size };
+        if (error.recoverySuggestions && error.recoverySuggestions.length > 0) {
+            console.info('Recovery suggestions:', error.recoverySuggestions);
         }
-        case 'voice':
-        case 'sticker':
-            return {
-                url: payload.url,
-                mediaId: payload.mediaId,
-                mimeType: payload.mimeType,
-                size: payload.size,
-            };
-        default:
-            return {};
     }
-}
-function createObjectUrl(platformId, blob) {
-    if (!isPlatformBrowser(platformId)) {
-        return '';
+    /**
+     * Get user-friendly error message
+     */
+    getUserFriendlyMessage(error) {
+        // Map technical errors to user-friendly messages
+        const messageMap = {
+            NETWORK_ERROR: 'Unable to connect. Please check your internet connection.',
+            UNAUTHORIZED: 'You are not authorized. Please log in again.',
+            FORBIDDEN: 'You do not have permission to perform this action.',
+            NOT_FOUND: 'The requested item could not be found.',
+            RATE_LIMIT_EXCEEDED: 'Too many requests. Please slow down.',
+            VALIDATION_ERROR: 'The provided data is invalid.',
+            SERVER_ERROR: 'A server error occurred. Please try again later.',
+            TIMEOUT: 'The operation timed out. Please try again.',
+        };
+        return messageMap[error.code] || error.message || 'An unexpected error occurred.';
     }
-    return URL.createObjectURL(blob);
-}
-function revokeObjectUrl(platformId, url) {
-    if (isPlatformBrowser(platformId) && url.startsWith('blob:')) {
-        URL.revokeObjectURL(url);
+    /**
+     * Check if error is retryable
+     */
+    isRetryable(error) {
+        const retryableCodes = ['NETWORK_ERROR', 'TIMEOUT', 'RATE_LIMIT_EXCEEDED', 'SERVER_ERROR'];
+        const retryableStatusCodes = [408, 429, 500, 502, 503, 504];
+        return (retryableCodes.includes(error.code) ||
+            (error.statusCode !== undefined && retryableStatusCodes.includes(error.statusCode)));
     }
-}
-async function createLocalPreviewUrl(fileService, platformId, source, messageType) {
-    const catalog = MESSAGE_TYPE_FILE_TYPE[messageType];
-    if (!catalog) {
-        return undefined;
+    /**
+     * Execute an operation with automatic retry logic
+     * @param operation - The async operation to execute
+     * @param operationName - Name of the operation for error tracking
+     * @param context - Additional context for error handling
+     * @returns Promise resolving to the operation result
+     * @throws {AXConversationError} If all retries fail
+     */
+    async executeWithRetry(operation, operationName, context) {
+        if (!this._config.autoRetry) {
+            // If auto-retry is disabled, just execute once
+            return operation();
+        }
+        const maxRetries = this._config.maxRetries ?? 3;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                const conversationError = this.handle(error, operationName, { ...context, attempt });
+                // Don't retry if error is not retryable or if this was the last attempt
+                if (!this.isRetryable(conversationError) || attempt >= maxRetries) {
+                    throw conversationError;
+                }
+                // Exponential backoff: 1s, 2s, 4s, 8s...
+                const delayMs = Math.pow(2, attempt) * 1000;
+                await this.delay(delayMs);
+            }
+        }
+        throw this.handle(lastError, operationName, context);
     }
-    const fileType = await fileService.getFileType(catalog);
-    if (!fileType) {
-        return undefined;
+    /**
+     * Delay helper for retry backoff
+     * @param ms - Milliseconds to delay
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    const ctx = { readAsDataUrl: (f) => fileService.blobToBase64(f), platformId };
-    const extension = resolveFileTypeExtension(fileType, {
-        file: source instanceof File ? source : undefined,
-        mimeType: source.type,
-    });
-    const result = await runFileTypeUtility(fileType, ctx, extension, 'createLocalPreviewUrl', source);
-    return typeof result === 'string' ? result : undefined;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXErrorHandlerService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXErrorHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
 
 /**
  * AXComposerService
@@ -9111,7 +9114,7 @@ class AXConversationIndexedDbRealtimeApi extends AXRealtimeApi {
     // Message Events
     // =====================
     subscribeToMessages(conversationId) {
-        return conversationSharedStorage.messageStream$.pipe(filter((msg) => msg.conversationId === conversationId));
+        return conversationSharedStorage.messageStream$.pipe(filter((msg) => !conversationId || msg.conversationId === conversationId));
     }
     subscribeToMessageUpdates(_conversationId) {
         return conversationSharedStorage.messageUpdates$;
@@ -15078,9 +15081,7 @@ class AXConversationService {
                 return null;
             }
             const conversation = this.state.getConversation(id);
-            return conversation
-                ? resolveConversationForViewer(conversation, this._currentUser()?.id)
-                : null;
+            return conversation ? resolveConversationForViewer(conversation, this._currentUser()?.id) : null;
         }, ...(ngDevMode ? [{ debugName: "activeConversation" }] : /* istanbul ignore next */ []));
         /** Messages for active conversation */
         this.activeMessages = computed(() => {
@@ -15215,6 +15216,18 @@ class AXConversationService {
             .subscribe((conversation) => {
             this.handleConversationUpdate(conversation);
         });
+        // Global message stream — backs message list even when the backend only pushes
+        // conversation.lastMessage updates or when per-conversation subscribe races loadMessages.
+        this.realtimeApi
+            .subscribeToMessages('')
+            .pipe(takeUntil(this.destroy$), catchError((error) => {
+            this.errorHandler.handle(error, 'subscribeToMessages');
+            return EMPTY;
+        }))
+            .subscribe((message) => {
+            this.handleNewMessage(message);
+            this._messageReceived$.next(message);
+        });
     }
     /**
      * Load conversations from server
@@ -15288,19 +15301,6 @@ class AXConversationService {
             finally {
                 this._loadingActiveMessages.set(false);
             }
-            // Subscribe to new messages with error handling (only if realtime is available)
-            if (this.realtimeApi) {
-                this.realtimeApi
-                    .subscribeToMessages(conversationId)
-                    .pipe(takeUntil(this._conversationSwitch$), takeUntil(this.destroy$), catchError((error) => {
-                    this.errorHandler.handle(error, 'subscribeToMessages', { conversationId });
-                    return EMPTY;
-                }))
-                    .subscribe((message) => {
-                    this.handleNewMessage(message);
-                    this._messageReceived$.next(message);
-                });
-            }
         }
         catch (error) {
             this.errorHandler.handle(error, 'selectConversation', { conversationId });
@@ -15699,11 +15699,15 @@ class AXConversationService {
      * Handle new message received
      */
     handleNewMessage(message) {
+        if (this.state.getMessage(message.id)) {
+            return;
+        }
         this.state.addMessage(message);
         this.state.updateLastMessage(message);
         const currentId = this._currentUser()?.id ?? 'current-user';
         const isFromOtherUser = message.senderId !== currentId;
-        if (isFromOtherUser) {
+        const isActiveConversation = message.conversationId === this._activeConversationId();
+        if (isFromOtherUser && !isActiveConversation) {
             this.state.incrementUnreadCount(message.conversationId);
         }
     }
@@ -15711,6 +15715,13 @@ class AXConversationService {
      * Handle message update
      */
     handleMessageUpdate(message) {
+        const existing = this.state.getMessage(message.id);
+        if (!existing) {
+            if (message.conversationId === this._activeConversationId()) {
+                this.handleNewMessage(message);
+            }
+            return;
+        }
         this.state.updateMessage(message.id, message);
     }
     /**
@@ -15759,6 +15770,12 @@ class AXConversationService {
      * Updates conversation metadata including unread count, last message, etc.
      */
     handleConversationUpdate(conversation) {
+        const lastMessage = conversation.lastMessage;
+        if (lastMessage &&
+            conversation.id === this._activeConversationId() &&
+            !this.state.getMessage(lastMessage.id)) {
+            this.state.addMessage(lastMessage);
+        }
         this.state.setConversation(conversation);
     }
     /**
@@ -15884,12 +15901,8 @@ class AXConversationService {
                 creatorId,
                 title: isPrivate ? undefined : metadata?.['title'],
                 description: metadata?.['description'],
-                avatar: isPrivate
-                    ? undefined
-                    : AXConversationService.normalizeOptionalString(metadata?.['avatar']),
-                icon: isPrivate
-                    ? undefined
-                    : AXConversationService.normalizeOptionalString(metadata?.['icon']),
+                avatar: isPrivate ? undefined : AXConversationService.normalizeOptionalString(metadata?.['avatar']),
+                icon: isPrivate ? undefined : AXConversationService.normalizeOptionalString(metadata?.['icon']),
                 metadata: isPrivate ? undefined : metadata,
             });
             this.state.setConversation(conversation);
@@ -15938,7 +15951,9 @@ class AXConversationService {
         const conversation = this.state.getConversation(conversationId);
         const conversationTitle = conversation?.title || this.translation.translateSync('@acorex:chat.fallbacks.this-conversation');
         // Show confirmation dialog
-        const result = await this.dialogService.confirm(this.translation.translateSync('@acorex:chat.dialog.delete-conversation.title'), this.translation.translateSync('@acorex:chat.dialog.delete-conversation.message', { params: { conversationTitle } }), 'danger', 'vertical', false);
+        const result = await this.dialogService.confirm(this.translation.translateSync('@acorex:chat.dialog.delete-conversation.title'), this.translation.translateSync('@acorex:chat.dialog.delete-conversation.message', {
+            params: { conversationTitle },
+        }), 'danger', 'vertical', false);
         // User cancelled
         if (!result.result) {
             return false;
@@ -20026,11 +20041,12 @@ class AXMessageListComponent {
         }
     }
     /**
-     * TrackBy function for message groups
-     * Tracks by date only to prevent re-rendering when messages are added
+     * TrackBy function for message groups.
+     * Include the latest message id so new messages in the same date group re-render.
      */
     trackMessageGroup(index, group) {
-        return group.date;
+        const lastId = group.messages.at(-1)?.id ?? `empty-${index}`;
+        return `${group.date}:${lastId}`;
     }
     /**
      * TrackBy function for messages