diff --git a/dev/tool/src/clean.ts b/dev/tool/src/clean.ts
index e3022a3d1a..33ad27850e 100644
--- a/dev/tool/src/clean.ts
+++ b/dev/tool/src/clean.ts
@@ -20,7 +20,6 @@ import { loadCollaborativeDoc, saveCollaborativeDoc, yDocToBuffer } from '@hceng
 import contact from '@hcengineering/contact'
 import core, {
   type ArrOf,
-  type AttachedDoc,
   type BackupClient,
   type Class,
   ClassifierKind,
@@ -47,7 +46,6 @@ import core, {
   type StatusCategory,
   type Tx,
   type TxCUD,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxMixin,
   TxOperations,
@@ -158,16 +156,6 @@ export async function cleanWorkspace (
               await db.collection(DOMAIN_TX).deleteMany({ objectId: (tx as TxRemoveDoc<Doc>).objectId })
               processed++
             }
-            if (
-              tx._class === core.class.TxCollectionCUD &&
-              (tx as TxCollectionCUD<Doc, AttachedDoc>).tx._class === core.class.TxRemoveDoc
-            ) {
-              // We need to remove all update and create operations for document
-              await db.collection(DOMAIN_TX).deleteMany({
-                'tx.objectId': ((tx as TxCollectionCUD<Doc, AttachedDoc>).tx as TxRemoveDoc<Doc>).objectId
-              })
-              processed++
-            }
           }
           if (processed % 1000 === 0) {
             console.log('processed', processed)
@@ -219,18 +207,13 @@ export async function cleanRemovedTransactions (workspaceId: WorkspaceId, transa
   try {
     let count = 0
     while (true) {
-      const removedDocs = await connection.findAll(
-        core.class.TxCollectionCUD,
-        { 'tx._class': core.class.TxRemoveDoc },
-        { limit: 1000 }
-      )
+      const removedDocs = await connection.findAll(core.class.TxRemoveDoc, {}, { limit: 1000 })
       if (removedDocs.length === 0) {
         break
       }
 
-      const toRemove = await connection.findAll(core.class.TxCollectionCUD, {
-        'tx._class': { $in: [core.class.TxCreateDoc, core.class.TxRemoveDoc, core.class.TxUpdateDoc] },
-        'tx.objectId': { $in: removedDocs.map((it) => it.tx.objectId) }
+      const toRemove = await connection.findAll(core.class.TxCUD, {
+        objectId: { $in: removedDocs.map((it) => it.objectId) }
       })
       await connection.clean(
         DOMAIN_TX,
@@ -368,20 +351,18 @@ export async function fixCommentDoubleIdCreate (workspaceId: WorkspaceId, transa
     mode: 'backup'
   })) as unknown as CoreClient & BackupClient
   try {
-    const commentTxes = await connection.findAll(core.class.TxCollectionCUD, {
-      'tx._class': core.class.TxCreateDoc,
-      'tx.objectClass': chunter.class.ChatMessage
+    const commentTxes = await connection.findAll(core.class.TxCreateDoc, {
+      objectClass: chunter.class.ChatMessage
     })
-    const commentTxesRemoved = await connection.findAll(core.class.TxCollectionCUD, {
-      'tx._class': core.class.TxRemoveDoc,
-      'tx.objectClass': chunter.class.ChatMessage
+    const commentTxesRemoved = await connection.findAll(core.class.TxRemoveDoc, {
+      objectClass: chunter.class.ChatMessage
     })
-    const removed = new Map(commentTxesRemoved.map((it) => [it.tx.objectId, it]))
+    const removed = new Map(commentTxesRemoved.map((it) => [it.objectId, it]))
     // Do not checked removed
     const objSet = new Set<Ref<Doc>>()
     const oldValue = new Map<Ref<Doc>, string>()
     for (const c of commentTxes) {
-      const cid = c.tx.objectId
+      const cid = c.objectId
       if (removed.has(cid)) {
         continue
       }
@@ -389,7 +370,7 @@ export async function fixCommentDoubleIdCreate (workspaceId: WorkspaceId, transa
       objSet.add(cid)
       if (has) {
         // We have found duplicate one, let's rename it.
-        const doc = TxProcessor.createDoc2Doc<ChatMessage>(c.tx as unknown as TxCreateDoc<ChatMessage>)
+        const doc = TxProcessor.createDoc2Doc<ChatMessage>(c as unknown as TxCreateDoc<ChatMessage>)
         if (doc.message !== '' && doc.message.trim() !== '<p></p>') {
           await connection.clean(DOMAIN_TX, [c._id])
           if (oldValue.get(cid) === doc.message.trim()) {
@@ -398,8 +379,8 @@ export async function fixCommentDoubleIdCreate (workspaceId: WorkspaceId, transa
             oldValue.set(doc._id, doc.message)
             console.log('renaming', cid, doc.message)
             // Remove previous transaction.
-            c.tx.objectId = generateId()
-            doc._id = c.tx.objectId as Ref<ChatMessage>
+            c.objectId = generateId()
+            doc._id = c.objectId as Ref<ChatMessage>
             await connection.upload(DOMAIN_TX, [c])
             // Also we need to create snapsot
             await connection.upload(DOMAIN_ACTIVITY, [doc])
diff --git a/dev/tool/src/mixin.ts b/dev/tool/src/mixin.ts
index d967b9a974..1fb66f142c 100644
--- a/dev/tool/src/mixin.ts
+++ b/dev/tool/src/mixin.ts
@@ -215,17 +215,7 @@ async function getMixinWithForeignProperties (
               { limit: 1, sort: { modifiedOn: SortingOrder.Descending } }
             )
 
-            const collectionTx = await connection.findAll(
-              core.class.TxCollectionCUD,
-              {
-                'tx._class': core.class.TxUpdateDoc,
-                'tx.objectId': doc._id,
-                [`tx.operations.${property}`]: { $exists: true }
-              },
-              { limit: 1, sort: { modifiedOn: SortingOrder.Descending } }
-            )
-
-            const cModifiedOn = Math.max(updateDocTx[0]?.modifiedOn ?? 0, collectionTx[0]?.modifiedOn ?? 0)
+            const cModifiedOn = updateDocTx[0]?.modifiedOn ?? 0
             const mModifiedOn = mixinTx[0]?.modifiedOn ?? 0
 
             properties.push({ name: property, cValue, mValue, cModifiedOn, mModifiedOn })
diff --git a/models/core/src/index.ts b/models/core/src/index.ts
index ef1b6c943a..26445f9f9d 100644
--- a/models/core/src/index.ts
+++ b/models/core/src/index.ts
@@ -24,12 +24,7 @@ import {
   DOMAIN_STATUS,
   DOMAIN_TRANSIENT,
   DOMAIN_TX,
-  systemAccountEmail,
-  type AttachedDoc,
-  type Class,
-  type Doc,
-  type IndexingConfiguration,
-  type TxCollectionCUD
+  systemAccountEmail
 } from '@hcengineering/core'
 import { type Builder } from '@hcengineering/model'
 import { TBenchmarkDoc } from './benchmark'
@@ -91,17 +86,7 @@ import {
 import { defineSpaceType } from './spaceType'
 import { TDomainStatusPlaceholder, TStatus, TStatusCategory } from './status'
 import { TUserStatus } from './transient'
-import {
-  TTx,
-  TTxApplyIf,
-  TTxCollectionCUD,
-  TTxCreateDoc,
-  TTxCUD,
-  TTxMixin,
-  TTxRemoveDoc,
-  TTxUpdateDoc,
-  TTxWorkspaceEvent
-} from './tx'
+import { TTx, TTxApplyIf, TTxCreateDoc, TTxCUD, TTxMixin, TTxRemoveDoc, TTxUpdateDoc, TTxWorkspaceEvent } from './tx'
 
 export { coreId, DOMAIN_SPACE } from '@hcengineering/core'
 export * from './core'
@@ -122,7 +107,6 @@ export function createModel (builder: Builder): void {
     TTxCUD,
     TTxCreateDoc,
     TAttachedDoc,
-    TTxCollectionCUD,
     TTxMixin,
     TTxUpdateDoc,
     TTxRemoveDoc,
@@ -188,14 +172,6 @@ export function createModel (builder: Builder): void {
     core.account.System
   )
 
-  builder.mixin<Class<TxCollectionCUD<Doc, AttachedDoc>>, IndexingConfiguration<TxCollectionCUD<Doc, AttachedDoc>>>(
-    core.class.TxCollectionCUD,
-    core.class.Class,
-    core.mixin.IndexConfiguration,
-    {
-      indexes: ['tx.objectId', 'tx.operations.attachedTo']
-    }
-  )
   builder.createDoc(core.class.DomainIndexConfiguration, core.space.Model, {
     domain: DOMAIN_TX,
     disabled: [
diff --git a/models/core/src/migration.ts b/models/core/src/migration.ts
index a692f66ab1..815481049e 100644
--- a/models/core/src/migration.ts
+++ b/models/core/src/migration.ts
@@ -15,11 +15,14 @@
 
 import { saveCollaborativeDoc } from '@hcengineering/collaboration'
 import core, {
+  type Class,
   DOMAIN_SPACE,
   DOMAIN_STATUS,
   DOMAIN_TX,
   MeasureMetricsContext,
   RateLimiter,
+  type Ref,
+  type TxCUD,
   collaborativeDocParse,
   coreId,
   generateId,
@@ -285,6 +288,39 @@ export const coreOperation: MigrateOperation = {
           await client.update(DOMAIN_TX, { '%hash%': { $exists: true } }, { $set: { '%hash%': null } })
           await client.update(DOMAIN_SPACE, { '%hash%': { $exists: true } }, { $set: { '%hash%': null } })
         }
+      },
+      {
+        state: 'remove-collection-txes',
+        func: async (client) => {
+          let processed = 0
+          while (true) {
+            const txes = await client.find<TxCUD<Doc>>(
+              DOMAIN_TX,
+              {
+                _class: 'core:class:TxCollectionCUD' as Ref<Class<Doc>>
+              },
+              { limit: 5000 }
+            )
+            if (txes.length === 0) break
+            for (const tx of txes) {
+              processed++
+              await client.update(
+                DOMAIN_TX,
+                { _id: tx._id },
+                {
+                  $set: {
+                    attachedTo: tx.objectId,
+                    attachedToClass: tx.objectClass,
+                    ...(tx as any).tx
+                  }
+                }
+              )
+              if (processed % 1000 === 0) {
+                console.log('processed', processed)
+              }
+            }
+          }
+        }
       }
     ])
   },
diff --git a/models/core/src/tx.ts b/models/core/src/tx.ts
index c12cfd1e09..f688761ecf 100644
--- a/models/core/src/tx.ts
+++ b/models/core/src/tx.ts
@@ -14,7 +14,6 @@
 //
 
 import {
-  type AttachedDoc,
   type Class,
   type Data,
   type Doc,
@@ -28,7 +27,6 @@ import {
   type Space,
   type Tx,
   type TxApplyIf,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxCUD,
   type TxMixin,
@@ -72,12 +70,6 @@ export class TTxCreateDoc<T extends Doc> extends TTxCUD<T> implements TxCreateDo
   attributes!: Data<T>
 }
 
-@Model(core.class.TxCollectionCUD, core.class.TxCUD)
-export class TTxCollectionCUD<T extends Doc, P extends AttachedDoc> extends TTxCUD<T> implements TxCollectionCUD<T, P> {
-  collection!: string
-  tx!: TxCUD<P>
-}
-
 @Model(core.class.TxMixin, core.class.TxCUD)
 export class TTxMixin<D extends Doc, M extends D> extends TTxCUD<D> implements TxMixin<D, M> {
   mixin!: Ref<Mixin<M>>
diff --git a/models/server-activity/src/index.ts b/models/server-activity/src/index.ts
index 5d4820a247..c48dec6f71 100644
--- a/models/server-activity/src/index.ts
+++ b/models/server-activity/src/index.ts
@@ -36,14 +36,16 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverActivity.trigger.OnReactionChanged,
     txMatch: {
-      collection: 'reactions',
-      _class: core.class.TxCollectionCUD
+      collection: 'reactions'
     },
     isAsync: true
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverActivity.trigger.ActivityMessagesHandler,
+    txMatch: {
+      objectClass: { $nin: [activity.class.ActivityMessage, notification.class.DocNotifyContext] }
+    },
     isAsync: true
   })
 
@@ -54,8 +56,8 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverActivity.trigger.ReferenceTrigger,
     txMatch: {
-      'tx.objectClass': { $ne: activity.class.ActivityReference },
-      objectClass: {
+      objectClass: { $ne: activity.class.ActivityReference },
+      attachedToClass: {
         $nin: [
           notification.class.InboxNotification,
           notification.class.DocNotifyContext,
diff --git a/models/server-activity/src/migration.ts b/models/server-activity/src/migration.ts
index f570bde1c9..24f1b44ac4 100644
--- a/models/server-activity/src/migration.ts
+++ b/models/server-activity/src/migration.ts
@@ -18,16 +18,13 @@ import core, {
   MeasureMetricsContext,
   SortingOrder,
   TxFactory,
-  TxProcessor,
   toFindResult,
   toIdMap,
-  type AttachedDoc,
   type Class,
   type Doc,
   type Ref,
   type Tx,
   type TxCUD,
-  type TxCollectionCUD,
   type TxCreateDoc
 } from '@hcengineering/core'
 import {
@@ -85,12 +82,11 @@ async function generateDocUpdateMessageByTx (
     tx,
     control,
     undefined,
-    undefined,
     objectCache
   )
 
   for (const collectionTx of createCollectionCUDTxes) {
-    const createTx = collectionTx.tx as TxCreateDoc<DocUpdateMessage>
+    const createTx = collectionTx as TxCreateDoc<DocUpdateMessage>
     const domain = client.hierarchy.getDomain(createTx.objectClass)
 
     await client.create<DocUpdateMessage>(domain, {
@@ -152,15 +148,14 @@ async function createDocUpdateMessages (client: MigrationClient): Promise<void>
             continue
           }
 
-          if (v._class === core.class.TxCollectionCUD) {
+          if (v.attachedToClass !== undefined && v.attachedTo !== undefined) {
             try {
-              const vcol = v as TxCollectionCUD<Doc, AttachedDoc>
-              const _cl = client.hierarchy.getBaseClass(vcol.tx.objectClass)
+              const _cl = client.hierarchy.getBaseClass(v.attachedToClass)
               const s = byClass.get(_cl) ?? new Set()
-              s.add(vcol.tx.objectId)
+              s.add(v.attachedTo)
               byClass.set(_cl, s)
             } catch {
-              const objClass = (v as TxCollectionCUD<Doc, AttachedDoc>).tx.objectClass
+              const objClass = v.attachedToClass
               const has = classNotFound.has(objClass)
               if (!has) {
                 classNotFound.add(objClass)
@@ -198,8 +193,7 @@ async function createDocUpdateMessages (client: MigrationClient): Promise<void>
         }
         const transactions = allTransactions.get(d._id) ?? []
         for (const tx of transactions) {
-          const innerTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-          txIds.add(innerTx._id)
+          txIds.add(tx._id)
         }
       }
 
@@ -220,10 +214,8 @@ async function createDocUpdateMessages (client: MigrationClient): Promise<void>
         }
         const transactions = allTransactions.get(d._id) ?? []
         for (const tx of transactions) {
-          const innerTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-
-          if (!client.hierarchy.hasClass(innerTx.objectClass)) {
-            const objClass = innerTx.objectClass
+          if (!client.hierarchy.hasClass(tx.objectClass)) {
+            const objClass = tx.objectClass
             const has = classNotFound.has(objClass)
             if (!has) {
               classNotFound.add(objClass)
diff --git a/models/server-attachment/src/index.ts b/models/server-attachment/src/index.ts
index ffabc76d7e..699e983fad 100644
--- a/models/server-attachment/src/index.ts
+++ b/models/server-attachment/src/index.ts
@@ -27,9 +27,8 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverAttachment.trigger.OnAttachmentDelete,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': attachment.class.Attachment,
-      'tx._class': core.class.TxRemoveDoc
+      _class: core.class.TxRemoveDoc,
+      objectClass: attachment.class.Attachment
     }
   })
 }
diff --git a/models/server-calendar/src/index.ts b/models/server-calendar/src/index.ts
index 13d285e317..06567046db 100644
--- a/models/server-calendar/src/index.ts
+++ b/models/server-calendar/src/index.ts
@@ -44,7 +44,7 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverCalendar.trigger.OnEvent,
     txMatch: {
-      'tx.objectClass': calendar.class.Event
+      objectClass: calendar.class.Event
     }
   })
 
diff --git a/models/server-chunter/src/index.ts b/models/server-chunter/src/index.ts
index 5887285e75..4f63c95de9 100644
--- a/models/server-chunter/src/index.ts
+++ b/models/server-chunter/src/index.ts
@@ -78,18 +78,16 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverChunter.trigger.OnChatMessageRemoved,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx._class': core.class.TxRemoveDoc,
-      'tx.objectClass': chunter.class.ChatMessage
+      _class: core.class.TxRemoveDoc,
+      objectClass: chunter.class.ChatMessage
     }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverChunter.trigger.ChatNotificationsHandler,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx._class': core.class.TxCreateDoc,
-      'tx.objectClass': chunter.class.ChatMessage
+      _class: core.class.TxCreateDoc,
+      objectClass: chunter.class.ChatMessage
     },
     isAsync: true
   })
diff --git a/models/server-collaboration/src/index.ts b/models/server-collaboration/src/index.ts
index 30e6796737..bbccadf756 100644
--- a/models/server-collaboration/src/index.ts
+++ b/models/server-collaboration/src/index.ts
@@ -23,6 +23,9 @@ export { serverCollaborationId } from '@hcengineering/server-collaboration'
 
 export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
-    trigger: serverCollaboration.trigger.OnDelete
+    trigger: serverCollaboration.trigger.OnDelete,
+    txMatch: {
+      _class: core.class.TxRemoveDoc
+    }
   })
 }
diff --git a/models/server-controlled-documents/src/index.ts b/models/server-controlled-documents/src/index.ts
index 1bd4370205..535e3a0b4f 100644
--- a/models/server-controlled-documents/src/index.ts
+++ b/models/server-controlled-documents/src/index.ts
@@ -33,11 +33,10 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverDocuments.trigger.OnDocApprovalRequestApproved,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      objectClass: documents.class.ControlledDocument,
-      'tx._class': core.class.TxUpdateDoc,
-      'tx.objectClass': documents.class.DocumentApprovalRequest,
-      'tx.operations.status': RequestStatus.Completed
+      _class: core.class.TxUpdateDoc,
+      attachedToClass: documents.class.ControlledDocument,
+      objectClass: documents.class.DocumentApprovalRequest,
+      'operations.status': RequestStatus.Completed
     }
   })
 
diff --git a/models/server-gmail/src/index.ts b/models/server-gmail/src/index.ts
index 3715b8f060..d1837e989c 100644
--- a/models/server-gmail/src/index.ts
+++ b/models/server-gmail/src/index.ts
@@ -42,9 +42,8 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverGmail.trigger.OnMessageCreate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': gmail.class.Message,
-      'tx._class': core.class.TxCreateDoc
+      _class: core.class.TxCreateDoc,
+      objectClass: gmail.class.Message
     }
   })
 
diff --git a/models/server-hr/src/index.ts b/models/server-hr/src/index.ts
index da31dc0808..5370433f12 100644
--- a/models/server-hr/src/index.ts
+++ b/models/server-hr/src/index.ts
@@ -44,27 +44,24 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverHr.trigger.OnRequestCreate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': hr.class.Request,
-      'tx._class': core.class.TxCreateDoc
+      _class: core.class.TxCreateDoc,
+      objectClass: hr.class.Request
     }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverHr.trigger.OnRequestUpdate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': hr.class.Request,
-      'tx._class': core.class.TxUpdateDoc
+      _class: core.class.TxUpdateDoc,
+      objectClass: hr.class.Request
     }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverHr.trigger.OnRequestRemove,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': hr.class.Request,
-      'tx._class': core.class.TxRemoveDoc
+      _class: core.class.TxRemoveDoc,
+      objectClass: hr.class.Request
     }
   })
 
@@ -88,9 +85,8 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverHr.trigger.OnPublicHolidayCreate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': hr.class.PublicHoliday,
-      'tx._class': core.class.TxCreateDoc
+      _class: core.class.TxCreateDoc,
+      objectClass: hr.class.PublicHoliday
     }
   })
 
diff --git a/models/server-notification/src/index.ts b/models/server-notification/src/index.ts
index 7a84045db4..02d29ebba8 100644
--- a/models/server-notification/src/index.ts
+++ b/models/server-notification/src/index.ts
@@ -89,7 +89,10 @@ export function createModel (builder: Builder): void {
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
-    trigger: serverNotification.trigger.OnDocRemove
+    trigger: serverNotification.trigger.OnDocRemove,
+    txMatch: {
+      _class: core.class.TxRemoveDoc
+    }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
diff --git a/models/server-request/src/index.ts b/models/server-request/src/index.ts
index 007cceb17d..57bf3580f8 100644
--- a/models/server-request/src/index.ts
+++ b/models/server-request/src/index.ts
@@ -25,7 +25,10 @@ export { serverRequestId } from '@hcengineering/server-request'
 
 export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
-    trigger: serverRequest.trigger.OnRequest
+    trigger: serverRequest.trigger.OnRequest,
+    txMatch: {
+      objectClass: request.class.Request
+    }
   })
 
   builder.mixin(request.class.Request, core.class.Class, serverNotification.mixin.TextPresenter, {
diff --git a/models/server-setting/src/index.ts b/models/server-setting/src/index.ts
index 8f0b5b3a34..403b10f9e8 100644
--- a/models/server-setting/src/index.ts
+++ b/models/server-setting/src/index.ts
@@ -68,11 +68,8 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverSetting.trigger.OnRoleNameUpdate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      objectSpace: core.space.Model,
-      collection: 'roles',
-      'tx._class': core.class.TxUpdateDoc,
-      'tx.objectClass': core.class.Role
+      _class: core.class.TxUpdateDoc,
+      objectClass: core.class.Role
     }
   })
 }
diff --git a/models/server-tags/src/index.ts b/models/server-tags/src/index.ts
index 842b1d05d7..3d55219b8f 100644
--- a/models/server-tags/src/index.ts
+++ b/models/server-tags/src/index.ts
@@ -23,7 +23,11 @@ export { serverTagsId } from '@hcengineering/server-tags'
 
 export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
-    trigger: serverTags.trigger.onTagReference
+    trigger: serverTags.trigger.onTagReference,
+    txMatch: {
+      _class: { $in: [core.class.TxCreateDoc, core.class.TxRemoveDoc] },
+      objectClass: tags.class.TagReference
+    }
   })
 
   builder.mixin<Class<Doc>, ObjectDDParticipant>(
diff --git a/models/server-task/src/index.ts b/models/server-task/src/index.ts
index 80e2227a88..bda31cf670 100644
--- a/models/server-task/src/index.ts
+++ b/models/server-task/src/index.ts
@@ -15,6 +15,7 @@
 
 import core from '@hcengineering/core/src/component'
 import { type Builder } from '@hcengineering/model'
+import task from '@hcengineering/task'
 import serverCore from '@hcengineering/server-core'
 import serverTask from '@hcengineering/server-task'
 
@@ -22,6 +23,9 @@ export { serverTaskId } from '@hcengineering/server-task'
 
 export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
-    trigger: serverTask.trigger.OnStateUpdate
+    trigger: serverTask.trigger.OnStateUpdate,
+    txMatch: {
+      objectClass: task.class.Task
+    }
   })
 }
diff --git a/models/server-telegram/src/index.ts b/models/server-telegram/src/index.ts
index 07b58aa547..7ea53af712 100644
--- a/models/server-telegram/src/index.ts
+++ b/models/server-telegram/src/index.ts
@@ -45,9 +45,8 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverTelegram.trigger.OnMessageCreate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': telegram.class.Message,
-      'tx._class': core.class.TxCreateDoc
+      _class: core.class.TxCreateDoc,
+      objectClass: telegram.class.Message
     }
   })
 
diff --git a/models/server-time/src/index.ts b/models/server-time/src/index.ts
index 152eacf9f0..04298a2009 100644
--- a/models/server-time/src/index.ts
+++ b/models/server-time/src/index.ts
@@ -44,27 +44,24 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverTime.trigger.OnToDoUpdate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': time.class.ToDo,
-      'tx._class': core.class.TxUpdateDoc
+      _class: core.class.TxUpdateDoc,
+      objectClass: time.class.ToDo
     }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverTime.trigger.OnToDoRemove,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': time.class.ToDo,
-      'tx._class': core.class.TxRemoveDoc
+      _class: core.class.TxRemoveDoc,
+      objectClass: time.class.ToDo
     }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverTime.trigger.OnToDoCreate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': time.class.ToDo,
-      'tx._class': core.class.TxCreateDoc
+      _class: core.class.TxCreateDoc,
+      objectClass: time.class.ToDo
     },
     isAsync: true
   })
@@ -72,18 +69,16 @@ export function createModel (builder: Builder): void {
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverTime.trigger.OnWorkSlotCreate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': time.class.WorkSlot,
-      'tx._class': core.class.TxCreateDoc
+      _class: core.class.TxCreateDoc,
+      objectClass: time.class.WorkSlot
     }
   })
 
   builder.createDoc(serverCore.class.Trigger, core.space.Model, {
     trigger: serverTime.trigger.OnWorkSlotUpdate,
     txMatch: {
-      _class: core.class.TxCollectionCUD,
-      'tx.objectClass': time.class.WorkSlot,
-      'tx._class': core.class.TxUpdateDoc
+      _class: core.class.TxUpdateDoc,
+      objectClass: time.class.WorkSlot
     }
   })
 
diff --git a/models/task/src/migration.ts b/models/task/src/migration.ts
index 9d0f50ac8f..47a20ea420 100644
--- a/models/task/src/migration.ts
+++ b/models/task/src/migration.ts
@@ -25,7 +25,6 @@ import {
   type Ref,
   type Space,
   type Status,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxUpdateDoc
 } from '@hcengineering/core'
@@ -447,48 +446,6 @@ export async function migrateDefaultStatusesBase<T extends Task> (
   }
   logger.log('affectedBaseTasks updated: ', counter)
 
-  const baseTaskCreateTxes = await client.find<TxCollectionCUD<T, T>>(DOMAIN_TX, {
-    _class: core.class.TxCollectionCUD,
-    'tx._class': core.class.TxCreateDoc,
-    'tx.objectClass': { $in: baseTaskClasses },
-    'tx.attributes.status': { $in: statusIdsBeingMigrated }
-  })
-
-  logger.log('Base task create TXes: ', baseTaskCreateTxes.length)
-
-  counter = 0
-  for (const baseTaskCreateTx of baseTaskCreateTxes) {
-    const tx = baseTaskCreateTx.tx as TxCreateDoc<T>
-    const newStatus = getNewStatus(tx.attributes.status)
-
-    if (newStatus !== tx.attributes.status) {
-      counter++
-      await client.update(DOMAIN_TX, { _id: baseTaskCreateTx._id }, { $set: { 'tx.attributes.status': newStatus } })
-    }
-  }
-  logger.log('Base task create TXes updated: ', counter)
-
-  const baseTaskUpdateTxes = await client.find<TxCollectionCUD<T, T>>(DOMAIN_TX, {
-    _class: core.class.TxCollectionCUD,
-    'tx._class': core.class.TxUpdateDoc,
-    'tx.objectClass': { $in: baseTaskClasses },
-    'tx.operations.status': { $in: statusIdsBeingMigrated }
-  })
-
-  logger.log('Base task update TXes: ', baseTaskUpdateTxes.length)
-
-  counter = 0
-  for (const baseTaskUpdateTx of baseTaskUpdateTxes) {
-    const tx = baseTaskUpdateTx.tx as TxUpdateDoc<T>
-    const newStatus = tx.operations.status !== undefined ? getNewStatus(tx.operations.status) : undefined
-
-    if (newStatus !== tx.operations.status) {
-      counter++
-      await client.update(DOMAIN_TX, { _id: baseTaskUpdateTx._id }, { $set: { 'tx.operations.status': newStatus } })
-    }
-  }
-  logger.log('Base task update TXes updated: ', counter)
-
   const baseTaskUpdateMessages = await client.find<DocUpdateMessage>(DOMAIN_ACTIVITY, {
     _class: activity.class.DocUpdateMessage,
     action: 'update',
diff --git a/packages/core/src/__tests__/minmodel.ts b/packages/core/src/__tests__/minmodel.ts
index 33f3c04a5f..134fc778fd 100644
--- a/packages/core/src/__tests__/minmodel.ts
+++ b/packages/core/src/__tests__/minmodel.ts
@@ -189,13 +189,6 @@ export function genMinModel (): TxCUD<Doc>[] {
       kind: ClassifierKind.CLASS
     })
   )
-  txes.push(
-    createClass(core.class.TxCollectionCUD, {
-      label: 'TxCollectionCUD' as IntlString,
-      extends: core.class.TxCUD,
-      kind: ClassifierKind.CLASS
-    })
-  )
 
   txes.push(
     createClass(core.class.Blob, {
diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
index 735a0b0ba5..3dfd42b0cd 100644
--- a/packages/core/src/client.ts
+++ b/packages/core/src/client.ts
@@ -15,14 +15,14 @@
 
 import { Analytics } from '@hcengineering/analytics'
 import { BackupClient, DocChunk } from './backup'
-import { Account, AttachedDoc, Class, DOMAIN_MODEL, Doc, Domain, Ref, Timestamp } from './classes'
+import { Account, Class, DOMAIN_MODEL, Doc, Domain, Ref, Timestamp } from './classes'
 import core from './component'
 import { Hierarchy } from './hierarchy'
 import { MeasureContext, MeasureMetricsContext } from './measurements'
 import { ModelDb } from './memdb'
 import type { DocumentQuery, FindOptions, FindResult, FulltextStorage, Storage, TxResult, WithLookup } from './storage'
 import { SearchOptions, SearchQuery, SearchResult, SortingOrder } from './storage'
-import { Tx, TxCUD, TxCollectionCUD } from './tx'
+import { Tx, TxCUD } from './tx'
 import { toFindResult } from './utils'
 
 const transactionThreshold = 500
@@ -307,9 +307,8 @@ export async function createClient (
     // if we have attachment document create/delete we need to full refresh, since some derived data could be missing
     for (const tx of atxes) {
       if (
-        tx._class === core.class.TxCollectionCUD &&
-        ((tx as TxCollectionCUD<Doc, AttachedDoc>).tx._class === core.class.TxCreateDoc ||
-          (tx as TxCollectionCUD<Doc, AttachedDoc>).tx._class === core.class.TxRemoveDoc)
+        (tx as TxCUD<Doc>).attachedTo !== undefined &&
+        (tx._class === core.class.TxCreateDoc || tx._class === core.class.TxRemoveDoc)
       ) {
         needFullRefresh = true
         break
diff --git a/packages/core/src/component.ts b/packages/core/src/component.ts
index baed6b65de..4ed7db7dff 100644
--- a/packages/core/src/component.ts
+++ b/packages/core/src/component.ts
@@ -60,7 +60,6 @@ import type {
   Tx,
   TxApplyIf,
   TxCUD,
-  TxCollectionCUD,
   TxCreateDoc,
   TxMixin,
   TxModelUpgrade,
@@ -97,7 +96,6 @@ export default plugin(coreId, {
     TxApplyIf: '' as Ref<Class<TxApplyIf>>,
     TxCUD: '' as Ref<Class<TxCUD<Doc>>>,
     TxCreateDoc: '' as Ref<Class<TxCreateDoc<Doc>>>,
-    TxCollectionCUD: '' as Ref<Class<TxCollectionCUD<Doc, AttachedDoc>>>,
     TxMixin: '' as Ref<Class<TxMixin<Doc, Doc>>>,
     TxUpdateDoc: '' as Ref<Class<TxUpdateDoc<Doc>>>,
     TxRemoveDoc: '' as Ref<Class<TxRemoveDoc<Doc>>>,
diff --git a/packages/core/src/memdb.ts b/packages/core/src/memdb.ts
index e04b712caa..471e940869 100644
--- a/packages/core/src/memdb.ts
+++ b/packages/core/src/memdb.ts
@@ -15,12 +15,12 @@
 
 import { PlatformError, Severity, Status } from '@hcengineering/platform'
 import { Lookup, MeasureContext, ReverseLookups, getObjectValue } from '.'
-import type { Account, AttachedDoc, Class, Doc, Ref } from './classes'
+import type { Account, Class, Doc, Ref } from './classes'
 import core from './component'
 import { Hierarchy } from './hierarchy'
 import { checkMixinKey, matchQuery, resultSort } from './query'
 import type { DocumentQuery, FindOptions, FindResult, LookupData, Storage, TxResult, WithLookup } from './storage'
-import type { Tx, TxCollectionCUD, TxCreateDoc, TxMixin, TxRemoveDoc, TxUpdateDoc } from './tx'
+import type { Tx, TxCreateDoc, TxMixin, TxRemoveDoc, TxUpdateDoc } from './tx'
 import { TxProcessor } from './tx'
 import { toFindResult } from './utils'
 
@@ -363,25 +363,6 @@ export class ModelDb extends MemDb {
         case core.class.TxCreateDoc:
           this.addDoc(TxProcessor.createDoc2Doc(tx as TxCreateDoc<Doc>, clone))
           break
-        case core.class.TxCollectionCUD: {
-          // We need update only create transactions to contain attached, attachedToClass.
-          const cud = tx as TxCollectionCUD<Doc, AttachedDoc<Doc>>
-          if (cud.tx._class === core.class.TxCreateDoc) {
-            const createTx = cud.tx as TxCreateDoc<AttachedDoc>
-            const d: TxCreateDoc<AttachedDoc> = {
-              ...createTx,
-              attributes: {
-                ...createTx.attributes,
-                attachedTo: cud.objectId,
-                attachedToClass: cud.objectClass,
-                collection: cud.collection
-              }
-            }
-            this.addDoc(TxProcessor.createDoc2Doc(d as TxCreateDoc<Doc>, clone))
-          }
-          this.addTxes(ctx, [cud.tx], clone)
-          break
-        }
         case core.class.TxUpdateDoc: {
           const cud = tx as TxUpdateDoc<Doc>
           const doc = this.findObject(cud.objectId)
diff --git a/packages/core/src/operations.ts b/packages/core/src/operations.ts
index c8d40c1c62..725e87c322 100644
--- a/packages/core/src/operations.ts
+++ b/packages/core/src/operations.ts
@@ -123,7 +123,7 @@ export class TxOperations implements Omit<Client, 'notify'> {
       modifiedBy
     )
     await this.tx(tx)
-    return tx.tx.objectId as unknown as Ref<P>
+    return tx.objectId as unknown as Ref<P>
   }
 
   async updateCollection<T extends Doc, P extends AttachedDoc>(
@@ -148,7 +148,7 @@ export class TxOperations implements Omit<Client, 'notify'> {
       modifiedBy
     )
     await this.tx(tx)
-    return tx.objectId
+    return attachedTo
   }
 
   async removeCollection<T extends Doc, P extends AttachedDoc>(
@@ -171,7 +171,7 @@ export class TxOperations implements Omit<Client, 'notify'> {
       modifiedBy
     )
     await this.tx(tx)
-    return tx.objectId
+    return attachedTo
   }
 
   updateDoc<T extends Doc>(
diff --git a/packages/core/src/tx.ts b/packages/core/src/tx.ts
index 51202c0fa9..13df6a1b16 100644
--- a/packages/core/src/tx.ts
+++ b/packages/core/src/tx.ts
@@ -88,6 +88,9 @@ export interface TxModelUpgrade extends Tx {}
 export interface TxCUD<T extends Doc> extends Tx {
   objectId: Ref<T>
   objectClass: Ref<Class<T>>
+  attachedTo?: Ref<Doc>
+  attachedToClass?: Ref<Class<Doc>>
+  collection?: string
 }
 
 /**
@@ -97,17 +100,6 @@ export interface TxCreateDoc<T extends Doc> extends TxCUD<T> {
   attributes: Data<T>
 }
 
-/**
- *
- * Will perform create/update/delete of attached documents.
- *
- * @public
- */
-export interface TxCollectionCUD<T extends Doc, P extends AttachedDoc> extends TxCUD<T> {
-  collection: string
-  tx: TxCUD<P>
-}
-
 /**
  * @public
  */
@@ -327,9 +319,6 @@ export abstract class TxProcessor implements WithTx {
         case core.class.TxCreateDoc:
           result.push(await this.txCreateDoc(tx as TxCreateDoc<Doc>))
           break
-        case core.class.TxCollectionCUD:
-          result.push(await this.txCollectionCUD(tx as TxCollectionCUD<Doc, AttachedDoc>))
-          break
         case core.class.TxUpdateDoc:
           result.push(await this.txUpdateDoc(tx as TxUpdateDoc<Doc>))
           break
@@ -348,9 +337,19 @@ export abstract class TxProcessor implements WithTx {
   }
 
   static createDoc2Doc<T extends Doc>(tx: TxCreateDoc<T>, doClone = true): T {
+    const attached =
+      tx.attachedTo !== undefined
+        ? {
+            attachedTo: tx.attachedTo,
+            attachedToClass: tx.attachedToClass,
+            collection: tx.collection
+          }
+        : {}
+
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return {
       ...(doClone ? clone(tx.attributes) : tx.attributes),
+      ...attached,
       _id: tx.objectId,
       _class: tx.objectClass,
       space: tx.objectSpace,
@@ -400,22 +399,10 @@ export abstract class TxProcessor implements WithTx {
 
   static buildDoc2Doc<D extends Doc>(txes: Tx[]): D | undefined {
     let doc: Doc
-    let createTx = txes.find((tx) => tx._class === core.class.TxCreateDoc)
-    if (createTx === undefined) {
-      const collectionTxes = txes.filter((tx) => tx._class === core.class.TxCollectionCUD) as Array<
-      TxCollectionCUD<Doc, AttachedDoc>
-      >
-      const collectionCreateTx = collectionTxes.find((p) => p.tx._class === core.class.TxCreateDoc)
-      if (collectionCreateTx === undefined) return
-      createTx = TxProcessor.extractTx(collectionCreateTx)
-    }
+    const createTx = txes.find((tx) => tx._class === core.class.TxCreateDoc)
     if (createTx === undefined) return
-    const objectId = (createTx as TxCreateDoc<D>).objectId
     doc = TxProcessor.createDoc2Doc(createTx as TxCreateDoc<Doc>)
-    for (let tx of txes) {
-      if ((tx as TxCUD<D>).objectId !== objectId && tx._class === core.class.TxCollectionCUD) {
-        tx = TxProcessor.extractTx(tx)
-      }
+    for (const tx of txes) {
       if (tx._class === core.class.TxUpdateDoc) {
         doc = TxProcessor.updateDoc2Doc(doc, tx as TxUpdateDoc<Doc>)
       } else if (tx._class === core.class.TxMixin) {
@@ -431,27 +418,10 @@ export abstract class TxProcessor implements WithTx {
       _class === core.class.TxCreateDoc ||
       _class === core.class.TxUpdateDoc ||
       _class === core.class.TxRemoveDoc ||
-      _class === core.class.TxCollectionCUD ||
       _class === core.class.TxMixin
     )
   }
 
-  static extractTx (tx: Tx): Tx {
-    if (tx._class === core.class.TxCollectionCUD) {
-      const ctx = tx as TxCollectionCUD<Doc, AttachedDoc>
-      if (ctx.tx._class === core.class.TxCreateDoc) {
-        const create = ctx.tx as TxCreateDoc<AttachedDoc>
-        create.attributes.attachedTo = ctx.objectId
-        create.attributes.attachedToClass = ctx.objectClass
-        create.attributes.collection = ctx.collection
-        return create
-      }
-      return ctx.tx
-    }
-
-    return tx
-  }
-
   static txHasUpdate<T extends Doc>(tx: TxUpdateDoc<T>, attribute: string): boolean {
     const ops = tx.operations
     if ((ops as any)[attribute] !== undefined) return true
@@ -472,24 +442,6 @@ export abstract class TxProcessor implements WithTx {
   protected abstract txUpdateDoc (tx: TxUpdateDoc<Doc>): Promise<TxResult>
   protected abstract txRemoveDoc (tx: TxRemoveDoc<Doc>): Promise<TxResult>
   protected abstract txMixin (tx: TxMixin<Doc, Doc>): Promise<TxResult>
-
-  protected txCollectionCUD (tx: TxCollectionCUD<Doc, AttachedDoc>): Promise<TxResult> {
-    // We need update only create transactions to contain attached, attachedToClass.
-    if (tx.tx._class === core.class.TxCreateDoc) {
-      const createTx = tx.tx as TxCreateDoc<AttachedDoc>
-      const d: TxCreateDoc<AttachedDoc> = {
-        ...createTx,
-        attributes: {
-          ...createTx.attributes,
-          attachedTo: tx.objectId,
-          attachedToClass: tx.objectClass,
-          collection: tx.collection
-        }
-      }
-      return this.txCreateDoc(d)
-    }
-    return this.tx(tx.tx)
-  }
 }
 
 /**
@@ -534,18 +486,14 @@ export class TxFactory {
     tx: TxCUD<P>,
     modifiedOn?: Timestamp,
     modifiedBy?: Ref<Account>
-  ): TxCollectionCUD<T, P> {
+  ): TxCUD<P> {
     return {
-      _id: generateId(),
-      _class: core.class.TxCollectionCUD,
-      space: this.txSpace,
-      objectId,
-      objectClass: _class,
-      objectSpace: space,
-      modifiedOn: modifiedOn ?? Date.now(),
-      modifiedBy: modifiedBy ?? this.account,
+      ...tx,
       collection,
-      tx
+      attachedTo: objectId,
+      attachedToClass: _class,
+      modifiedOn: modifiedOn ?? Date.now(),
+      modifiedBy: modifiedBy ?? this.account
     }
   }
 
diff --git a/packages/presentation/src/utils.ts b/packages/presentation/src/utils.ts
index 005e2e6883..eb86633c8e 100644
--- a/packages/presentation/src/utils.ts
+++ b/packages/presentation/src/utils.ts
@@ -119,7 +119,7 @@ class UIClient extends TxOperations implements Client, OptimisticTxes {
         this.pendingTxes.delete(t._id)
 
         // Only CUD tx can be pending now
-        const innerTx = TxProcessor.extractTx(t) as TxCUD<Doc>
+        const innerTx = t as TxCUD<Doc>
 
         if (innerTx._class === core.class.TxCreateDoc) {
           // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
@@ -206,7 +206,7 @@ class UIClient extends TxOperations implements Client, OptimisticTxes {
       return
     }
 
-    const innerTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
+    const innerTx = tx as TxCUD<Doc>
     // Can pre-build some configuration later from the model if this will be too slow.
     const instantTxes = this.getHierarchy().classHierarchyMixin(innerTx.objectClass, plugin.mixin.InstantTransactions)
     if (instantTxes?.txClasses.includes(innerTx._class) !== true) {
diff --git a/packages/query/src/__tests__/minmodel.ts b/packages/query/src/__tests__/minmodel.ts
index b03547ebd0..fffb687a68 100644
--- a/packages/query/src/__tests__/minmodel.ts
+++ b/packages/query/src/__tests__/minmodel.ts
@@ -188,13 +188,6 @@ export function genMinModel (): TxCUD<Doc>[] {
       kind: ClassifierKind.CLASS
     })
   )
-  txes.push(
-    createClass(core.class.TxCollectionCUD, {
-      label: 'TxCollectionCUD' as IntlString,
-      extends: core.class.TxCUD,
-      kind: ClassifierKind.CLASS
-    })
-  )
   txes.push(
     createClass(core.class.TxMixin, {
       label: 'TxMixin' as IntlString,
diff --git a/packages/query/src/__tests__/query.test.ts b/packages/query/src/__tests__/query.test.ts
index 89a05facfb..f8bd46df54 100644
--- a/packages/query/src/__tests__/query.test.ts
+++ b/packages/query/src/__tests__/query.test.ts
@@ -677,24 +677,33 @@ describe('query', () => {
         )
       )
     }
-    const pp = new Promise((resolve) => {
-      liveQuery.query<AttachedComment>(
-        test.class.TestComment,
-        { _id: parentComment },
-        (result) => {
-          attempt++
-          const comment = result[0]
-          if (comment !== undefined) {
-            expect((comment.$lookup as any)?.comments).toHaveLength(childLength - attempt)
-          }
-          if (attempt === childLength) {
-            resolve(null)
-          }
-        },
-        { lookup: { _id: { comments: test.class.TestComment } } }
-      )
+
+    let secondPromise: Promise<void> | undefined
+    const firstCallback = new Promise<void>((resolve) => {
+      secondPromise = new Promise<void>((_resolve) => {
+        liveQuery.query<AttachedComment>(
+          test.class.TestComment,
+          { _id: parentComment },
+          (result) => {
+            attempt++
+            if (attempt === 0) {
+              resolve()
+            }
+            const comment = result[0]
+            if (comment !== undefined) {
+              expect((comment.$lookup as any)?.comments).toHaveLength(childLength - attempt)
+            }
+            if (attempt === childLength) {
+              _resolve()
+            }
+          },
+          { lookup: { _id: { comments: test.class.TestComment } } }
+        )
+      })
     })
 
+    await firstCallback
+
     for (const child of childs) {
       await factory.removeCollection(
         test.class.TestComment,
@@ -705,7 +714,7 @@ describe('query', () => {
         'comments'
       )
     }
-    await pp
+    await secondPromise
   })
 
   it('lookup query update doc', async () => {
diff --git a/packages/query/src/index.ts b/packages/query/src/index.ts
index 33ce6edd2d..c88bfe84c5 100644
--- a/packages/query/src/index.ts
+++ b/packages/query/src/index.ts
@@ -15,7 +15,6 @@
 
 import { Analytics } from '@hcengineering/analytics'
 import core, {
-  AttachedDoc,
   BulkUpdateEvent,
   Class,
   Client,
@@ -38,7 +37,6 @@ import core, {
   Space,
   Timestamp,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxMixin,
   TxProcessor,
@@ -672,41 +670,6 @@ export class LiveQuery implements WithTx, Client {
     return {}
   }
 
-  protected async txCollectionCUD (
-    tx: TxCollectionCUD<Doc, AttachedDoc>,
-    docCache: Map<string, Doc>
-  ): Promise<TxResult> {
-    for (const queries of this.queries) {
-      const isTx = this.client.getHierarchy().isDerived(queries[0], core.class.Tx)
-      for (const q of queries[1]) {
-        if (isTx) {
-          // handle add since Txes are immutable
-          await this.handleDocAdd(q, tx, true, docCache)
-          continue
-        }
-
-        if (tx.tx._class === core.class.TxCreateDoc) {
-          const createTx = tx.tx as TxCreateDoc<AttachedDoc>
-          const d: TxCreateDoc<AttachedDoc> = {
-            ...createTx,
-            attributes: {
-              ...createTx.attributes,
-              attachedTo: tx.objectId,
-              attachedToClass: tx.objectClass,
-              collection: tx.collection
-            }
-          }
-          await this.handleDocAdd(q, TxProcessor.createDoc2Doc(d), true, docCache)
-        } else if (tx.tx._class === core.class.TxUpdateDoc) {
-          await this.handleDocUpdate(q, tx.tx as unknown as TxUpdateDoc<Doc>, docCache)
-        } else if (tx.tx._class === core.class.TxRemoveDoc) {
-          await this.handleDocRemove(q, tx.tx as unknown as TxRemoveDoc<Doc>)
-        }
-      }
-    }
-    return {}
-  }
-
   async txUpdateDoc (tx: TxUpdateDoc<Doc>, docCache: Map<string, Doc>): Promise<TxResult> {
     for (const queries of this.queries) {
       const isTx = this.client.getHierarchy().isDerived(queries[0], core.class.Tx)
@@ -1278,8 +1241,6 @@ export class LiveQuery implements WithTx, Client {
     switch (tx._class) {
       case core.class.TxCreateDoc:
         return await this.txCreateDoc(tx as TxCreateDoc<Doc>, docCache)
-      case core.class.TxCollectionCUD:
-        return await this.txCollectionCUD(tx as TxCollectionCUD<Doc, AttachedDoc>, docCache)
       case core.class.TxUpdateDoc:
         return await this.txUpdateDoc(tx as TxUpdateDoc<Doc>, docCache)
       case core.class.TxRemoveDoc:
diff --git a/plugins/board-resources/src/components/editor/CardActions.svelte b/plugins/board-resources/src/components/editor/CardActions.svelte
index 4031cd767c..03d8e7c15d 100644
--- a/plugins/board-resources/src/components/editor/CardActions.svelte
+++ b/plugins/board-resources/src/components/editor/CardActions.svelte
@@ -39,7 +39,7 @@
         }
       } else {
         let targetState: Status | undefined = undefined
-        const txes = await client.findAll(core.class.Tx, { 'tx.objectId': value._id })
+        const txes = await client.findAll(core.class.Tx, { objectId: value._id })
         while (txes.length) {
           const doc = TxProcessor.buildDoc2Doc<Card>(txes)
           if (doc === undefined) {
diff --git a/plugins/chunter-resources/src/components/ReverseChannelScrollView.svelte b/plugins/chunter-resources/src/components/ReverseChannelScrollView.svelte
index 27ab50660a..9863ceee4d 100644
--- a/plugins/chunter-resources/src/components/ReverseChannelScrollView.svelte
+++ b/plugins/chunter-resources/src/components/ReverseChannelScrollView.svelte
@@ -21,7 +21,7 @@
     Space,
     Timestamp,
     Tx,
-    TxCollectionCUD,
+    TxCUD,
     TxProcessor
   } from '@hcengineering/core'
   import activity, { ActivityMessage } from '@hcengineering/activity'
@@ -546,11 +546,9 @@
   }
 
   const newMessageTxListener = (tx: Tx): void => {
-    if (tx._class !== core.class.TxCollectionCUD) return
-    const ctx = tx as TxCollectionCUD<Doc, ActivityMessage>
-    if (ctx.objectId !== doc._id) return
-    const etx = TxProcessor.extractTx(tx)
-    if (etx._class !== core.class.TxCreateDoc) return
+    const ctx = tx as TxCUD<ActivityMessage>
+    if (ctx.attachedTo !== doc._id) return
+    if (ctx._class !== core.class.TxCreateDoc) return
     if (shouldScrollToNew) {
       void wait().then(scrollToNewMessages)
     }
diff --git a/plugins/task-resources/src/components/Dashboard.svelte b/plugins/task-resources/src/components/Dashboard.svelte
index c81982ca07..3376dde2b9 100644
--- a/plugins/task-resources/src/components/Dashboard.svelte
+++ b/plugins/task-resources/src/components/Dashboard.svelte
@@ -49,15 +49,14 @@
       return
     }
     txQuery.query(
-      core.class.TxCollectionCUD,
+      core.class.TxCreateDoc,
       {
         objectSpace: space,
-        'tx._class': core.class.TxCreateDoc,
-        'tx.objectClass': _class,
+        objectClass: _class,
         modifiedOn: { $gte: modified }
       },
       (result) => {
-        ids = result.map((p) => p.tx.objectId) as Ref<Task>[]
+        ids = result.map((p) => p.objectId) as Ref<Task>[]
       }
     )
   }
diff --git a/plugins/test-management-resources/src/utils.ts b/plugins/test-management-resources/src/utils.ts
index 63fa18bb32..823692ebf8 100644
--- a/plugins/test-management-resources/src/utils.ts
+++ b/plugins/test-management-resources/src/utils.ts
@@ -14,7 +14,7 @@
 //
 
 import { type Contact } from '@hcengineering/contact'
-import core, { type Doc, type Ref, type TxCollectionCUD, type TxCreateDoc, type TxUpdateDoc } from '@hcengineering/core'
+import core, { type Doc, type Ref, type TxCreateDoc, type TxUpdateDoc } from '@hcengineering/core'
 import { getClient } from '@hcengineering/presentation'
 import { showPopup } from '@hcengineering/ui'
 import { type TestProject, type TestCase, type TestSuite } from '@hcengineering/test-management'
@@ -30,20 +30,19 @@ export async function getPreviousAssignees (objectId: Ref<Doc> | undefined): Pro
   }
   const client = getClient()
   const createTx = (
-    await client.findAll<TxCollectionCUD<TestCase, TestCase>>(core.class.TxCollectionCUD, {
-      'tx.objectId': objectId,
-      'tx._class': core.class.TxCreateDoc
+    await client.findAll<TxCreateDoc<TestCase>>(core.class.TxCreateDoc, {
+      objectId: objectId as Ref<TestCase>
     })
   )[0]
-  const updateTxes = await client.findAll<TxCollectionCUD<TestCase, TestCase>>(
-    core.class.TxCollectionCUD,
-    { 'tx.objectId': objectId, 'tx._class': core.class.TxUpdateDoc, 'tx.operations.assignee': { $exists: true } },
+  const updateTxes = await client.findAll<TxUpdateDoc<TestCase>>(
+    core.class.TxUpdateDoc,
+    { objectId: objectId as Ref<TestCase>, 'operations.assignee': { $exists: true } },
     { sort: { modifiedOn: -1 } }
   )
   const set = new Set<Ref<Contact>>()
-  const createAssignee = (createTx?.tx as TxCreateDoc<TestCase>)?.attributes?.assignee
+  const createAssignee = createTx?.attributes?.assignee
   for (const tx of updateTxes) {
-    const assignee = (tx.tx as TxUpdateDoc<TestCase>).operations.assignee
+    const assignee = tx.operations.assignee
     if (assignee == null) continue
     set.add(assignee)
   }
diff --git a/plugins/time-resources/src/components/team/calendar/TeamCalendar.svelte b/plugins/time-resources/src/components/team/calendar/TeamCalendar.svelte
index f69a80c0c3..95b2c9e4f5 100644
--- a/plugins/time-resources/src/components/team/calendar/TeamCalendar.svelte
+++ b/plugins/time-resources/src/components/team/calendar/TeamCalendar.svelte
@@ -25,7 +25,6 @@
     Tx,
     TxCUD,
     TxCreateDoc,
-    TxProcessor,
     TxUpdateDoc,
     getCurrentAccount
   } from '@hcengineering/core'
@@ -66,8 +65,7 @@
     { modifiedBy: { $in: Array.from(personAccounts.map((it) => it._id)) }, modifiedOn: { $gt: fromDate, $lt: toDate } },
     (res) => {
       const map = new Map<Ref<Account>, Tx[]>()
-      for (const _t of res) {
-        const t = TxProcessor.extractTx(_t)
+      for (const t of res) {
         const account = t.createdBy ?? t.modifiedBy
         map.set(account, [...(map.get(account) ?? []), t])
       }
diff --git a/plugins/tracker-resources/src/components/issues/AssigneeEditor.svelte b/plugins/tracker-resources/src/components/issues/AssigneeEditor.svelte
index f7453f3a8e..7717b7370a 100644
--- a/plugins/tracker-resources/src/components/issues/AssigneeEditor.svelte
+++ b/plugins/tracker-resources/src/components/issues/AssigneeEditor.svelte
@@ -92,7 +92,7 @@
         func: async () => {
           const r: Ref<Person>[] = []
           for (const d of cdocs) {
-            r.push(...(await getPreviousAssignees(d._id)))
+            r.push(...(await getPreviousAssignees(d._id as Ref<Issue>)))
           }
           return r
         }
diff --git a/plugins/tracker-resources/src/components/issues/IssueStatusActivity.svelte b/plugins/tracker-resources/src/components/issues/IssueStatusActivity.svelte
index 92422b6ad3..a46f33d618 100644
--- a/plugins/tracker-resources/src/components/issues/IssueStatusActivity.svelte
+++ b/plugins/tracker-resources/src/components/issues/IssueStatusActivity.svelte
@@ -1,14 +1,5 @@
 <script lang="ts">
-  import core, {
-    IdMap,
-    Ref,
-    Timestamp,
-    Tx,
-    TxCollectionCUD,
-    TxCreateDoc,
-    TxUpdateDoc,
-    WithLookup
-  } from '@hcengineering/core'
+  import core, { IdMap, Ref, Timestamp, Tx, TxCreateDoc, TxUpdateDoc, WithLookup } from '@hcengineering/core'
   import { createQuery } from '@hcengineering/presentation'
   import { Issue, IssueStatus } from '@hcengineering/tracker'
   import { Label, Row, ticker } from '@hcengineering/ui'
@@ -31,7 +22,7 @@
 
   $: query.query(
     core.class.Tx,
-    { 'tx.objectId': issue._id },
+    { objectId: issue._id },
     (res) => {
       txes = res
     },
@@ -44,10 +35,7 @@
 
     let current: Ref<IssueStatus> | undefined
     let last: Timestamp = Date.now()
-    for (let it of txes) {
-      if (it._class === core.class.TxCollectionCUD) {
-        it = (it as TxCollectionCUD<Issue, Issue>).tx
-      }
+    for (const it of txes) {
       let newStatus: Ref<IssueStatus> | undefined
       if (it._class === core.class.TxCreateDoc) {
         const op = it as TxCreateDoc<Issue>
diff --git a/plugins/tracker-resources/src/utils.ts b/plugins/tracker-resources/src/utils.ts
index 11d63200f7..1d3e380332 100644
--- a/plugins/tracker-resources/src/utils.ts
+++ b/plugins/tracker-resources/src/utils.ts
@@ -30,7 +30,6 @@ import core, {
   type Space,
   type Status,
   type StatusCategory,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxOperations,
   type TxResult,
@@ -340,26 +339,25 @@ export function subIssueListProvider (subIssues: Issue[], target: Ref<Issue>): v
   }
 }
 
-export async function getPreviousAssignees (objectId: Ref<Doc> | undefined): Promise<Array<Ref<Contact>>> {
+export async function getPreviousAssignees (objectId: Ref<Issue> | undefined): Promise<Array<Ref<Contact>>> {
   if (objectId === undefined) {
     return []
   }
   const client = getClient()
   const createTx = (
-    await client.findAll<TxCollectionCUD<Issue, Issue>>(core.class.TxCollectionCUD, {
-      'tx.objectId': objectId,
-      'tx._class': core.class.TxCreateDoc
+    await client.findAll<TxCreateDoc<Issue>>(core.class.TxCreateDoc, {
+      objectId
     })
   )[0]
-  const updateTxes = await client.findAll<TxCollectionCUD<Issue, Issue>>(
-    core.class.TxCollectionCUD,
-    { 'tx.objectId': objectId, 'tx._class': core.class.TxUpdateDoc, 'tx.operations.assignee': { $exists: true } },
+  const updateTxes = await client.findAll<TxUpdateDoc<Issue>>(
+    core.class.TxUpdateDoc,
+    { objectId, 'operations.assignee': { $exists: true } },
     { sort: { modifiedOn: -1 } }
   )
   const set = new Set<Ref<Contact>>()
-  const createAssignee = (createTx?.tx as TxCreateDoc<Issue>)?.attributes?.assignee
+  const createAssignee = createTx?.attributes?.assignee
   for (const tx of updateTxes) {
-    const assignee = (tx.tx as TxUpdateDoc<Issue>).operations.assignee
+    const assignee = tx.operations.assignee
     if (assignee == null) continue
     set.add(assignee)
   }
diff --git a/plugins/view-resources/src/middleware.ts b/plugins/view-resources/src/middleware.ts
index 8825bce73d..d4321c7e7a 100644
--- a/plugins/view-resources/src/middleware.ts
+++ b/plugins/view-resources/src/middleware.ts
@@ -300,8 +300,7 @@ export class AnalyticsMiddleware extends BasePresentationMiddleware implements P
   }
 
   private async handleTx (...txes: Tx[]): Promise<void> {
-    for (const tx of txes) {
-      const etx = TxProcessor.extractTx(tx)
+    for (const etx of txes) {
       if (etx._class === core.class.TxApplyIf) {
         const applyIf = etx as TxApplyIf
         void this.handleTx(...applyIf.txes)
diff --git a/plugins/view-resources/src/utils.ts b/plugins/view-resources/src/utils.ts
index 4bd6805852..8bf9723798 100644
--- a/plugins/view-resources/src/utils.ts
+++ b/plugins/view-resources/src/utils.ts
@@ -47,7 +47,6 @@ import core, {
   type Space,
   type Tx,
   type TxCUD,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxMixin,
   type TxOperations,
@@ -1319,25 +1318,19 @@ export async function buildRemovedDoc<T extends Doc> (
   objectId: Ref<T>,
   _class: Ref<Class<T>>
 ): Promise<T | undefined> {
-  const isAttached = client.getHierarchy().isDerived(_class, core.class.AttachedDoc)
   const txes = await client.findAll<TxCUD<Doc>>(
-    isAttached ? core.class.TxCollectionCUD : core.class.TxCUD,
-    isAttached
-      ? { 'tx.objectId': objectId }
-      : {
-          objectId
-        },
+    core.class.TxCUD,
+    {
+      objectId
+    },
     { sort: { modifiedOn: 1 } }
   )
-  const createTx = isAttached
-    ? txes.map((tx) => (tx as TxCollectionCUD<Doc, AttachedDoc>).tx).find((tx) => tx._class === core.class.TxCreateDoc)
-    : txes.find((tx) => tx._class === core.class.TxCreateDoc)
+  const createTx = txes.find((tx) => tx._class === core.class.TxCreateDoc)
 
   if (createTx === undefined) return
   let doc = TxProcessor.createDoc2Doc(createTx as TxCreateDoc<Doc>)
 
-  for (let tx of txes) {
-    tx = TxProcessor.extractTx(tx) as TxCUD<Doc>
+  for (const tx of txes) {
     if (tx._class === core.class.TxUpdateDoc) {
       doc = TxProcessor.updateDoc2Doc(doc, tx as TxUpdateDoc<Doc>)
     } else if (tx._class === core.class.TxMixin) {
diff --git a/server-plugins/activity-resources/src/index.ts b/server-plugins/activity-resources/src/index.ts
index b53524d044..e8c622a2b6 100644
--- a/server-plugins/activity-resources/src/index.ts
+++ b/server-plugins/activity-resources/src/index.ts
@@ -34,7 +34,6 @@ import core, {
   Ref,
   Space,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxProcessor
@@ -54,19 +53,18 @@ import { ReferenceTrigger } from './references'
 import { getAttrName, getCollectionAttribute, getDocUpdateAction, getTxAttributesUpdates } from './utils'
 
 export async function OnReactionChanged (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
-  for (const originTx of txes) {
-    const tx = originTx as TxCollectionCUD<ActivityMessage, Reaction>
-    const innerTx = TxProcessor.extractTx(tx) as TxCUD<Reaction>
+  for (const tx of txes) {
+    const innerTx = tx as TxCUD<Reaction>
 
     if (innerTx._class === core.class.TxCreateDoc) {
-      const txes = await createReactionNotifications(tx, control)
+      const txes = await createReactionNotifications(innerTx, control)
 
       await control.apply(control.ctx, txes)
       continue
     }
 
     if (innerTx._class === core.class.TxRemoveDoc) {
-      const txes = await removeReactionNotifications(tx, control)
+      const txes = await removeReactionNotifications(innerTx, control)
       await control.apply(control.ctx, txes)
       continue
     }
@@ -75,15 +73,13 @@ export async function OnReactionChanged (txes: Tx[], control: TriggerControl): P
   return []
 }
 
-export async function removeReactionNotifications (
-  tx: TxCollectionCUD<ActivityMessage, Reaction>,
-  control: TriggerControl
-): Promise<Tx[]> {
+export async function removeReactionNotifications (tx: TxCUD<Reaction>, control: TriggerControl): Promise<Tx[]> {
+  if (tx.attachedTo === undefined) return []
   const message = (
     await control.findAll(
       control.ctx,
       activity.class.ActivityMessage,
-      { objectId: tx.tx.objectId },
+      { objectId: tx.objectId },
       { projection: { _id: 1, _class: 1, space: 1 } }
     )
   )[0]
@@ -103,13 +99,11 @@ export async function removeReactionNotifications (
   return res
 }
 
-export async function createReactionNotifications (
-  tx: TxCollectionCUD<ActivityMessage, Reaction>,
-  control: TriggerControl
-): Promise<Tx[]> {
-  const createTx = TxProcessor.extractTx(tx) as TxCreateDoc<Reaction>
-
-  const parentMessage = (await control.findAll(control.ctx, activity.class.ActivityMessage, { _id: tx.objectId }))[0]
+export async function createReactionNotifications (tx: TxCUD<Reaction>, control: TriggerControl): Promise<Tx[]> {
+  if (tx.attachedTo === undefined) return []
+  const parentMessage = (
+    await control.findAll(control.ctx, activity.class.ActivityMessage, { _id: tx.attachedTo as Ref<ActivityMessage> })
+  )[0]
 
   if (parentMessage === undefined) {
     return []
@@ -127,8 +121,8 @@ export async function createReactionNotifications (
     txId: tx._id,
     attachedTo: parentMessage._id,
     attachedToClass: parentMessage._class,
-    objectId: createTx.objectId,
-    objectClass: createTx.objectClass,
+    objectId: tx.objectId,
+    objectClass: tx.objectClass,
     action: 'create',
     collection: 'docUpdateMessages',
     updateCollection: tx.collection
@@ -142,14 +136,13 @@ export async function createReactionNotifications (
 
   res.push(messageTx)
 
-  const docUpdateMessage = TxProcessor.createDoc2Doc(messageTx.tx as TxCreateDoc<DocUpdateMessage>)
+  const docUpdateMessage = TxProcessor.createDoc2Doc(messageTx as TxCreateDoc<DocUpdateMessage>)
 
   res = res.concat(
     await createCollabDocInfo(
       control.ctx,
       [user] as Ref<PersonAccount>[],
       control,
-      tx.tx,
       tx,
       parentMessage,
       [docUpdateMessage],
@@ -176,7 +169,7 @@ function getDocUpdateMessageTx (
   object: Doc,
   rawMessage: Data<DocUpdateMessage>,
   modifiedBy?: Ref<Account>
-): TxCollectionCUD<Doc, DocUpdateMessage> {
+): TxCUD<DocUpdateMessage> {
   const { hierarchy } = control
   const space = isSpace(object, hierarchy) ? object._id : object.space
   const innerTx = control.txFactory.createTxCreateDoc(
@@ -202,13 +195,13 @@ function getDocUpdateMessageTx (
 export async function pushDocUpdateMessages (
   ctx: MeasureContext,
   control: ActivityControl,
-  res: TxCollectionCUD<Doc, DocUpdateMessage>[],
+  res: TxCUD<DocUpdateMessage>[],
   object: Doc | undefined,
   originTx: TxCUD<Doc>,
   modifiedBy?: Ref<Account>,
   objectCache?: DocObjectCache,
   controlRules?: ActivityMessageControl[]
-): Promise<TxCollectionCUD<Doc, DocUpdateMessage>[]> {
+): Promise<TxCUD<DocUpdateMessage>[]> {
   if (object === undefined) {
     return res
   }
@@ -217,24 +210,18 @@ export async function pushDocUpdateMessages (
     return res
   }
 
-  const tx =
-    originTx._class === core.class.TxCollectionCUD ? (originTx as TxCollectionCUD<Doc, AttachedDoc>).tx : originTx
-
   const rawMessage: Data<DocUpdateMessage> = {
     txId: originTx._id,
     attachedTo: object._id,
     attachedToClass: object._class,
-    objectId: tx.objectId,
-    objectClass: tx.objectClass,
-    action: getDocUpdateAction(control, tx),
+    objectId: originTx.objectId,
+    objectClass: originTx.objectClass,
+    action: getDocUpdateAction(control, originTx),
     collection: 'docUpdateMessages',
-    updateCollection:
-      originTx._class === core.class.TxCollectionCUD
-        ? (originTx as TxCollectionCUD<Doc, AttachedDoc>).collection
-        : undefined
+    updateCollection: originTx.collection
   }
 
-  const attributesUpdates = await getTxAttributesUpdates(ctx, control, originTx, tx, object, objectCache, controlRules)
+  const attributesUpdates = await getTxAttributesUpdates(ctx, control, originTx, object, objectCache, controlRules)
 
   for (const attributeUpdates of attributesUpdates) {
     res.push(
@@ -262,27 +249,26 @@ export async function generateDocUpdateMessages (
   ctx: MeasureContext,
   tx: TxCUD<Doc>,
   control: ActivityControl,
-  res: TxCollectionCUD<Doc, DocUpdateMessage>[] = [],
-  originTx?: TxCUD<Doc>,
-  objectCache?: DocObjectCache
-): Promise<TxCollectionCUD<Doc, DocUpdateMessage>[]> {
+  res: TxCUD<DocUpdateMessage>[] = [],
+  objectCache?: DocObjectCache,
+  skipAttached: boolean = false
+): Promise<TxCUD<DocUpdateMessage>[]> {
   if (tx.space === core.space.DerivedTx) {
     return res
   }
 
   const { hierarchy } = control
-  const etx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-
   if (
     hierarchy.isDerived(tx.objectClass, activity.class.ActivityMessage) ||
-    hierarchy.isDerived(etx.objectClass, activity.class.ActivityMessage)
+    (tx.attachedToClass !== undefined && hierarchy.isDerived(tx.attachedToClass, activity.class.ActivityMessage))
   ) {
     return res
   }
 
   if (
     hierarchy.classHierarchyMixin(tx.objectClass, activity.mixin.IgnoreActivity) !== undefined ||
-    hierarchy.classHierarchyMixin(etx.objectClass, activity.mixin.IgnoreActivity) !== undefined
+    (tx.attachedToClass !== undefined &&
+      hierarchy.classHierarchyMixin(tx.attachedToClass, activity.mixin.IgnoreActivity) !== undefined)
   ) {
     return res
   }
@@ -294,8 +280,7 @@ export async function generateDocUpdateMessages (
   if (controlRules.length > 0) {
     for (const r of controlRules) {
       for (const s of r.skip) {
-        const otx = originTx ?? etx
-        if (matchQuery(otx !== undefined ? [tx, otx] : [tx], s, r.objectClass, hierarchy).length > 0) {
+        if (matchQuery([tx], s, r.objectClass, hierarchy).length > 0) {
           // Match found, we need to skip
           return res
         }
@@ -303,68 +288,58 @@ export async function generateDocUpdateMessages (
     }
   }
 
+  if (tx.attachedTo !== undefined && tx.attachedToClass !== undefined && !skipAttached) {
+    res = await generateDocUpdateMessages(ctx, tx, control, res, objectCache, true)
+    if ([core.class.TxCreateDoc, core.class.TxRemoveDoc].includes(tx._class)) {
+      if (!isActivityDoc(tx.attachedToClass, control.hierarchy)) {
+        return res
+      }
+
+      let doc = objectCache?.docs?.get(tx.attachedTo)
+      if (doc === undefined) {
+        doc = (await control.findAll(ctx, tx.attachedToClass, { _id: tx.attachedTo }, { limit: 1 }))[0]
+      }
+      if (doc === undefined) {
+        const createTx = (
+          await control.findAll(ctx, core.class.TxCreateDoc, { objectId: tx.attachedTo }, { limit: 1 })
+        )[0]
+
+        doc = createTx !== undefined ? TxProcessor.createDoc2Doc(createTx as TxCreateDoc<Doc>) : undefined
+      }
+      if (doc !== undefined) {
+        objectCache?.docs?.set(tx.attachedTo, doc)
+        return await ctx.with(
+          'pushDocUpdateMessages',
+          {},
+          async (ctx) =>
+            await pushDocUpdateMessages(ctx, control, res, doc ?? undefined, tx, undefined, objectCache, controlRules)
+        )
+      }
+    }
+  }
+
   switch (tx._class) {
     case core.class.TxCreateDoc: {
       const doc = TxProcessor.createDoc2Doc(tx as TxCreateDoc<Doc>)
       return await ctx.with('pushDocUpdateMessages', {}, (ctx) =>
-        pushDocUpdateMessages(ctx, control, res, doc, originTx ?? tx, undefined, objectCache, controlRules)
+        pushDocUpdateMessages(ctx, control, res, doc, tx, undefined, objectCache, controlRules)
       )
     }
     case core.class.TxMixin:
     case core.class.TxUpdateDoc: {
-      if (!isActivityDoc(tx.objectClass, control.hierarchy)) {
-        return res
-      }
-
-      let doc = objectCache?.docs?.get(tx.objectId)
-      if (doc === undefined) {
-        doc = (await control.findAll(ctx, tx.objectClass, { _id: tx.objectId }, { limit: 1 }))[0]
-        objectCache?.docs?.set(tx.objectId, doc)
-      }
-      return await ctx.with('pushDocUpdateMessages', {}, (ctx) =>
-        pushDocUpdateMessages(ctx, control, res, doc ?? undefined, originTx ?? tx, undefined, objectCache, controlRules)
-      )
-    }
-    case core.class.TxCollectionCUD: {
-      const actualTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-      res = await generateDocUpdateMessages(ctx, actualTx, control, res, tx, objectCache)
-      if ([core.class.TxCreateDoc, core.class.TxRemoveDoc].includes(actualTx._class)) {
-        if (!isActivityDoc(tx.objectClass, control.hierarchy)) {
-          return res
-        }
-
+      if (isActivityDoc(tx.objectClass, control.hierarchy)) {
         let doc = objectCache?.docs?.get(tx.objectId)
         if (doc === undefined) {
           doc = (await control.findAll(ctx, tx.objectClass, { _id: tx.objectId }, { limit: 1 }))[0]
-        }
-        if (doc === undefined) {
-          const isAttachedDoc = hierarchy.isDerived(tx.objectClass, core.class.AttachedDoc)
-          const createTx = isAttachedDoc
-            ? (await control.findAll(ctx, core.class.TxCollectionCUD, { 'tx.objectId': tx.objectId }, { limit: 1 }))[0]
-            : (await control.findAll(ctx, core.class.TxCreateDoc, { objectId: tx.objectId }, { limit: 1 }))[0]
-
-          doc =
-            createTx !== undefined
-              ? TxProcessor.createDoc2Doc(TxProcessor.extractTx(createTx) as TxCreateDoc<Doc>)
-              : undefined
-        }
-        if (doc !== undefined) {
           objectCache?.docs?.set(tx.objectId, doc)
-          return await ctx.with('pushDocUpdateMessages', {}, (ctx) =>
-            pushDocUpdateMessages(
-              ctx,
-              control,
-              res,
-              doc ?? undefined,
-              originTx ?? tx,
-              undefined,
-              objectCache,
-              controlRules
-            )
-          )
         }
+        return await ctx.with(
+          'pushDocUpdateMessages',
+          {},
+          async (ctx) =>
+            await pushDocUpdateMessages(ctx, control, res, doc ?? undefined, tx, undefined, objectCache, controlRules)
+        )
       }
-      return res
     }
   }
 
@@ -393,10 +368,10 @@ async function ActivityMessagesHandler (_txes: TxCUD<Doc>[], control: TriggerCon
       tx.space === core.space.DerivedTx
         ? []
         : await control.ctx.with('generateDocUpdateMessages', {}, (ctx) =>
-          generateDocUpdateMessages(ctx, tx, control, [], undefined, cache)
+          generateDocUpdateMessages(ctx, tx, control, [], cache)
         )
 
-    const messages = txes.map((messageTx) => TxProcessor.createDoc2Doc(messageTx.tx as TxCreateDoc<DocUpdateMessage>))
+    const messages = txes.map((messageTx) => TxProcessor.createDoc2Doc(messageTx as TxCreateDoc<DocUpdateMessage>))
 
     const notificationTxes = await control.ctx.with('createCollaboratorNotifications', {}, (ctx) =>
       createCollaboratorNotifications(ctx, tx, control, messages, undefined, cache.docs as Map<Ref<Doc>, Doc>)
@@ -412,9 +387,7 @@ async function ActivityMessagesHandler (_txes: TxCUD<Doc>[], control: TriggerCon
 
 async function OnDocRemoved (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
-  for (const originTx of txes) {
-    const tx = TxProcessor.extractTx(originTx) as TxCUD<Doc>
-
+  for (const tx of txes) {
     if (tx._class !== core.class.TxRemoveDoc) {
       continue
     }
@@ -445,7 +418,7 @@ async function ReactionNotificationContentProvider (
   _: Ref<Account>,
   control: TriggerControl
 ): Promise<NotificationContent> {
-  const tx = TxProcessor.extractTx(originTx) as TxCreateDoc<Reaction>
+  const tx = originTx as TxCreateDoc<Reaction>
   const presenter = getTextPresenter(doc._class, control.hierarchy)
   const reaction = TxProcessor.createDoc2Doc(tx)
 
diff --git a/server-plugins/activity-resources/src/references.ts b/server-plugins/activity-resources/src/references.ts
index e1f75a07ba..3c4d12fa45 100644
--- a/server-plugins/activity-resources/src/references.ts
+++ b/server-plugins/activity-resources/src/references.ts
@@ -18,7 +18,6 @@ import { loadCollaborativeDoc, yDocToBuffer } from '@hcengineering/collaboration
 import contact, { Employee, Person, PersonAccount } from '@hcengineering/contact'
 import core, {
   Account,
-  AttachedDoc,
   Class,
   CollaborativeDoc,
   Data,
@@ -28,7 +27,6 @@ import core, {
   Ref,
   Space,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxFactory,
@@ -359,12 +357,11 @@ async function getMessageNotifyResult (
   reference: Data<ActivityReference>,
   account: PersonAccount[],
   control: TriggerControl,
-  originTx: TxCUD<Doc>,
+  tx: TxCUD<Doc>,
   doc: Doc,
   notificationControl: NotificationProviderControl
 ): Promise<NotifyResult> {
   const { hierarchy } = control
-  const tx = TxProcessor.extractTx(originTx) as TxCUD<Doc>
 
   if (
     reference.attachedDocClass === undefined ||
@@ -384,7 +381,7 @@ async function getMessageNotifyResult (
     return new Map()
   }
 
-  return await isShouldNotifyTx(control, tx, originTx, doc, account, false, false, notificationControl, undefined)
+  return await isShouldNotifyTx(control, tx, doc, account, false, false, notificationControl, undefined)
 }
 
 function isMarkupType (type: Ref<Class<Type<any>>>): boolean {
@@ -668,24 +665,41 @@ async function getRemoveActivityReferenceTxes (
   return txes
 }
 
-function guessReferenceTx (hierarchy: Hierarchy, tx: TxCUD<Doc>): TxCUD<Doc> {
+function guessReferenceObj (
+  hierarchy: Hierarchy,
+  tx: TxCUD<Doc>
+): {
+    objectId: Ref<Doc>
+    objectClass: Ref<Class<Doc>>
+  } {
   // Try to guess reference target Tx for TxCollectionCUD txes based on collaborators availability
-  if (hierarchy.isDerived(tx._class, core.class.TxCollectionCUD)) {
-    const cltx = tx as TxCollectionCUD<Doc, AttachedDoc>
-    tx = TxProcessor.extractTx(cltx) as TxCUD<Doc>
-
+  if (tx.attachedToClass !== undefined && tx.attachedTo !== undefined) {
     if (hierarchy.isDerived(tx.objectClass, activity.class.ActivityMessage)) {
-      return cltx
+      return {
+        objectId: tx.attachedTo,
+        objectClass: tx.attachedToClass
+      }
     }
 
     const mixin = hierarchy.classHierarchyMixin(tx.objectClass, notification.mixin.ClassCollaborators)
-    return mixin !== undefined ? tx : cltx
+    return mixin !== undefined
+      ? {
+          objectId: tx.objectId,
+          objectClass: tx.objectClass
+        }
+      : {
+          objectId: tx.attachedTo,
+          objectClass: tx.attachedToClass
+        }
+  }
+  return {
+    objectId: tx.objectId,
+    objectClass: tx.objectClass
   }
-  return tx
 }
 
-async function ActivityReferenceCreate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
-  const ctx = etx as TxCreateDoc<Doc>
+async function ActivityReferenceCreate (tx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
+  const ctx = tx as TxCreateDoc<Doc>
 
   if (ctx._class !== core.class.TxCreateDoc) return []
   if (control.hierarchy.isDerived(ctx.objectClass, notification.class.InboxNotification)) return []
@@ -694,7 +708,7 @@ async function ActivityReferenceCreate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control
   const txFactory = new TxFactory(control.txFactory.account)
 
   const doc = TxProcessor.createDoc2Doc(ctx)
-  const targetTx = guessReferenceTx(control.hierarchy, tx)
+  const target = guessReferenceObj(control.hierarchy, tx)
 
   const txes: Tx[] = await getCreateReferencesTxes(
     control.ctx,
@@ -702,9 +716,9 @@ async function ActivityReferenceCreate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control
     control.storageAdapter,
     txFactory,
     doc,
-    targetTx.objectId,
-    targetTx.objectClass,
-    targetTx.objectSpace,
+    target.objectId,
+    target.objectClass,
+    tx.objectSpace,
     tx
   )
 
@@ -715,8 +729,8 @@ async function ActivityReferenceCreate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control
   return []
 }
 
-async function ActivityReferenceUpdate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
-  const ctx = etx as TxUpdateDoc<Doc>
+async function ActivityReferenceUpdate (tx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
+  const ctx = tx as TxUpdateDoc<Doc>
   const attributes = control.hierarchy.getAllAttributes(ctx.objectClass)
 
   let hasUpdates = false
@@ -742,7 +756,7 @@ async function ActivityReferenceUpdate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control
 
   const txFactory = new TxFactory(control.txFactory.account)
   const doc = TxProcessor.updateDoc2Doc(rawDoc, ctx)
-  const targetTx = guessReferenceTx(control.hierarchy, tx)
+  const target = guessReferenceObj(control.hierarchy, tx)
 
   const txes: Tx[] = await getUpdateReferencesTxes(
     control.ctx,
@@ -750,9 +764,9 @@ async function ActivityReferenceUpdate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control
     control.storageAdapter,
     txFactory,
     doc,
-    targetTx.objectId,
-    targetTx.objectClass,
-    targetTx.objectSpace,
+    target.objectId,
+    target.objectClass,
+    tx.objectSpace,
     tx
   )
 
@@ -763,8 +777,8 @@ async function ActivityReferenceUpdate (tx: TxCUD<Doc>, etx: TxCUD<Doc>, control
   return []
 }
 
-async function ActivityReferenceRemove (tx: Tx, etx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
-  const ctx = etx as TxRemoveDoc<Doc>
+async function ActivityReferenceRemove (tx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
+  const ctx = tx as TxRemoveDoc<Doc>
   const attributes = control.hierarchy.getAllAttributes(ctx.objectClass)
 
   let hasMarkdown = false
@@ -795,22 +809,21 @@ export async function ReferenceTrigger (txes: TxCUD<Doc>[], control: TriggerCont
   const result: Tx[] = []
 
   for (const tx of txes) {
-    const etx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-    if (control.hierarchy.isDerived(etx.objectClass, activity.class.ActivityReference)) {
+    if (control.hierarchy.isDerived(tx.objectClass, activity.class.ActivityReference)) {
       continue
     }
-    if (control.hierarchy.isDerived(etx.objectClass, notification.class.InboxNotification)) {
+    if (control.hierarchy.isDerived(tx.objectClass, notification.class.InboxNotification)) {
       continue
     }
 
-    if (etx._class === core.class.TxCreateDoc) {
-      result.push(...(await ActivityReferenceCreate(tx, etx, control)))
+    if (tx._class === core.class.TxCreateDoc) {
+      result.push(...(await ActivityReferenceCreate(tx, control)))
     }
-    if (etx._class === core.class.TxUpdateDoc) {
-      result.push(...(await ActivityReferenceUpdate(tx, etx, control)))
+    if (tx._class === core.class.TxUpdateDoc) {
+      result.push(...(await ActivityReferenceUpdate(tx, control)))
     }
-    if (etx._class === core.class.TxRemoveDoc) {
-      result.push(...(await ActivityReferenceRemove(tx, etx, control)))
+    if (tx._class === core.class.TxRemoveDoc) {
+      result.push(...(await ActivityReferenceRemove(tx, control)))
     }
   }
   return result
diff --git a/server-plugins/activity-resources/src/utils.ts b/server-plugins/activity-resources/src/utils.ts
index b63a5b0823..e2d020ba96 100644
--- a/server-plugins/activity-resources/src/utils.ts
+++ b/server-plugins/activity-resources/src/utils.ts
@@ -1,3 +1,4 @@
+import { ActivityMessageControl, DocAttributeUpdates, DocUpdateAction } from '@hcengineering/activity'
 import {
   Account,
   AttachedDoc,
@@ -10,7 +11,6 @@ import {
   Mixin,
   Ref,
   RefTo,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxMixin,
@@ -18,12 +18,11 @@ import {
   TxUpdateDoc
 } from '@hcengineering/core'
 import core from '@hcengineering/core/src/component'
-import { ActivityMessageControl, DocAttributeUpdates, DocUpdateAction } from '@hcengineering/activity'
-import { ActivityControl, DocObjectCache, getAllObjectTransactions } from '@hcengineering/server-activity'
-import { getDocCollaborators } from '@hcengineering/server-notification-resources'
 import notification from '@hcengineering/notification'
-import { TriggerControl } from '@hcengineering/server-core'
 import { translate } from '@hcengineering/platform'
+import { ActivityControl, DocObjectCache, getAllObjectTransactions } from '@hcengineering/server-activity'
+import { TriggerControl } from '@hcengineering/server-core'
+import { getDocCollaborators } from '@hcengineering/server-notification-resources'
 
 function getAvailableAttributesKeys (tx: TxCUD<Doc>, hierarchy: Hierarchy): string[] {
   if (hierarchy.isDerived(tx._class, core.class.TxUpdateDoc)) {
@@ -110,16 +109,13 @@ export async function getDocDiff (
   objectCache?: DocObjectCache
 ): Promise<{ doc?: Doc, prevDoc?: Doc }> {
   const hierarchy = control.hierarchy
-  const isAttached = hierarchy.isDerived(_class, core.class.AttachedDoc)
 
   const objectTxes =
     objectCache?.transactions.get(objectId) ??
     (await getAllObjectTransactions(control, _class, [objectId], mixin)).get(objectId) ??
     []
 
-  const createTx = isAttached
-    ? objectTxes.find((tx) => (tx as TxCollectionCUD<Doc, AttachedDoc>).tx?._class === core.class.TxCreateDoc)
-    : objectTxes.find((tx) => tx._class === core.class.TxCreateDoc)
+  const createTx = objectTxes.find((tx) => tx._class === core.class.TxCreateDoc)
 
   if (createTx === undefined) {
     return {}
@@ -128,11 +124,9 @@ export async function getDocDiff (
   let doc: Doc | undefined
   let prevDoc: Doc | undefined
 
-  doc = TxProcessor.createDoc2Doc(TxProcessor.extractTx(createTx) as TxCreateDoc<Doc>)
-
-  for (const objectTx of objectTxes) {
-    const actualTx = TxProcessor.extractTx(objectTx) as TxCUD<Doc>
+  doc = TxProcessor.createDoc2Doc(createTx as TxCreateDoc<Doc>)
 
+  for (const actualTx of objectTxes) {
     if (actualTx._class === core.class.TxUpdateDoc) {
       prevDoc = hierarchy.clone(doc)
       doc = TxProcessor.updateDoc2Doc(doc, actualTx as TxUpdateDoc<Doc>)
@@ -143,7 +137,7 @@ export async function getDocDiff (
       doc = TxProcessor.updateMixin4Doc(doc, actualTx as TxMixin<Doc, Doc>)
     }
 
-    if (objectTx._id === lastTxId) {
+    if (actualTx._id === lastTxId) {
       break
     }
   }
@@ -229,7 +223,6 @@ export async function getAttributeDiff (
 export async function getTxAttributesUpdates (
   ctx: MeasureContext,
   control: ActivityControl,
-  originTx: TxCUD<Doc>,
   tx: TxCUD<Doc>,
   object: Doc,
   objectCache?: DocObjectCache,
@@ -302,7 +295,7 @@ export async function getTxAttributesUpdates (
 
     if (hierarchy.isDerived(attrClass, core.class.TypeMarkup) || mixin === notification.mixin.Collaborators) {
       if (docDiff === undefined) {
-        docDiff = await getDocDiff(control, updateObject._class, updateObject._id, originTx._id, mixin, objectCache)
+        docDiff = await getDocDiff(control, updateObject._class, updateObject._id, tx._id, mixin, objectCache)
       }
     }
 
diff --git a/server-plugins/activity/src/utils.ts b/server-plugins/activity/src/utils.ts
index cb45394aa0..58c4bac316 100644
--- a/server-plugins/activity/src/utils.ts
+++ b/server-plugins/activity/src/utils.ts
@@ -1,15 +1,4 @@
-import {
-  AttachedDoc,
-  Class,
-  Doc,
-  Mixin,
-  Ref,
-  SortingOrder,
-  TxCollectionCUD,
-  TxCUD,
-  TxMixin,
-  TxUpdateDoc
-} from '@hcengineering/core'
+import { AttachedDoc, Class, Doc, Mixin, Ref, SortingOrder, TxCUD, TxMixin, TxUpdateDoc } from '@hcengineering/core'
 import core from '@hcengineering/core/src/component'
 import { DocObjectCache, type ActivityControl } from './types'
 
@@ -20,34 +9,27 @@ export async function getAllObjectTransactions (
   mixin?: Ref<Mixin<Doc>>
 ): Promise<DocObjectCache['transactions']> {
   const cache: DocObjectCache['transactions'] = new Map()
-  const hierarchy = control.hierarchy
-  const isAttached = hierarchy.isDerived(_class, core.class.AttachedDoc)
 
   const ownTxes = await control.findAll<TxCUD<Doc>>(
     control.ctx,
-    isAttached ? core.class.TxCollectionCUD : core.class.TxCUD,
-    isAttached
-      ? { 'tx.objectId': { $in: docs as Ref<AttachedDoc>[] } }
-      : {
-          objectId: { $in: docs },
-          _class: {
-            $in: [core.class.TxCreateDoc, core.class.TxUpdateDoc, core.class.TxRemoveDoc, core.class.TxMixin]
-          }
-        },
+    core.class.TxCUD,
+    {
+      objectId: { $in: docs }
+    },
     { sort: { modifiedOn: SortingOrder.Ascending } }
   )
 
   for (const tx of ownTxes) {
-    const id = isAttached ? (tx as TxCollectionCUD<Doc, AttachedDoc>).tx.objectId : tx.objectId
+    if (mixin !== undefined && tx._class === core.class.TxMixin && (tx as TxMixin<Doc, Doc>).mixin !== mixin) continue
+    const id = tx.objectId
     cache.set(id, [...(cache.get(id) ?? []), tx])
   }
 
-  const collectionTxes = await control.findAll<TxCollectionCUD<Doc, AttachedDoc>>(
+  const collectionTxes = await control.findAll<TxCUD<AttachedDoc>>(
     control.ctx,
-    core.class.TxCollectionCUD,
+    core.class.TxCUD,
     {
-      objectId: { $in: docs },
-      'tx._class': { $in: [core.class.TxCreateDoc, core.class.TxUpdateDoc, core.class.TxRemoveDoc] }
+      attachedTo: { $in: docs }
     },
     { sort: { modifiedOn: SortingOrder.Ascending } }
   )
@@ -57,36 +39,17 @@ export async function getAllObjectTransactions (
     cache.set(id, [...(cache.get(id) ?? []), tx])
   }
 
-  const mixinTxes = isAttached
-    ? await control.findAll<TxMixin<Doc, Doc>>(
-      control.ctx,
-      core.class.TxMixin,
-      {
-        objectId: { $in: docs },
-        ...(mixin !== undefined ? { mixin } : {})
-      },
-      { sort: { modifiedOn: SortingOrder.Ascending } }
-    )
-    : []
-
-  for (const tx of mixinTxes) {
-    const id = tx.objectId
-    cache.set(id, [...(cache.get(id) ?? []), tx])
-  }
-
-  const moveCollection = await control.findAll<TxCollectionCUD<Doc, AttachedDoc>>(
+  const moveCollection = await control.findAll<TxCUD<AttachedDoc>>(
     control.ctx,
-    core.class.TxCollectionCUD,
+    core.class.TxUpdateDoc,
     {
-      'tx.operations.attachedTo': { $in: docs },
-      'tx._class': core.class.TxUpdateDoc
+      'operations.attachedTo': { $in: docs }
     },
     { sort: { modifiedOn: SortingOrder.Ascending } }
   )
 
   for (const tx of moveCollection) {
-    const id = ((tx as TxCollectionCUD<Doc, AttachedDoc>).tx as TxUpdateDoc<AttachedDoc>).operations
-      .attachedTo as Ref<Doc>
+    const id = (tx as TxUpdateDoc<AttachedDoc>).operations.attachedTo as Ref<Doc>
     cache.set(id, [...(cache.get(id) ?? []), tx])
   }
 
diff --git a/server-plugins/ai-bot-resources/src/index.ts b/server-plugins/ai-bot-resources/src/index.ts
index ee9b08d7ae..89ac7e9962 100644
--- a/server-plugins/ai-bot-resources/src/index.ts
+++ b/server-plugins/ai-bot-resources/src/index.ts
@@ -29,7 +29,6 @@ import core, {
   Ref,
   toWorkspaceString,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxProcessor,
@@ -240,25 +239,20 @@ async function onSupportWorkspaceMessage (control: TriggerControl, message: Chat
   await sendAIEvents([transferEvent], control.workspace, control.ctx)
 }
 
-export async function OnMessageSend (
-  originTxs: TxCollectionCUD<Doc, AttachedDoc>[],
-  control: TriggerControl
-): Promise<Tx[]> {
+export async function OnMessageSend (originTxs: TxCUD<AttachedDoc>[], control: TriggerControl): Promise<Tx[]> {
   const { hierarchy } = control
-  const txes = originTxs
-    .map((it) => TxProcessor.extractTx(it) as TxCreateDoc<ChatMessage>)
-    .filter(
-      (it) =>
-        it._class === core.class.TxCreateDoc &&
-        hierarchy.isDerived(it.objectClass, chunter.class.ChatMessage) &&
-        !(it.modifiedBy === aiBot.account.AIBot || it.modifiedBy === core.account.System)
-    )
+  const txes = originTxs.filter(
+    (it) =>
+      it._class === core.class.TxCreateDoc &&
+      hierarchy.isDerived(it.objectClass, chunter.class.ChatMessage) &&
+      !(it.modifiedBy === aiBot.account.AIBot || it.modifiedBy === core.account.System)
+  )
   if (txes.length === 0) {
     return []
   }
   for (const tx of txes) {
     const isThread = hierarchy.isDerived(tx.objectClass, chunter.class.ThreadMessage)
-    const message = TxProcessor.createDoc2Doc(tx)
+    const message = TxProcessor.createDoc2Doc(tx as TxCreateDoc<ChatMessage>)
 
     const docClass = isThread ? (message as ThreadMessage).objectClass : message.attachedToClass
 
@@ -365,7 +359,7 @@ export async function OnMessageNotified (
 
 export async function OnUserStatus (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const originTx of txes) {
-    const tx = TxProcessor.extractTx(originTx) as TxCUD<UserStatus>
+    const tx = originTx as TxCUD<UserStatus>
 
     if (
       tx.objectClass !== core.class.UserStatus ||
diff --git a/server-plugins/attachment-resources/src/index.ts b/server-plugins/attachment-resources/src/index.ts
index 553ca560f4..cc1ee76a47 100644
--- a/server-plugins/attachment-resources/src/index.ts
+++ b/server-plugins/attachment-resources/src/index.ts
@@ -16,7 +16,6 @@
 
 import type { Attachment } from '@hcengineering/attachment'
 import type { Tx, TxRemoveDoc } from '@hcengineering/core'
-import { TxProcessor } from '@hcengineering/core'
 import type { TriggerControl } from '@hcengineering/server-core'
 
 /**
@@ -28,7 +27,7 @@ export async function OnAttachmentDelete (
 ): Promise<Tx[]> {
   const toDelete: string[] = []
   for (const tx of txes) {
-    const rmTx = TxProcessor.extractTx(tx) as TxRemoveDoc<Attachment>
+    const rmTx = tx as TxRemoveDoc<Attachment>
 
     // Obtain document being deleted.
     const attach = removedMap.get(rmTx.objectId) as Attachment
diff --git a/server-plugins/calendar-resources/src/index.ts b/server-plugins/calendar-resources/src/index.ts
index 32293b898e..edfc41c11c 100644
--- a/server-plugins/calendar-resources/src/index.ts
+++ b/server-plugins/calendar-resources/src/index.ts
@@ -86,7 +86,7 @@ export async function ReminderTextPresenter (doc: Doc, control: TriggerControl):
 export async function OnPersonAccountCreate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxCreateDoc<PersonAccount>
+    const ctx = tx as TxCreateDoc<PersonAccount>
     const user = TxProcessor.createDoc2Doc(ctx)
 
     result.push(
@@ -126,7 +126,7 @@ function getEventPerson (current: Event, calendars: Calendar[], control: Trigger
 async function OnEvent (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxCUD<Event>
+    const ctx = tx as TxCUD<Event>
     if (ctx._class === core.class.TxCreateDoc) {
       result.push(...(await onEventCreate(ctx as TxCreateDoc<Event>, control)))
     } else if (ctx._class === core.class.TxUpdateDoc) {
diff --git a/server-plugins/chunter-resources/src/index.ts b/server-plugins/chunter-resources/src/index.ts
index d3a0ef59b5..2ae2047397 100644
--- a/server-plugins/chunter-resources/src/index.ts
+++ b/server-plugins/chunter-resources/src/index.ts
@@ -18,7 +18,6 @@ import chunter, { Channel, ChatMessage, chunterId, ChunterSpace, ThreadMessage }
 import contact, { Person, PersonAccount } from '@hcengineering/contact'
 import core, {
   Account,
-  AttachedDoc,
   Class,
   concatLink,
   Doc,
@@ -29,7 +28,6 @@ import core, {
   Ref,
   Timestamp,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxProcessor,
@@ -114,7 +112,7 @@ export async function CommentRemove (
 }
 
 async function OnThreadMessageCreated (originTx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
-  const tx = TxProcessor.extractTx(originTx) as TxCreateDoc<ThreadMessage>
+  const tx = originTx as TxCreateDoc<ThreadMessage>
 
   const threadMessage = TxProcessor.createDoc2Doc(tx)
   const message = (
@@ -154,7 +152,7 @@ async function OnThreadMessageCreated (originTx: TxCUD<Doc>, control: TriggerCon
 
 async function OnChatMessageCreated (ctx: MeasureContext, tx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
   const hierarchy = control.hierarchy
-  const actualTx = TxProcessor.extractTx(tx) as TxCreateDoc<ChatMessage>
+  const actualTx = tx as TxCreateDoc<ChatMessage>
 
   const message = TxProcessor.createDoc2Doc(actualTx)
   if (message.modifiedBy === core.account.System) return []
@@ -206,7 +204,7 @@ async function OnChatMessageCreated (ctx: MeasureContext, tx: TxCUD<Doc>, contro
 async function ChatNotificationsHandler (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCreateDoc<ChatMessage>
+    const actualTx = tx as TxCreateDoc<ChatMessage>
 
     if (actualTx._class !== core.class.TxCreateDoc) {
       continue
@@ -232,7 +230,7 @@ function joinChannel (control: TriggerControl, channel: Channel, user: Ref<Accou
 }
 
 async function OnThreadMessageDeleted (tx: Tx, control: TriggerControl): Promise<Tx[]> {
-  const removeTx = TxProcessor.extractTx(tx) as TxRemoveDoc<ThreadMessage>
+  const removeTx = tx as TxRemoveDoc<ThreadMessage>
 
   const message = control.removedMap.get(removeTx.objectId) as ThreadMessage
 
@@ -270,23 +268,21 @@ async function OnThreadMessageDeleted (tx: Tx, control: TriggerControl): Promise
 export async function ChunterTrigger (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const res: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCreateDoc<ChatMessage>
-
     if (
-      actualTx._class === core.class.TxCreateDoc &&
-      control.hierarchy.isDerived(actualTx.objectClass, chunter.class.ThreadMessage)
+      tx._class === core.class.TxCreateDoc &&
+      control.hierarchy.isDerived(tx.objectClass, chunter.class.ThreadMessage)
     ) {
       res.push(...(await control.ctx.with('OnThreadMessageCreated', {}, (ctx) => OnThreadMessageCreated(tx, control))))
     }
     if (
-      actualTx._class === core.class.TxRemoveDoc &&
-      control.hierarchy.isDerived(actualTx.objectClass, chunter.class.ThreadMessage)
+      tx._class === core.class.TxRemoveDoc &&
+      control.hierarchy.isDerived(tx.objectClass, chunter.class.ThreadMessage)
     ) {
       res.push(...(await control.ctx.with('OnThreadMessageDeleted', {}, (ctx) => OnThreadMessageDeleted(tx, control))))
     }
     if (
-      actualTx._class === core.class.TxCreateDoc &&
-      control.hierarchy.isDerived(actualTx.objectClass, chunter.class.ChatMessage)
+      tx._class === core.class.TxCreateDoc &&
+      control.hierarchy.isDerived(tx.objectClass, chunter.class.ChatMessage)
     ) {
       res.push(...(await control.ctx.with('OnChatMessageCreated', {}, (ctx) => OnChatMessageCreated(ctx, tx, control))))
     }
@@ -310,16 +306,13 @@ export async function getChunterNotificationContent (
 
   let message: string | undefined
 
-  if (tx._class === core.class.TxCollectionCUD) {
-    const ptx = tx as TxCollectionCUD<Doc, AttachedDoc>
-    if (ptx.tx._class === core.class.TxCreateDoc) {
-      if (control.hierarchy.isDerived(ptx.tx.objectClass, chunter.class.ChatMessage)) {
-        const createTx = ptx.tx as TxCreateDoc<ChatMessage>
-        message = createTx.attributes.message
-      } else if (ptx.tx.objectClass === activity.class.ActivityReference) {
-        const createTx = ptx.tx as TxCreateDoc<ActivityReference>
-        message = createTx.attributes.message
-      }
+  if (tx._class === core.class.TxCreateDoc) {
+    if (control.hierarchy.isDerived(tx.objectClass, chunter.class.ChatMessage)) {
+      const createTx = tx as TxCreateDoc<ChatMessage>
+      message = createTx.attributes.message
+    } else if (tx.objectClass === activity.class.ActivityReference) {
+      const createTx = tx as TxCreateDoc<ActivityReference>
+      message = createTx.attributes.message
     }
   }
 
@@ -348,15 +341,15 @@ export async function getChunterNotificationContent (
   }
 }
 
-async function OnChatMessageRemoved (txes: TxCollectionCUD<Doc, ChatMessage>[], control: TriggerControl): Promise<Tx[]> {
+async function OnChatMessageRemoved (txes: TxCUD<ChatMessage>[], control: TriggerControl): Promise<Tx[]> {
   const res: Tx[] = []
   for (const tx of txes) {
-    if (tx.tx._class !== core.class.TxRemoveDoc) {
+    if (tx._class !== core.class.TxRemoveDoc) {
       continue
     }
 
     const notifications = await control.findAll(control.ctx, notification.class.InboxNotification, {
-      attachedTo: tx.tx.objectId
+      attachedTo: tx.objectId
     })
 
     notifications.forEach((notification) => {
@@ -478,8 +471,7 @@ export async function syncChat (control: TriggerControl, status: UserStatus, dat
 }
 
 async function OnUserStatus (txes: TxCUD<UserStatus>[], control: TriggerControl): Promise<Tx[]> {
-  for (const originTx of txes) {
-    const tx = TxProcessor.extractTx(originTx) as TxCUD<UserStatus>
+  for (const tx of txes) {
     if (tx.objectClass !== core.class.UserStatus) {
       continue
     }
@@ -488,14 +480,14 @@ async function OnUserStatus (txes: TxCUD<UserStatus>[], control: TriggerControl)
       const { online } = createTx.attributes
       if (online) {
         const status = TxProcessor.createDoc2Doc(createTx)
-        await syncChat(control, status, originTx.modifiedOn)
+        await syncChat(control, status, tx.modifiedOn)
       }
     } else if (tx._class === core.class.TxUpdateDoc) {
       const updateTx = tx as TxUpdateDoc<UserStatus>
       const { online } = updateTx.operations
       if (online === true) {
         const status = (await control.findAll(control.ctx, core.class.UserStatus, { _id: updateTx.objectId }))[0]
-        await syncChat(control, status, originTx.modifiedOn)
+        await syncChat(control, status, tx.modifiedOn)
       }
     }
   }
diff --git a/server-plugins/collaboration-resources/src/index.ts b/server-plugins/collaboration-resources/src/index.ts
index 4e03ebf162..bcf19cbfdd 100644
--- a/server-plugins/collaboration-resources/src/index.ts
+++ b/server-plugins/collaboration-resources/src/index.ts
@@ -15,7 +15,7 @@
 
 import { removeCollaborativeDoc } from '@hcengineering/collaboration'
 import type { CollaborativeDoc, Doc, Tx, TxRemoveDoc } from '@hcengineering/core'
-import core, { TxProcessor } from '@hcengineering/core'
+import core from '@hcengineering/core'
 import { type TriggerControl } from '@hcengineering/server-core'
 
 /**
@@ -25,9 +25,7 @@ export async function OnDelete (
   txes: Tx[],
   { hierarchy, storageAdapter, workspace, removedMap, ctx }: TriggerControl
 ): Promise<Tx[]> {
-  const ltxes = txes
-    .map((it) => TxProcessor.extractTx(it))
-    .filter((it) => it._class === core.class.TxRemoveDoc) as TxRemoveDoc<Doc>[]
+  const ltxes = txes.filter((it) => it._class === core.class.TxRemoveDoc) as TxRemoveDoc<Doc>[]
   for (const rmTx of ltxes) {
     // Obtain document being deleted
     const doc = removedMap.get(rmTx.objectId)
diff --git a/server-plugins/controlled-documents-resources/src/index.ts b/server-plugins/controlled-documents-resources/src/index.ts
index 28cb724eff..e2c90a4f82 100644
--- a/server-plugins/controlled-documents-resources/src/index.ts
+++ b/server-plugins/controlled-documents-resources/src/index.ts
@@ -20,7 +20,6 @@ import core, {
   Ref,
   SortingOrder,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxFactory,
   TxUpdateDoc,
@@ -345,12 +344,17 @@ export async function OnDocPlannedEffectiveDateChanged (
 }
 
 export async function OnDocApprovalRequestApproved (
-  txes: TxCollectionCUD<ControlledDocument, DocumentApprovalRequest>[],
+  txes: TxUpdateDoc<DocumentApprovalRequest>[],
   control: TriggerControl
 ): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const doc = (await control.findAll(control.ctx, tx.objectClass, { _id: tx.objectId })).shift()
+    if (tx.attachedTo === undefined || tx.attachedToClass === undefined) continue
+    const doc = (
+      await control.findAll<ControlledDocument>(control.ctx, tx.attachedToClass, {
+        _id: tx.attachedTo as Ref<ControlledDocument>
+      })
+    )[0]
     if (doc == null || doc.plannedEffectiveDate !== 0) {
       continue
     }
diff --git a/server-plugins/drive-resources/src/index.ts b/server-plugins/drive-resources/src/index.ts
index 80464092a5..f2a1622c23 100644
--- a/server-plugins/drive-resources/src/index.ts
+++ b/server-plugins/drive-resources/src/index.ts
@@ -22,8 +22,7 @@ import {
   type TxRemoveDoc,
   DocumentQuery,
   FindOptions,
-  FindResult,
-  TxProcessor
+  FindResult
 } from '@hcengineering/core'
 import drive, { type FileVersion, type Folder } from '@hcengineering/drive'
 import type { TriggerControl } from '@hcengineering/server-core'
@@ -36,7 +35,7 @@ export async function OnFileVersionDelete (
   const result: Tx[] = []
   const toDelete: string[] = []
   for (const tx of txes) {
-    const rmTx = TxProcessor.extractTx(tx) as TxRemoveDoc<FileVersion>
+    const rmTx = tx as TxRemoveDoc<FileVersion>
 
     // Obtain document being deleted.
     const version = removedMap.get(rmTx.objectId) as FileVersion
diff --git a/server-plugins/fulltext-resources/src/index.ts b/server-plugins/fulltext-resources/src/index.ts
index e77064f87c..999dfc5ff4 100644
--- a/server-plugins/fulltext-resources/src/index.ts
+++ b/server-plugins/fulltext-resources/src/index.ts
@@ -20,12 +20,10 @@ import core, {
   Tx,
   TxProcessor,
   type AnyAttribute,
-  type AttachedDoc,
   type Class,
   type Doc,
   type FullTextSearchContext,
   type Ref,
-  type TxCollectionCUD,
   type TxCUD,
   type TxUpdateDoc
 } from '@hcengineering/core'
@@ -44,11 +42,7 @@ export async function OnChange (txes: Tx[], control: TriggerControl): Promise<Tx
   }
   const docsToUpsert = control.ctx.contextData.fulltextUpdates
 
-  for (let tx of txes) {
-    if (tx._class === core.class.TxCollectionCUD) {
-      const txcol = tx as TxCollectionCUD<Doc, AttachedDoc>
-      tx = txcol.tx
-    }
+  for (const tx of txes) {
     const attrs = new Map<string, AnyAttribute>()
     if (TxProcessor.isExtendsCUD(tx._class)) {
       const cud = tx as TxCUD<Doc>
diff --git a/server-plugins/gmail-resources/src/index.ts b/server-plugins/gmail-resources/src/index.ts
index 36774a299d..8919671faa 100644
--- a/server-plugins/gmail-resources/src/index.ts
+++ b/server-plugins/gmail-resources/src/index.ts
@@ -98,7 +98,7 @@ export function IsIncomingMessageTypeMatch (
   type: NotificationType,
   control: TriggerControl
 ): boolean {
-  const message = TxProcessor.createDoc2Doc(TxProcessor.extractTx(tx) as TxCreateDoc<Message>)
+  const message = TxProcessor.createDoc2Doc(tx as TxCreateDoc<Message>)
   return message.incoming && message.sendOn > (doc.createdOn ?? doc.modifiedOn)
 }
 
diff --git a/server-plugins/guest-resources/src/index.ts b/server-plugins/guest-resources/src/index.ts
index dc17d073fb..1d08291d60 100644
--- a/server-plugins/guest-resources/src/index.ts
+++ b/server-plugins/guest-resources/src/index.ts
@@ -38,9 +38,7 @@ import view from '@hcengineering/view'
 export async function OnPublicLinkCreate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const extractedTx = TxProcessor.extractTx(tx)
-
-    const createTx = extractedTx as TxCreateDoc<PublicLink>
+    const createTx = tx as TxCreateDoc<PublicLink>
 
     const link = TxProcessor.createDoc2Doc<PublicLink>(createTx)
 
diff --git a/server-plugins/hr-resources/src/index.ts b/server-plugins/hr-resources/src/index.ts
index a7577a049f..1e9a2f2e27 100644
--- a/server-plugins/hr-resources/src/index.ts
+++ b/server-plugins/hr-resources/src/index.ts
@@ -134,7 +134,7 @@ function getTxes (
 export async function OnDepartmentStaff (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxMixin<Employee, Staff>
+    const ctx = tx as TxMixin<Employee, Staff>
 
     const targetAccount = control.modelDb.getAccountByPersonId(ctx.objectId) as PersonAccount[]
     if (targetAccount.length === 0) {
@@ -193,7 +193,7 @@ export async function OnDepartmentStaff (txes: Tx[], control: TriggerControl): P
 export async function OnDepartmentRemove (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxRemoveDoc<Department>
+    const ctx = tx as TxRemoveDoc<Department>
 
     const department = control.removedMap.get(ctx.objectId) as Department
     if (department === undefined) {
@@ -235,7 +235,7 @@ export async function OnDepartmentRemove (txes: Tx[], control: TriggerControl):
 export async function OnEmployee (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxMixin<Person, Employee>
+    const ctx = tx as TxMixin<Person, Employee>
 
     const person = (await control.findAll(control.ctx, contact.class.Person, { _id: ctx.objectId }))[0]
     if (person === undefined) {
@@ -262,11 +262,10 @@ export async function OnEmployee (txes: Tx[], control: TriggerControl): Promise<
 export async function OnEmployeeDeactivate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx)
-    if (core.class.TxMixin !== actualTx._class) {
+    if (core.class.TxMixin !== tx._class) {
       continue
     }
-    const ctx = actualTx as TxMixin<Person, Employee>
+    const ctx = tx as TxMixin<Person, Employee>
     if (ctx.mixin !== contact.mixin.Employee || ctx.attributes.active !== false) {
       continue
     }
@@ -348,7 +347,7 @@ async function sendEmailNotifications (
  */
 export async function OnRequestCreate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxCreateDoc<Request>
+    const ctx = tx as TxCreateDoc<Request>
 
     const sender = getPersonAccountById(ctx.modifiedBy, control)
     if (sender === undefined) {
@@ -367,7 +366,7 @@ export async function OnRequestCreate (txes: Tx[], control: TriggerControl): Pro
  */
 export async function OnRequestUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxUpdateDoc<Request>
+    const ctx = tx as TxUpdateDoc<Request>
 
     const sender = getPersonAccountById(ctx.modifiedBy, control)
     if (sender === undefined) {
@@ -389,7 +388,7 @@ export async function OnRequestUpdate (txes: Tx[], control: TriggerControl): Pro
  */
 export async function OnRequestRemove (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxCreateDoc<Request>
+    const ctx = tx as TxCreateDoc<Request>
 
     const sender = getPersonAccountById(ctx.modifiedBy, control)
     if (sender === undefined) {
@@ -448,7 +447,7 @@ export async function RequestTextPresenter (doc: Doc, control: TriggerControl):
 export async function OnPublicHolidayCreate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxCreateDoc<PublicHoliday>
+    const ctx = tx as TxCreateDoc<PublicHoliday>
 
     const sender = getPersonAccountById(ctx.modifiedBy, control)
     if (sender === undefined) {
diff --git a/server-plugins/love-resources/src/index.ts b/server-plugins/love-resources/src/index.ts
index f989c81669..0a4eaca085 100644
--- a/server-plugins/love-resources/src/index.ts
+++ b/server-plugins/love-resources/src/index.ts
@@ -51,7 +51,7 @@ import view from '@hcengineering/view'
 export async function OnEmployee (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxMixin<Person, Employee>
+    const actualTx = tx as TxMixin<Person, Employee>
     if (actualTx._class !== core.class.TxMixin) {
       continue
     }
@@ -140,7 +140,7 @@ async function removeUserInfo (acc: Ref<Account>, control: TriggerControl): Prom
 export async function OnUserStatus (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<UserStatus>
+    const actualTx = tx as TxCUD<UserStatus>
     if (actualTx.objectClass !== core.class.UserStatus) {
       continue
     }
@@ -243,7 +243,7 @@ async function setDefaultRoomAccess (info: ParticipantInfo, control: TriggerCont
 export async function OnParticipantInfo (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<ParticipantInfo>
+    const actualTx = tx as TxCUD<ParticipantInfo>
     if (actualTx._class === core.class.TxCreateDoc) {
       const info = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<ParticipantInfo>)
       result.push(...(await roomJoinHandler(info, control)))
@@ -277,7 +277,7 @@ export async function OnParticipantInfo (txes: Tx[], control: TriggerControl): P
 
 export async function OnKnock (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCreateDoc<JoinRequest>
+    const actualTx = tx as TxCreateDoc<JoinRequest>
     if (actualTx._class === core.class.TxCreateDoc) {
       const request = TxProcessor.createDoc2Doc(actualTx)
       if (request.status === RequestStatus.Pending) {
@@ -327,7 +327,7 @@ export async function OnKnock (txes: Tx[], control: TriggerControl): Promise<Tx[
 
 export async function OnInvite (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCreateDoc<Invite>
+    const actualTx = tx as TxCreateDoc<Invite>
     if (actualTx._class === core.class.TxCreateDoc) {
       const invite = TxProcessor.createDoc2Doc(actualTx)
       if (invite.status === RequestStatus.Pending) {
diff --git a/server-plugins/notification-resources/src/index.ts b/server-plugins/notification-resources/src/index.ts
index 16d7a8d97a..1c5db63d84 100644
--- a/server-plugins/notification-resources/src/index.ts
+++ b/server-plugins/notification-resources/src/index.ts
@@ -46,7 +46,6 @@ import core, {
   Timestamp,
   toIdMap,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxMixin,
@@ -778,7 +777,6 @@ export async function getNotificationTxes (
   control: TriggerControl,
   object: Doc,
   tx: TxCUD<Doc>,
-  originTx: TxCUD<Doc>,
   receiver: ReceiverInfo,
   sender: SenderInfo,
   params: NotifyParams,
@@ -798,7 +796,6 @@ export async function getNotificationTxes (
     const notifyResult = await isShouldNotifyTx(
       control,
       tx,
-      originTx,
       object,
       [receiver.account],
       params.isOwn,
@@ -810,7 +807,7 @@ export async function getNotificationTxes (
     if (notifyResult.has(notification.providers.InboxNotificationProvider)) {
       const notificationTx = await pushActivityInboxNotifications(
         ctx,
-        originTx,
+        tx,
         control,
         res,
         receiver,
@@ -851,7 +848,7 @@ export async function getNotificationTxes (
           object.space,
           receiver,
           sender._id,
-          params.shouldUpdateTimestamp ? originTx.modifiedOn : undefined,
+          params.shouldUpdateTimestamp ? tx.modifiedOn : undefined,
           tx
         )
       }
@@ -939,7 +936,6 @@ export async function createCollabDocInfo (
   collaborators: Ref<PersonAccount>[],
   control: TriggerControl,
   tx: TxCUD<Doc>,
-  originTx: TxCUD<Doc>,
   object: Doc,
   activityMessages: ActivityMessage[],
   params: NotifyParams,
@@ -947,7 +943,7 @@ export async function createCollabDocInfo (
 ): Promise<Tx[]> {
   let res: Tx[] = []
 
-  if (originTx.space === core.space.DerivedTx) {
+  if (tx.space === core.space.DerivedTx) {
     return res
   }
 
@@ -971,7 +967,7 @@ export async function createCollabDocInfo (
   }
 
   if (notifyContexts.length > 0) {
-    await updateContextsTimestamp(ctx, notifyContexts, originTx.modifiedOn, control, originTx.modifiedBy)
+    await updateContextsTimestamp(ctx, notifyContexts, tx.modifiedOn, control, tx.modifiedBy)
   }
   if (notifyContexts.length > 0 && unsubscribe.length > 0) {
     await removeContexts(ctx, notifyContexts, unsubscribe, control)
@@ -992,10 +988,10 @@ export async function createCollabDocInfo (
   }
 
   const usersInfo = await ctx.with('get-user-info', {}, (ctx) =>
-    getUsersInfo(ctx, [...Array.from(targets), originTx.modifiedBy as Ref<PersonAccount>], control)
+    getUsersInfo(ctx, [...Array.from(targets), tx.modifiedBy as Ref<PersonAccount>], control)
   )
-  const sender: SenderInfo = usersInfo.get(originTx.modifiedBy) ?? {
-    _id: originTx.modifiedBy
+  const sender: SenderInfo = usersInfo.get(tx.modifiedBy) ?? {
+    _id: tx.modifiedBy
   }
 
   const settings = await getNotificationProviderControl(ctx, control)
@@ -1013,7 +1009,6 @@ export async function createCollabDocInfo (
       control,
       object,
       tx,
-      originTx,
       info,
       sender,
       params,
@@ -1104,7 +1099,6 @@ async function getSpaceCollabTxes (
   control: TriggerControl,
   doc: Doc,
   tx: TxCUD<Doc>,
-  originTx: TxCUD<Doc>,
   activityMessages: ActivityMessage[],
   cache: Map<Ref<Doc>, Doc>
 ): Promise<Tx[]> {
@@ -1130,7 +1124,6 @@ async function getSpaceCollabTxes (
         collabs.collaborators as Ref<PersonAccount>[],
         control,
         tx,
-        originTx,
         doc,
         activityMessages,
         { isSpace: true, isOwn: false, shouldUpdateTimestamp: true }
@@ -1145,7 +1138,6 @@ async function createCollaboratorDoc (
   tx: TxCreateDoc<Doc>,
   control: TriggerControl,
   activityMessage: ActivityMessage[],
-  originTx: TxCUD<Doc>,
   cache: Map<Ref<Doc>, Doc>
 ): Promise<Tx[]> {
   const res: Tx[] = []
@@ -1161,7 +1153,7 @@ async function createCollaboratorDoc (
   const mixinTx = getMixinTx(tx, control, collaborators)
 
   const notificationTxes = await ctx.with('create-collabdocinfo', {}, (ctx) =>
-    createCollabDocInfo(ctx, collaborators as Ref<PersonAccount>[], control, tx, originTx, doc, activityMessage, {
+    createCollabDocInfo(ctx, collaborators as Ref<PersonAccount>[], control, tx, doc, activityMessage, {
       isOwn: true,
       isSpace: false,
       shouldUpdateTimestamp: true
@@ -1172,7 +1164,7 @@ async function createCollaboratorDoc (
 
   res.push(
     ...(await ctx.with('get-space-collabtxes', {}, (ctx) =>
-      getSpaceCollabTxes(ctx, control, doc, tx, originTx, activityMessage, cache)
+      getSpaceCollabTxes(ctx, control, doc, tx, activityMessage, cache)
     ))
   )
 
@@ -1197,18 +1189,11 @@ async function updateCollaboratorsMixin (
   const notificationControl = await getNotificationProviderControl(ctx, control)
 
   if (tx.attributes.collaborators !== undefined) {
-    const createTx = hierarchy.isDerived(tx.objectClass, core.class.AttachedDoc)
-      ? (
-          await control.findAll(ctx, core.class.TxCollectionCUD, {
-            'tx.objectId': tx.objectId,
-            'tx._class': core.class.TxCreateDoc
-          })
-        )[0]
-      : (
-          await control.findAll(ctx, core.class.TxCreateDoc, {
-            objectId: tx.objectId
-          })
-        )[0]
+    const createTx = (
+      await control.findAll(ctx, core.class.TxCreateDoc, {
+        objectId: tx.objectId
+      })
+    )[0]
     const mixinTxes = await control.findAll(ctx, core.class.TxMixin, {
       objectId: tx.objectId
     })
@@ -1283,19 +1268,25 @@ async function updateCollaboratorsMixin (
 
 async function collectionCollabDoc (
   ctx: MeasureContext,
-  tx: TxCollectionCUD<Doc, AttachedDoc>,
+  tx: TxCUD<AttachedDoc>,
   control: TriggerControl,
   activityMessages: ActivityMessage[],
-  cache: Map<Ref<Doc>, Doc>
+  cache: Map<Ref<Doc>, Doc>,
+  ignoreCollection: boolean = false
 ): Promise<Tx[]> {
-  const actualTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-  let res = await createCollaboratorNotifications(ctx, actualTx, control, activityMessages, tx, cache)
+  let res = await createCollaboratorNotifications(ctx, tx, control, activityMessages, tx, cache, ignoreCollection)
 
-  if (![core.class.TxCreateDoc, core.class.TxRemoveDoc, core.class.TxUpdateDoc].includes(actualTx._class)) {
+  if (![core.class.TxCreateDoc, core.class.TxRemoveDoc, core.class.TxUpdateDoc].includes(tx._class)) {
     return res
   }
 
-  const mixin = control.hierarchy.classHierarchyMixin(tx.objectClass, notification.mixin.ClassCollaborators)
+  const { attachedTo, attachedToClass } = tx
+
+  if (attachedTo === undefined || attachedToClass === undefined) {
+    return res
+  }
+
+  const mixin = control.hierarchy.classHierarchyMixin(attachedToClass, notification.mixin.ClassCollaborators)
 
   if (mixin === undefined) {
     return res
@@ -1305,7 +1296,7 @@ async function collectionCollabDoc (
     'get-doc',
     {},
     async (ctx) =>
-      cache.get(tx.objectId) ?? (await control.findAll(ctx, tx.objectClass, { _id: tx.objectId }, { limit: 1 }))[0]
+      cache.get(attachedTo) ?? (await control.findAll(ctx, attachedToClass, { _id: attachedTo }, { limit: 1 }))[0]
   )
 
   if (doc === undefined) {
@@ -1318,7 +1309,7 @@ async function collectionCollabDoc (
 
   res = res.concat(
     await ctx.with('create-collab-doc-info', {}, (ctx) =>
-      createCollabDocInfo(ctx, collaborators as Ref<PersonAccount>[], control, actualTx, tx, doc, activityMessages, {
+      createCollabDocInfo(ctx, collaborators as Ref<PersonAccount>[], control, tx, doc, activityMessages, {
         isOwn: false,
         isSpace: false,
         shouldUpdateTimestamp: true
@@ -1491,7 +1482,6 @@ async function updateCollaboratorDoc (
           collabsInfo.result as Ref<PersonAccount>[],
           control,
           tx,
-          originTx,
           doc,
           activityMessages,
           params,
@@ -1505,22 +1495,13 @@ async function updateCollaboratorDoc (
     )
     res.push(getMixinTx(tx, control, collaborators))
     res = res.concat(
-      await createCollabDocInfo(
-        ctx,
-        collaborators as Ref<PersonAccount>[],
-        control,
-        tx,
-        originTx,
-        doc,
-        activityMessages,
-        params
-      )
+      await createCollabDocInfo(ctx, collaborators as Ref<PersonAccount>[], control, tx, doc, activityMessages, params)
     )
   }
 
   res = res.concat(
     await ctx.with('get-space-collabtxes', {}, (ctx) =>
-      getSpaceCollabTxes(ctx, control, doc, tx, originTx, activityMessages, cache)
+      getSpaceCollabTxes(ctx, control, doc, tx, activityMessages, cache)
     )
   )
   res = res.concat(
@@ -1726,23 +1707,29 @@ export async function createCollaboratorNotifications (
   control: TriggerControl,
   activityMessages: ActivityMessage[],
   originTx?: TxCUD<Doc>,
-  cache: Map<Ref<Doc>, Doc> = new Map<Ref<Doc>, Doc>()
+  cache: Map<Ref<Doc>, Doc> = new Map<Ref<Doc>, Doc>(),
+  ignoreCollection: boolean = false
 ): Promise<Tx[]> {
   if (tx.space === core.space.DerivedTx) {
     // do not forgot update collaborators for derived  tx
-    return await ctx.with('updateDerivedCollaborators', {}, (ctx) =>
-      updateCollaborators(ctx, control, TxProcessor.extractTx(tx) as TxCUD<Doc>, cache)
-    )
+    return await ctx.with('updateDerivedCollaborators', {}, (ctx) => updateCollaborators(ctx, control, tx, cache))
   }
 
   if (activityMessages.length === 0) {
     return []
   }
 
+  if (tx.attachedTo !== undefined && !ignoreCollection) {
+    const res = await ctx.with('collectionCollabDoc', {}, (ctx) =>
+      collectionCollabDoc(ctx, tx as TxCUD<AttachedDoc>, control, activityMessages, cache, true)
+    )
+    return await applyUserTxes(ctx, control, res)
+  }
+
   switch (tx._class) {
     case core.class.TxCreateDoc: {
       const res = await ctx.with('createCollaboratorDoc', {}, (ctx) =>
-        createCollaboratorDoc(ctx, tx as TxCreateDoc<Doc>, control, activityMessages, originTx ?? tx, cache)
+        createCollaboratorDoc(ctx, tx as TxCreateDoc<Doc>, control, activityMessages, cache)
       )
 
       return await applyUserTxes(ctx, control, res)
@@ -1759,12 +1746,6 @@ export async function createCollaboratorNotifications (
       )
       return await applyUserTxes(ctx, control, res)
     }
-    case core.class.TxCollectionCUD: {
-      const res = await ctx.with('collectionCollabDoc', {}, (ctx) =>
-        collectionCollabDoc(ctx, tx as TxCollectionCUD<Doc, AttachedDoc>, control, activityMessages, cache)
-      )
-      return await applyUserTxes(ctx, control, res)
-    }
   }
 
   return []
@@ -1872,11 +1853,10 @@ async function OnActivityMessageRemove (message: ActivityMessage, control: Trigg
 async function OnEmployeeDeactivate (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx)
-    if (core.class.TxMixin !== actualTx._class) {
+    const ctx = tx as TxMixin<Person, Employee>
+    if (core.class.TxMixin !== ctx._class) {
       continue
     }
-    const ctx = actualTx as TxMixin<Person, Employee>
     if (ctx.mixin !== contact.mixin.Employee || ctx.attributes.active !== false) {
       continue
     }
@@ -1899,9 +1879,7 @@ async function OnEmployeeDeactivate (txes: TxCUD<Doc>[], control: TriggerControl
 }
 
 async function OnDocRemove (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
-  const ltxes = txes
-    .map((it) => TxProcessor.extractTx(it))
-    .filter((it) => it._class === core.class.TxRemoveDoc) as TxRemoveDoc<Doc>[]
+  const ltxes = txes.filter((it) => it._class === core.class.TxRemoveDoc) as TxRemoveDoc<Doc>[]
   const res: Tx[] = []
   for (const tx of ltxes) {
     if (control.hierarchy.isDerived(tx.objectClass, activity.class.ActivityMessage)) {
diff --git a/server-plugins/notification-resources/src/utils.ts b/server-plugins/notification-resources/src/utils.ts
index 54a61e0f3c..e95a5733a0 100644
--- a/server-plugins/notification-resources/src/utils.ts
+++ b/server-plugins/notification-resources/src/utils.ts
@@ -31,11 +31,8 @@ import core, {
   Space,
   toIdMap,
   Tx,
-  TxCreateDoc,
   TxCUD,
   TxMixin,
-  TxProcessor,
-  TxRemoveDoc,
   TxUpdateDoc,
   type IdMap,
   type MeasureContext,
@@ -187,7 +184,6 @@ export function isAllowed (
 export async function isShouldNotifyTx (
   control: TriggerControl,
   tx: TxCUD<Doc>,
-  originTx: TxCUD<Doc>,
   object: Doc,
   user: PersonAccount[],
   isOwn: boolean,
@@ -195,7 +191,7 @@ export async function isShouldNotifyTx (
   notificationControl: NotificationProviderControl,
   docUpdateMessage?: DocUpdateMessage
 ): Promise<NotifyResult> {
-  const types = getMatchedTypes(control, tx, originTx, isOwn, isSpace, docUpdateMessage?.attributeUpdates?.attrKey)
+  const types = getMatchedTypes(control, tx, isOwn, isSpace, docUpdateMessage?.attributeUpdates?.attrKey)
   const modifiedAccount = getPersonAccountById(tx.modifiedBy, control)
   const result = new Map<Ref<NotificationProvider>, BaseNotificationType[]>()
   let providers: NotificationProvider[] = control.modelDb.findAllSync(notification.class.NotificationProvider, {})
@@ -243,7 +239,6 @@ export async function isShouldNotifyTx (
 function getMatchedTypes (
   control: TriggerControl,
   tx: TxCUD<Doc>,
-  originTx: TxCUD<Doc>,
   isOwn: boolean,
   isSpace: boolean,
   field?: string
@@ -253,7 +248,7 @@ function getMatchedTypes (
     .filter((p) => (isSpace ? p.spaceSubscribe === true : p.spaceSubscribe !== true))
   const filtered: NotificationType[] = []
   for (const type of allTypes) {
-    if (isTypeMatched(control, type, tx, originTx, isOwn)) {
+    if (isTypeMatched(control, type, tx, isOwn)) {
       filtered.push(type)
     }
   }
@@ -261,20 +256,14 @@ function getMatchedTypes (
   return filtered
 }
 
-function isTypeMatched (
-  control: TriggerControl,
-  type: NotificationType,
-  tx: TxCUD<Doc>,
-  originTx: TxCUD<Doc>,
-  isOwn: boolean
-): boolean {
+function isTypeMatched (control: TriggerControl, type: NotificationType, tx: TxCUD<Doc>, isOwn: boolean): boolean {
   const h = control.hierarchy
   const targetClass = h.getBaseClass(type.objectClass)
   if (type.onlyOwn === true && !isOwn) return false
   if (!type.txClasses.includes(tx._class)) return false
   if (!control.hierarchy.isDerived(h.getBaseClass(tx.objectClass), targetClass)) return false
-  if (originTx._class === core.class.TxCollectionCUD && type.attachedToClass !== undefined) {
-    if (!control.hierarchy.isDerived(h.getBaseClass(originTx.objectClass), h.getBaseClass(type.attachedToClass))) {
+  if (tx.attachedToClass !== undefined && type.attachedToClass !== undefined) {
+    if (!control.hierarchy.isDerived(h.getBaseClass(tx.attachedToClass), h.getBaseClass(type.attachedToClass))) {
       return false
     }
   }
@@ -370,12 +359,10 @@ async function getFallbackNotificationFullfillment (
     intlParams.title = await textPresenterFunc(object, control)
   }
 
-  const tx = TxProcessor.extractTx(originTx)
-
   intlParams.senderName = await getSenderName(control, sender)
 
-  if (tx._class === core.class.TxUpdateDoc) {
-    const updateTx = tx as TxUpdateDoc<Doc>
+  if (originTx._class === core.class.TxUpdateDoc) {
+    const updateTx = originTx as TxUpdateDoc<Doc>
     const attributes = control.hierarchy.getAllAttributes(object._class)
     for (const attrName in updateTx.operations) {
       if (!Object.prototype.hasOwnProperty.call(updateTx.operations, attrName)) {
@@ -394,18 +381,16 @@ async function getFallbackNotificationFullfillment (
       }
       break
     }
-  } else if (originTx._class === core.class.TxCollectionCUD && tx._class === core.class.TxCreateDoc) {
-    const createTx = tx as TxCreateDoc<Doc>
-    const clazz = control.hierarchy.getClass(createTx.objectClass)
+  } else if (originTx.attachedToClass !== undefined && originTx._class === core.class.TxCreateDoc) {
+    const clazz = control.hierarchy.getClass(originTx.objectClass)
     const label = clazz.pluralLabel ?? clazz.label
 
     if (label !== undefined) {
       intlParamsNotLocalized.collection = clazz.pluralLabel ?? clazz.label
       body = notification.string.CommonNotificationCollectionAdded
     }
-  } else if (originTx._class === core.class.TxCollectionCUD && tx._class === core.class.TxRemoveDoc) {
-    const createTx = tx as TxRemoveDoc<Doc>
-    const clazz = control.hierarchy.getClass(createTx.objectClass)
+  } else if (originTx.attachedToClass !== undefined && originTx._class === core.class.TxRemoveDoc) {
+    const clazz = control.hierarchy.getClass(originTx.objectClass)
     const label = clazz.pluralLabel ?? clazz.label
 
     if (label !== undefined) {
@@ -437,8 +422,7 @@ export async function getNotificationContent (
 
   let data: Markup | undefined
 
-  const actualTx = TxProcessor.extractTx(originTx) as TxCUD<Doc>
-  const notificationPresenter = getNotificationPresenter(actualTx.objectClass, control.hierarchy)
+  const notificationPresenter = getNotificationPresenter(originTx.objectClass, control.hierarchy)
 
   if (notificationPresenter !== undefined) {
     const getFuillfillmentParams = await getResource(notificationPresenter.presenter)
diff --git a/server-plugins/recruit-resources/src/index.ts b/server-plugins/recruit-resources/src/index.ts
index 23fe554d0e..fe49f00866 100644
--- a/server-plugins/recruit-resources/src/index.ts
+++ b/server-plugins/recruit-resources/src/index.ts
@@ -87,7 +87,7 @@ export async function applicationTextPresenter (doc: Doc, control: TriggerContro
 export async function OnRecruitUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
+    const actualTx = tx as TxCUD<Doc>
     if (!control.hierarchy.isDerived(actualTx.objectClass, recruit.class.Vacancy)) {
       continue
     }
diff --git a/server-plugins/request-resources/src/index.ts b/server-plugins/request-resources/src/index.ts
index ac49558514..4c06b8a7c6 100644
--- a/server-plugins/request-resources/src/index.ts
+++ b/server-plugins/request-resources/src/index.ts
@@ -20,7 +20,6 @@ import core, {
   Ref,
   Tx,
   TxCUD,
-  TxCollectionCUD,
   TxCreateDoc,
   TxProcessor,
   TxUpdateDoc,
@@ -43,27 +42,24 @@ import {
 /**
  * @public
  */
-export async function OnRequest (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
+export async function OnRequest (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const hierarchy = control.hierarchy
-  const ltxes = (
-    txes.filter((it) => it._class === core.class.TxCollectionCUD) as TxCollectionCUD<Doc, Request>[]
-  ).filter((it) => hierarchy.isDerived(it.tx.objectClass, request.class.Request))
+  const ltxes = txes.filter((it) => hierarchy.isDerived(it.objectClass, request.class.Request))
 
   let res: Tx[] = []
 
   for (const ptx of ltxes) {
-    res = res.concat(await getRequestNotificationTx(control.ctx, ptx, control))
+    res = res.concat(await getRequestNotificationTx(control.ctx, ptx as TxCUD<Request>, control))
 
-    if (ptx.tx._class === core.class.TxUpdateDoc) {
-      res = res.concat(await OnRequestUpdate(ptx, control))
+    if (ptx._class === core.class.TxUpdateDoc) {
+      res = res.concat(await OnRequestUpdate(ptx as TxUpdateDoc<Request>, control))
     }
   }
 
   return res
 }
 
-async function OnRequestUpdate (tx: TxCollectionCUD<Doc, Request>, control: TriggerControl): Promise<Tx[]> {
-  const ctx = tx.tx as TxUpdateDoc<Request>
+async function OnRequestUpdate (ctx: TxUpdateDoc<Request>, control: TriggerControl): Promise<Tx[]> {
   const applyTxes: Tx[] = []
 
   if (ctx.operations.$push?.approved !== undefined) {
@@ -75,9 +71,9 @@ async function OnRequestUpdate (tx: TxCollectionCUD<Doc, Request>, control: Trig
       })
       collectionTx.space = core.space.Tx
       const resTx = control.txFactory.createTxCollectionCUD(
-        tx.objectClass,
-        tx.objectId,
-        tx.objectSpace,
+        ctx.attachedToClass ?? ctx.objectClass,
+        ctx.attachedTo ?? ctx.objectId,
+        ctx.objectSpace,
         'requests',
         collectionTx
       )
@@ -88,9 +84,9 @@ async function OnRequestUpdate (tx: TxCollectionCUD<Doc, Request>, control: Trig
     }
 
     const approvedDateTx = control.txFactory.createTxCollectionCUD(
-      tx.objectClass,
-      tx.objectId,
-      tx.objectSpace,
+      ctx.attachedToClass ?? ctx.objectClass,
+      ctx.attachedTo ?? ctx.objectId,
+      ctx.objectSpace,
       'requests',
       control.txFactory.createTxUpdateDoc(ctx.objectClass, ctx.objectSpace, ctx.objectId, {
         $push: { approvedDates: Date.now() }
@@ -130,14 +126,15 @@ async function getRequest (tx: TxCUD<Request>, control: TriggerControl): Promise
 // We need request-specific logic to attach a activity message on request create/update to parent, but use request collaborators for notifications
 async function getRequestNotificationTx (
   ctx: MeasureContext,
-  tx: TxCollectionCUD<Doc, Request>,
+  tx: TxCUD<Request>,
   control: TriggerControl
 ): Promise<Tx[]> {
-  const request = await getRequest(tx.tx, control)
+  if (tx.attachedToClass === undefined || tx.attachedTo === undefined) return []
+  const request = await getRequest(tx, control)
 
   if (request === undefined) return []
 
-  const doc = (await control.findAll(control.ctx, tx.objectClass, { _id: tx.objectId }, { limit: 1 }))[0]
+  const doc = (await control.findAll(control.ctx, tx.attachedToClass, { _id: tx.attachedTo }, { limit: 1 }))[0]
 
   if (doc === undefined) return []
 
@@ -149,9 +146,9 @@ async function getRequestNotificationTx (
   res.push(...messagesTxes)
 
   const messages = messagesTxes.map((messageTx) =>
-    TxProcessor.createDoc2Doc(messageTx.tx as TxCreateDoc<DocUpdateMessage>)
+    TxProcessor.createDoc2Doc(messageTx as TxCreateDoc<DocUpdateMessage>)
   )
-  const collaborators = await getCollaborators(control.ctx, request, control, tx.tx, res)
+  const collaborators = await getCollaborators(control.ctx, request, control, tx, res)
 
   if (collaborators.length === 0) return res
 
@@ -176,7 +173,6 @@ async function getRequestNotificationTx (
       ctx,
       control,
       request,
-      tx.tx,
       tx,
       targetInfo,
       senderInfo,
diff --git a/server-plugins/setting-resources/src/index.ts b/server-plugins/setting-resources/src/index.ts
index 78e2e459fd..1175d1b544 100644
--- a/server-plugins/setting-resources/src/index.ts
+++ b/server-plugins/setting-resources/src/index.ts
@@ -14,7 +14,7 @@
 //
 
 import contact, { Person, PersonAccount, getFirstName, getLastName } from '@hcengineering/contact'
-import core, { Account, Doc, Ref, Role, Tx, TxProcessor, TxUpdateDoc } from '@hcengineering/core'
+import core, { Account, Doc, Ref, Role, Tx, TxUpdateDoc } from '@hcengineering/core'
 import { getEmbeddedLabel, translate } from '@hcengineering/platform'
 import type { TriggerControl } from '@hcengineering/server-core'
 import setting, { Integration } from '@hcengineering/setting'
@@ -95,9 +95,7 @@ export async function getOwnerPosition (
 export async function OnRoleNameUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx)
-    const updateTx = actualTx as TxUpdateDoc<Role>
-
+    const updateTx = tx as TxUpdateDoc<Role>
     if (updateTx.operations?.name === undefined) {
       continue
     }
diff --git a/server-plugins/tags-resources/src/index.ts b/server-plugins/tags-resources/src/index.ts
index 415e69a3c9..1d875ab3df 100644
--- a/server-plugins/tags-resources/src/index.ts
+++ b/server-plugins/tags-resources/src/index.ts
@@ -51,8 +51,7 @@ export async function TagElementRemove (
  */
 export async function OnTagReference (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
-  for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx)
+  for (const actualTx of txes) {
     const isCreate = control.hierarchy.isDerived(actualTx._class, core.class.TxCreateDoc)
     const isRemove = control.hierarchy.isDerived(actualTx._class, core.class.TxRemoveDoc)
     if (!isCreate && !isRemove) {
@@ -63,11 +62,10 @@ export async function OnTagReference (txes: Tx[], control: TriggerControl): Prom
     }
     if (isCreate) {
       const doc = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<TagReference>)
-      result.push(
-        control.txFactory.createTxUpdateDoc(tags.class.TagElement, core.space.Workspace, doc.tag, {
-          $inc: { refCount: 1 }
-        })
-      )
+      const res = control.txFactory.createTxUpdateDoc(tags.class.TagElement, core.space.Workspace, doc.tag, {
+        $inc: { refCount: 1 }
+      })
+      result.push(res)
     }
     if (isRemove) {
       const ctx = actualTx as TxRemoveDoc<TagReference>
diff --git a/server-plugins/task-resources/src/index.ts b/server-plugins/task-resources/src/index.ts
index 51eb215697..2f5943a6db 100644
--- a/server-plugins/task-resources/src/index.ts
+++ b/server-plugins/task-resources/src/index.ts
@@ -20,13 +20,10 @@ import task, { Task } from '@hcengineering/task'
 /**
  * @public
  */
-export async function OnStateUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
+export async function OnStateUpdate (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
-  for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-    if (!control.hierarchy.isDerived(actualTx.objectClass, task.class.Task)) {
-      continue
-    }
+  for (const actualTx of txes) {
+    if (!control.hierarchy.isDerived(actualTx.objectClass, task.class.Task)) continue
     if (actualTx._class === core.class.TxCreateDoc) {
       const doc = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<Task>)
       const status = control.modelDb.findAllSync(core.class.Status, { _id: doc.status })[0]
diff --git a/server-plugins/telegram-resources/src/index.ts b/server-plugins/telegram-resources/src/index.ts
index efde2ae8d8..7179cd2ca0 100644
--- a/server-plugins/telegram-resources/src/index.ts
+++ b/server-plugins/telegram-resources/src/index.ts
@@ -105,7 +105,7 @@ export function IsIncomingMessageTypeMatch (
   type: NotificationType,
   control: TriggerControl
 ): boolean {
-  const message = TxProcessor.createDoc2Doc(TxProcessor.extractTx(tx) as TxCreateDoc<TelegramMessage>)
+  const message = TxProcessor.createDoc2Doc(tx as TxCreateDoc<TelegramMessage>)
   return message.incoming && message.sendOn > (doc.createdOn ?? doc.modifiedOn)
 }
 
diff --git a/server-plugins/time-resources/src/index.ts b/server-plugins/time-resources/src/index.ts
index f97c857472..b502e6d49f 100644
--- a/server-plugins/time-resources/src/index.ts
+++ b/server-plugins/time-resources/src/index.ts
@@ -50,20 +50,19 @@ import tracker, { Issue, IssueStatus, Project, TimeSpendReport } from '@hcengine
 /**
  * @public
  */
-export async function OnTask (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
+export async function OnTask (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<Doc>
     const mixin = control.hierarchy.classHierarchyMixin<Class<Doc>, ToDoFactory>(
-      actualTx.objectClass,
+      tx.objectClass,
       serverTime.mixin.ToDoFactory
     )
     if (mixin !== undefined) {
-      if (actualTx._class !== core.class.TxRemoveDoc) {
+      if (tx._class !== core.class.TxRemoveDoc) {
         const factory = await getResource(mixin.factory)
         result.push(...(await factory(tx, control)))
       } else {
-        const todos = await control.findAll(control.ctx, time.class.ToDo, { attachedTo: actualTx.objectId })
+        const todos = await control.findAll(control.ctx, time.class.ToDo, { attachedTo: tx.objectId })
         result.push(...todos.map((p) => control.txFactory.createTxRemoveDoc(p._class, p.space, p._id)))
       }
     }
@@ -75,7 +74,7 @@ export async function OnTask (txes: Tx[], control: TriggerControl): Promise<Tx[]
 export async function OnWorkSlotUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<WorkSlot>
+    const actualTx = tx as TxCUD<WorkSlot>
     if (!control.hierarchy.isDerived(actualTx.objectClass, time.class.WorkSlot)) {
       continue
     }
@@ -100,7 +99,7 @@ export async function OnWorkSlotUpdate (txes: Tx[], control: TriggerControl): Pr
 
 export async function OnWorkSlotCreate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<WorkSlot>
+    const actualTx = tx as TxCUD<WorkSlot>
     if (!control.hierarchy.isDerived(actualTx.objectClass, time.class.WorkSlot)) {
       continue
     }
@@ -163,7 +162,7 @@ export async function OnWorkSlotCreate (txes: Tx[], control: TriggerControl): Pr
 
 export async function OnToDoRemove (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<ToDo>
+    const actualTx = tx as TxCUD<ToDo>
     if (!control.hierarchy.isDerived(actualTx.objectClass, time.class.ToDo)) {
       continue
     }
@@ -227,7 +226,7 @@ export async function OnToDoRemove (txes: Tx[], control: TriggerControl): Promis
 export async function OnToDoCreate (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const hierarchy = control.hierarchy
   for (const tx of txes) {
-    const createTx = TxProcessor.extractTx(tx) as TxCreateDoc<ToDo>
+    const createTx = tx as TxCreateDoc<ToDo>
 
     if (!hierarchy.isDerived(createTx.objectClass, time.class.ToDo)) {
       continue
@@ -298,7 +297,7 @@ export async function OnToDoCreate (txes: TxCUD<Doc>[], control: TriggerControl)
       person: senderPerson
     }
     const notificationControl = await getNotificationProviderControl(control.ctx, control)
-    const notifyResult = await isShouldNotifyTx(control, createTx, tx, todo, account, true, false, notificationControl)
+    const notifyResult = await isShouldNotifyTx(control, createTx, todo, account, true, false, notificationControl)
     const content = await getNotificationContent(tx, account, senderInfo, todo, control)
     const data: Partial<Data<CommonInboxNotification>> = {
       ...content,
@@ -343,7 +342,7 @@ export async function OnToDoCreate (txes: TxCUD<Doc>[], control: TriggerControl)
 export async function OnToDoUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx) as TxCUD<ToDo>
+    const actualTx = tx as TxCUD<ToDo>
     if (!control.hierarchy.isDerived(actualTx.objectClass, time.class.ToDo)) {
       continue
     }
@@ -445,8 +444,7 @@ export async function OnToDoUpdate (txes: Tx[], control: TriggerControl): Promis
 /**
  * @public
  */
-export async function IssueToDoFactory (tx: Tx, control: TriggerControl): Promise<Tx[]> {
-  const actualTx = TxProcessor.extractTx(tx) as TxCUD<Issue>
+export async function IssueToDoFactory (actualTx: TxCUD<Issue>, control: TriggerControl): Promise<Tx[]> {
   if (!control.hierarchy.isDerived(actualTx.objectClass, tracker.class.Issue)) return []
   if (control.hierarchy.isDerived(actualTx._class, core.class.TxCreateDoc)) {
     const issue = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<Issue>)
diff --git a/server-plugins/tracker-resources/src/index.ts b/server-plugins/tracker-resources/src/index.ts
index 6b2660ef69..eb6fcf9df2 100644
--- a/server-plugins/tracker-resources/src/index.ts
+++ b/server-plugins/tracker-resources/src/index.ts
@@ -18,14 +18,12 @@ import { Person, PersonAccount } from '@hcengineering/contact'
 import core, {
   Account,
   AccountRole,
-  AttachedDoc,
   concatLink,
   Doc,
   DocumentUpdate,
   Ref,
   Space,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
   TxCUD,
   TxProcessor,
@@ -107,44 +105,40 @@ export async function getIssueNotificationContent (
   }
   const intlParamsNotLocalized: Record<string, IntlString> = {}
 
-  if (tx._class === core.class.TxCollectionCUD) {
-    const ptx = tx as TxCollectionCUD<Doc, AttachedDoc>
+  if (tx._class === core.class.TxCreateDoc) {
+    if (tx.objectClass === chunter.class.ChatMessage) {
+      const createTx = tx as TxCreateDoc<ChatMessage>
+      const message = createTx.attributes.message
+      const plainTextMessage = stripTags(message, NOTIFICATION_BODY_SIZE)
+      intlParams.message = plainTextMessage
+    }
+  } else if (tx._class === core.class.TxUpdateDoc) {
+    const updateTx = tx as TxUpdateDoc<Issue>
 
-    if (ptx.tx._class === core.class.TxCreateDoc) {
-      if (ptx.tx.objectClass === chunter.class.ChatMessage) {
-        const createTx = ptx.tx as TxCreateDoc<ChatMessage>
-        const message = createTx.attributes.message
-        const plainTextMessage = stripTags(message, NOTIFICATION_BODY_SIZE)
-        intlParams.message = plainTextMessage
-      }
-    } else if (ptx.tx._class === core.class.TxUpdateDoc) {
-      const updateTx = ptx.tx as TxUpdateDoc<Issue>
-
-      if (
-        updateTx.operations.assignee !== null &&
-        updateTx.operations.assignee !== undefined &&
-        isSamePerson(control, updateTx.operations.assignee, target)
-      ) {
-        body = tracker.string.IssueAssigneedToYou
-      } else {
-        const attributes = control.hierarchy.getAllAttributes(doc._class)
-        for (const attrName in updateTx.operations) {
-          if (!Object.prototype.hasOwnProperty.call(updateTx.operations, attrName)) {
-            continue
-          }
-
-          const attr = attributes.get(attrName)
-          if (attr !== null && attr !== undefined) {
-            intlParamsNotLocalized.property = attr.label
-            if (attr.type._class === core.class.TypeString) {
-              body = tracker.string.IssueNotificationChangedProperty
-              intlParams.newValue = (issue as any)[attr.name]?.toString()
-            } else {
-              body = tracker.string.IssueNotificationChanged
-            }
-          }
-          break
+    if (
+      updateTx.operations.assignee !== null &&
+      updateTx.operations.assignee !== undefined &&
+      isSamePerson(control, updateTx.operations.assignee, target)
+    ) {
+      body = tracker.string.IssueAssigneedToYou
+    } else {
+      const attributes = control.hierarchy.getAllAttributes(doc._class)
+      for (const attrName in updateTx.operations) {
+        if (!Object.prototype.hasOwnProperty.call(updateTx.operations, attrName)) {
+          continue
         }
+
+        const attr = attributes.get(attrName)
+        if (attr !== null && attr !== undefined) {
+          intlParamsNotLocalized.property = attr.label
+          if (attr.type._class === core.class.TypeString) {
+            body = tracker.string.IssueNotificationChangedProperty
+            intlParams.newValue = (issue as any)[attr.name]?.toString()
+          } else {
+            body = tracker.string.IssueNotificationChanged
+          }
+        }
+        break
       }
     }
   }
@@ -163,7 +157,7 @@ export async function getIssueNotificationContent (
 export async function OnComponentRemove (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
-    const ctx = TxProcessor.extractTx(tx) as TxRemoveDoc<Component>
+    const ctx = tx as TxRemoveDoc<Component>
 
     const issues = await control.findAll(control.ctx, tracker.class.Issue, {
       component: ctx.objectId
@@ -238,9 +232,7 @@ export async function OnWorkspaceOwnerAdded (txes: Tx[], control: TriggerControl
  */
 export async function OnIssueUpdate (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
-  for (const tx of txes) {
-    const actualTx = TxProcessor.extractTx(tx)
-
+  for (const actualTx of txes) {
     // Check TimeReport operations
     if (
       actualTx._class === core.class.TxCreateDoc ||
@@ -249,7 +241,7 @@ export async function OnIssueUpdate (txes: Tx[], control: TriggerControl): Promi
     ) {
       const cud = actualTx as TxCUD<TimeSpendReport>
       if (cud.objectClass === tracker.class.TimeSpendReport) {
-        result.push(...(await doTimeReportUpdate(cud, tx, control)))
+        result.push(...(await doTimeReportUpdate(cud, control)))
       }
     }
 
@@ -265,7 +257,7 @@ export async function OnIssueUpdate (txes: Tx[], control: TriggerControl): Promi
     if (actualTx._class === core.class.TxUpdateDoc) {
       const updateTx = actualTx as TxUpdateDoc<Issue>
       if (control.hierarchy.isDerived(updateTx.objectClass, tracker.class.Issue)) {
-        result.push(...(await doIssueUpdate(updateTx, control, tx as TxCollectionCUD<Issue, AttachedDoc>)))
+        result.push(...(await doIssueUpdate(updateTx, control)))
         continue
       }
     }
@@ -299,22 +291,21 @@ export async function OnIssueUpdate (txes: Tx[], control: TriggerControl): Promi
   return result
 }
 
-async function doTimeReportUpdate (cud: TxCUD<TimeSpendReport>, tx: Tx, control: TriggerControl): Promise<Tx[]> {
-  const parentTx = tx as TxCollectionCUD<Issue, TimeSpendReport>
+async function doTimeReportUpdate (cud: TxCUD<TimeSpendReport>, control: TriggerControl): Promise<Tx[]> {
+  const { attachedTo: attachedToId, attachedToClass } = cud
+  if (attachedToClass === undefined || attachedToId === undefined) {
+    return []
+  }
+  const attachedTo = attachedToId as Ref<Issue>
   switch (cud._class) {
     case core.class.TxCreateDoc: {
       const ccud = cud as TxCreateDoc<TimeSpendReport>
-      const [currentIssue] = await control.findAll(
-        control.ctx,
-        tracker.class.Issue,
-        { _id: parentTx.objectId },
-        { limit: 1 }
-      )
+      const [currentIssue] = await control.findAll(control.ctx, tracker.class.Issue, { _id: attachedTo }, { limit: 1 })
       const res = [
         control.txFactory.createTxUpdateDoc<Issue>(
-          parentTx.objectClass,
-          parentTx.objectSpace,
-          parentTx.objectId,
+          attachedToClass,
+          cud.objectSpace,
+          attachedTo,
           {
             $inc: { reportedTime: ccud.attributes.value }
           },
@@ -331,28 +322,25 @@ async function doTimeReportUpdate (cud: TxCUD<TimeSpendReport>, tx: Tx, control:
       const upd = cud as TxUpdateDoc<TimeSpendReport>
       if (upd.operations.value !== undefined) {
         const logTxes = Array.from(
-          await control.findAll(control.ctx, core.class.TxCollectionCUD, {
-            'tx.objectId': cud.objectId
+          await control.findAll(control.ctx, core.class.TxCUD, {
+            objectId: cud.objectId
           })
-        )
-          .filter((it) => it._id !== parentTx._id)
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          .map(TxProcessor.extractTx)
+        ).filter((it) => it._id !== cud._id)
         const doc: TimeSpendReport | undefined = TxProcessor.buildDoc2Doc(logTxes)
 
         const res: Tx[] = []
         const [currentIssue] = await control.findAll(
           control.ctx,
           tracker.class.Issue,
-          { _id: parentTx.objectId },
+          { _id: attachedTo },
           { limit: 1 }
         )
         if (doc !== undefined) {
           res.push(
             control.txFactory.createTxUpdateDoc<Issue>(
-              parentTx.objectClass,
-              parentTx.objectSpace,
-              parentTx.objectId,
+              attachedToClass,
+              cud.objectSpace,
+              attachedTo,
               {
                 $inc: { reportedTime: upd.operations.value - doc.value }
               },
@@ -371,28 +359,25 @@ async function doTimeReportUpdate (cud: TxCUD<TimeSpendReport>, tx: Tx, control:
       break
     }
     case core.class.TxRemoveDoc: {
-      if (!control.removedMap.has(parentTx.objectId)) {
+      if (!control.removedMap.has(attachedTo)) {
         const logTxes = Array.from(
-          await control.findAll(control.ctx, core.class.TxCollectionCUD, {
-            'tx.objectId': cud.objectId
+          await control.findAll(control.ctx, core.class.TxCUD, {
+            objectId: cud.objectId
           })
-        )
-          .filter((it) => it._id !== parentTx._id)
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          .map(TxProcessor.extractTx)
+        ).filter((it) => it._id !== cud._id)
         const doc: TimeSpendReport | undefined = TxProcessor.buildDoc2Doc(logTxes)
         if (doc !== undefined) {
           const [currentIssue] = await control.findAll(
             control.ctx,
             tracker.class.Issue,
-            { _id: parentTx.objectId },
+            { _id: attachedTo },
             { limit: 1 }
           )
           const res = [
             control.txFactory.createTxUpdateDoc<Issue>(
-              parentTx.objectClass,
-              parentTx.objectSpace,
-              parentTx.objectId,
+              attachedToClass,
+              cud.objectSpace,
+              attachedTo,
               {
                 $inc: { reportedTime: -1 * doc.value }
               },
@@ -411,11 +396,7 @@ async function doTimeReportUpdate (cud: TxCUD<TimeSpendReport>, tx: Tx, control:
   return []
 }
 
-async function doIssueUpdate (
-  updateTx: TxUpdateDoc<Issue>,
-  control: TriggerControl,
-  tx: TxCollectionCUD<Issue, AttachedDoc>
-): Promise<Tx[]> {
+async function doIssueUpdate (updateTx: TxUpdateDoc<Issue>, control: TriggerControl): Promise<Tx[]> {
   const res: Tx[] = []
 
   let currentIssue: WithLookup<Issue> | undefined
diff --git a/server/backup/src/backup.ts b/server/backup/src/backup.ts
index 6959ded269..070361edef 100644
--- a/server/backup/src/backup.ts
+++ b/server/backup/src/backup.ts
@@ -16,7 +16,6 @@
 
 import { Analytics } from '@hcengineering/analytics'
 import core, {
-  AttachedDoc,
   BackupClient,
   Client as CoreClient,
   Doc,
@@ -32,7 +31,6 @@ import core, {
   Ref,
   SortingOrder,
   systemAccountEmail,
-  TxCollectionCUD,
   WorkspaceId,
   type BackupStatus,
   type Blob,
@@ -525,7 +523,7 @@ export async function cloneWorkspace (
               try {
                 docs = await ctx.with('load-docs', {}, (ctx) => sourceConnection.loadDocs(c, needRetrieve))
                 if (clearTime) {
-                  docs = prepareClonedDocuments(docs, sourceConnection)
+                  docs = prepareClonedDocuments(docs)
                 }
                 const executor = new RateLimiter(10)
                 for (const d of docs) {
@@ -593,37 +591,17 @@ export async function cloneWorkspace (
   )
 }
 
-function prepareClonedDocuments (docs: Doc[], sourceConnection: CoreClient & BackupClient): Doc[] {
+function prepareClonedDocuments (docs: Doc[]): Doc[] {
   docs = docs.map((p) => {
-    let collectionCud = false
-    try {
-      collectionCud = sourceConnection.getHierarchy().isDerived(p._class, core.class.TxCollectionCUD)
-    } catch (err: any) {
-      console.log(err)
-    }
-
     // if full text is skipped, we need to clean stages for indexes.
     if (p._class === core.class.DocIndexState) {
       ;(p as DocIndexState).needIndex = true
     }
 
-    if (collectionCud) {
-      return {
-        ...p,
-        modifiedOn: Date.now(),
-        createdOn: Date.now(),
-        tx: {
-          ...(p as TxCollectionCUD<Doc, AttachedDoc>).tx,
-          modifiedOn: Date.now(),
-          createdOn: Date.now()
-        }
-      }
-    } else {
-      return {
-        ...p,
-        modifiedOn: Date.now(),
-        createdOn: Date.now()
-      }
+    return {
+      ...p,
+      modifiedOn: Date.now(),
+      createdOn: Date.now()
     }
   })
   return docs
diff --git a/server/core/src/triggers.ts b/server/core/src/triggers.ts
index 1b707323c1..d4be68e058 100644
--- a/server/core/src/triggers.ts
+++ b/server/core/src/triggers.ts
@@ -137,7 +137,7 @@ export class Triggers {
       let matches = tx
       if (query !== undefined) {
         this.addDerived(query, 'objectClass')
-        this.addDerived(query, 'tx.objectClass')
+        this.addDerived(query, 'attachedToClass')
         matches = matchQuery(tx, query, core.class.Tx, ctrl.hierarchy) as Tx[]
       }
       if (matches.length > 0) {
diff --git a/server/middleware/src/broadcast.ts b/server/middleware/src/broadcast.ts
index 278b53ac56..9e6f5f1c32 100644
--- a/server/middleware/src/broadcast.ts
+++ b/server/middleware/src/broadcast.ts
@@ -143,10 +143,10 @@ export class BroadcastMiddleware extends BaseMiddleware implements Middleware {
     for (const dtx of derived) {
       if (TxProcessor.isExtendsCUD(dtx._class)) {
         classes.add((dtx as TxCUD<Doc>).objectClass)
-      }
-      const etx = TxProcessor.extractTx(dtx)
-      if (TxProcessor.isExtendsCUD(etx._class)) {
-        classes.add((etx as TxCUD<Doc>).objectClass)
+        const attachedToClass = (dtx as TxCUD<Doc>).attachedToClass
+        if (attachedToClass !== undefined) {
+          classes.add(attachedToClass)
+        }
       }
     }
     const bevent = createBroadcastEvent(Array.from(classes))
diff --git a/server/middleware/src/domainTx.ts b/server/middleware/src/domainTx.ts
index 1bde9158c1..66d339760e 100644
--- a/server/middleware/src/domainTx.ts
+++ b/server/middleware/src/domainTx.ts
@@ -120,7 +120,7 @@ export class DomainTxMiddleware extends BaseMiddleware implements Middleware {
 
     const domains = new Set<Domain>()
     for (const tx of txes) {
-      const txCUD = TxProcessor.extractTx(tx) as TxCUD<Doc>
+      const txCUD = tx as TxCUD<Doc>
       if (!TxProcessor.isExtendsCUD(txCUD._class)) {
         // Skip unsupported tx
         ctx.error('Unsupported transaction', tx)
diff --git a/server/middleware/src/modified.ts b/server/middleware/src/modified.ts
index 95b6f4c119..90d7207891 100644
--- a/server/middleware/src/modified.ts
+++ b/server/middleware/src/modified.ts
@@ -13,7 +13,7 @@
 // limitations under the License.
 //
 
-import core, { MeasureContext, Tx, TxCollectionCUD, systemAccountEmail, type SessionData } from '@hcengineering/core'
+import core, { MeasureContext, Tx, systemAccountEmail, type SessionData } from '@hcengineering/core'
 import { BaseMiddleware, Middleware, TxMiddlewareResult, type PipelineContext } from '@hcengineering/server-core'
 
 /**
@@ -37,9 +37,6 @@ export class ModifiedMiddleware extends BaseMiddleware implements Middleware {
       if (tx.modifiedBy !== core.account.System && ctx.contextData.userEmail !== systemAccountEmail) {
         tx.modifiedOn = Date.now()
         tx.createdOn = tx.createdOn ?? tx.modifiedOn
-        if (tx._class === core.class.TxCollectionCUD) {
-          ;(tx as TxCollectionCUD<any, any>).tx.modifiedOn = tx.modifiedOn
-        }
       }
     }
     return this.provideTx(ctx, txes)
diff --git a/server/middleware/src/spacePermissions.ts b/server/middleware/src/spacePermissions.ts
index 33d55fcd15..7f3584d7f9 100644
--- a/server/middleware/src/spacePermissions.ts
+++ b/server/middleware/src/spacePermissions.ts
@@ -14,7 +14,6 @@
 //
 import core, {
   Account,
-  AttachedDoc,
   Class,
   Doc,
   Permission,
@@ -26,7 +25,6 @@ import core, {
   Tx,
   TxApplyIf,
   TxCUD,
-  TxCollectionCUD,
   TxCreateDoc,
   TxMixin,
   TxProcessor,
@@ -245,46 +243,34 @@ export class SpacePermissionsMiddleware extends BaseMiddleware implements Middle
     return this.context.hierarchy.isDerived(tx.objectClass, core.class.Space)
   }
 
-  private isTxCollectionCUD (tx: TxCUD<Doc>): tx is TxCollectionCUD<Doc, AttachedDoc> {
-    return this.context.hierarchy.isDerived(tx._class, core.class.TxCollectionCUD)
-  }
-
   private isRoleTxCUD (tx: TxCUD<Doc>): tx is TxCUD<Role> {
     return this.context.hierarchy.isDerived(tx.objectClass, core.class.Role)
   }
 
-  private handlePermissionsUpdatesFromRoleTx (ctx: MeasureContext, tx: TxCUD<Doc>): void {
-    if (!this.isTxCollectionCUD(tx)) {
+  private handlePermissionsUpdatesFromRoleTx (ctx: MeasureContext, actualTx: TxCUD<Doc>): void {
+    if (actualTx._class !== core.class.TxUpdateDoc) {
       return
     }
 
-    const actualTx = TxProcessor.extractTx(tx)
-    if (!TxProcessor.isExtendsCUD(actualTx._class)) {
+    const targetSpaceTypeId = actualTx.attachedTo
+    if (targetSpaceTypeId === undefined) {
       return
     }
 
-    const actualCudTx = actualTx as TxCUD<Doc>
-
-    if (!this.isRoleTxCUD(actualCudTx)) {
+    if (!this.isRoleTxCUD(actualTx)) {
       return
     }
 
     // We are only interested in updates of the existing roles because:
     // When role is created it always has empty set of permissions
     // And it's not currently possible to delete a role
-
-    if (actualCudTx._class !== core.class.TxUpdateDoc) {
-      return
-    }
-
-    const updateTx = actualCudTx as TxUpdateDoc<Role>
+    const updateTx = actualTx as TxUpdateDoc<Role>
 
     if (updateTx.operations.permissions === undefined) {
       return
     }
 
     // Find affected spaces
-    const targetSpaceTypeId = tx.objectId
     const affectedSpacesIds = Object.entries(this.typeBySpace)
       .filter(([, typeId]) => typeId === targetSpaceTypeId)
       .map(([spaceId]) => spaceId) as Ref<TypedSpace>[]
@@ -360,12 +346,6 @@ export class SpacePermissionsMiddleware extends BaseMiddleware implements Middle
       return
     }
 
-    if (tx._class === core.class.TxCollectionCUD) {
-      const actualTx = TxProcessor.extractTx(tx)
-
-      this.checkPermissions(ctx, actualTx)
-    }
-
     const cudTx = tx as TxCUD<Doc>
     const h = this.context.hierarchy
     const isSpace = h.isDerived(cudTx.objectClass, core.class.Space)
diff --git a/server/middleware/src/spaceSecurity.ts b/server/middleware/src/spaceSecurity.ts
index 257219e60c..a0205408bc 100644
--- a/server/middleware/src/spaceSecurity.ts
+++ b/server/middleware/src/spaceSecurity.ts
@@ -330,8 +330,7 @@ export class SpaceSecurityMiddleware extends BaseMiddleware implements Middlewar
     return res
   }
 
-  private async processTxSpaceDomain (sctx: MeasureContext, tx: TxCUD<Doc>): Promise<void> {
-    const actualTx = TxProcessor.extractTx(tx)
+  private async processTxSpaceDomain (sctx: MeasureContext, actualTx: TxCUD<Doc>): Promise<void> {
     if (actualTx._class === core.class.TxCreateDoc) {
       const ctx = actualTx as TxCreateDoc<Doc>
       const doc = TxProcessor.createDoc2Doc(ctx)
diff --git a/server/middleware/src/triggers.ts b/server/middleware/src/triggers.ts
index 90344da64a..48188f78f9 100644
--- a/server/middleware/src/triggers.ts
+++ b/server/middleware/src/triggers.ts
@@ -28,9 +28,8 @@ import core, {
   type Ref,
   type SessionData,
   type Tx,
-  type TxCollectionCUD,
+  TxCUD,
   TxFactory,
-  TxProcessor,
   type TxRemoveDoc,
   type TxUpdateDoc,
   addOperation,
@@ -289,11 +288,10 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
     const result: Tx[] = []
 
     for (const tx of txes) {
-      const actualTx = TxProcessor.extractTx(tx)
-      if (!this.context.hierarchy.isDerived(actualTx._class, core.class.TxRemoveDoc)) {
+      if (!this.context.hierarchy.isDerived(tx._class, core.class.TxRemoveDoc)) {
         continue
       }
-      const rtx = actualTx as TxRemoveDoc<Doc>
+      const rtx = tx as TxRemoveDoc<Doc>
       const object = ctx.contextData.removedMap.get(rtx.objectId)
       if (object === undefined) {
         continue
@@ -330,18 +328,20 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
     return result
   }
 
-  private async updateCollection (ctx: MeasureContext, tx: Tx, findAll: SessionFindAll): Promise<Tx[]> {
-    if (tx._class !== core.class.TxCollectionCUD) {
+  private async updateCollection (
+    ctx: MeasureContext,
+    colTx: TxUpdateDoc<AttachedDoc>,
+    findAll: SessionFindAll
+  ): Promise<Tx[]> {
+    if (colTx.attachedTo === undefined || colTx.attachedToClass === undefined || colTx.collection === undefined) {
       return []
     }
 
-    const colTx = tx as TxCollectionCUD<Doc, AttachedDoc>
-    const _id = colTx.objectId
-    const _class = colTx.objectClass
-    const { operations } = colTx.tx as TxUpdateDoc<AttachedDoc>
+    const _id = colTx.attachedTo
+    const _class = colTx.attachedToClass
+    const { operations } = colTx
 
     if (
-      colTx.tx._class !== core.class.TxUpdateDoc ||
       this.context.hierarchy.getDomain(_class) === DOMAIN_MODEL // We could not update increments for model classes
     ) {
       return []
@@ -357,7 +357,7 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
       const attr = this.context.hierarchy.findAttribute(oldAttachedTo._class, colTx.collection)
 
       if (attr !== undefined) {
-        oldTx = this.getCollectionUpdateTx(_id, _class, tx.modifiedBy, colTx.modifiedOn, oldAttachedTo, {
+        oldTx = this.getCollectionUpdateTx(_id, _class, colTx.modifiedBy, colTx.modifiedOn, oldAttachedTo, {
           $inc: { [colTx.collection]: -1 }
         })
       }
@@ -372,7 +372,7 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
       newTx = this.getCollectionUpdateTx(
         newAttachedTo._id,
         newAttachedTo._class,
-        tx.modifiedBy,
+        colTx.modifiedBy,
         colTx.modifiedOn,
         newAttachedTo,
         { $inc: { [newAttachedToCollection]: 1 } }
@@ -389,10 +389,10 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
   ): Promise<Tx[]> {
     const result: Tx[] = []
     for (const tx of txes) {
-      if (tx._class === core.class.TxCollectionCUD) {
-        const colTx = tx as TxCollectionCUD<Doc, AttachedDoc>
-        const _id = colTx.objectId
-        const _class = colTx.objectClass
+      const colTx = tx as TxCUD<AttachedDoc>
+      if (colTx.attachedTo !== undefined && colTx.attachedToClass !== undefined && colTx.collection !== undefined) {
+        const _id = colTx.attachedTo
+        const _class = colTx.attachedToClass
 
         // Skip model operations
         if (this.context.hierarchy.getDomain(_class) === DOMAIN_MODEL) {
@@ -400,11 +400,11 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
           continue
         }
 
-        const isCreateTx = colTx.tx._class === core.class.TxCreateDoc
-        const isDeleteTx = colTx.tx._class === core.class.TxRemoveDoc
-        const isUpdateTx = colTx.tx._class === core.class.TxUpdateDoc
+        const isCreateTx = colTx._class === core.class.TxCreateDoc
+        const isDeleteTx = colTx._class === core.class.TxRemoveDoc
+        const isUpdateTx = colTx._class === core.class.TxUpdateDoc
         if (isUpdateTx) {
-          result.push(...(await this.updateCollection(ctx, tx, findAll)))
+          result.push(...(await this.updateCollection(ctx, colTx as TxUpdateDoc<AttachedDoc>, findAll)))
         }
 
         if ((isCreateTx || isDeleteTx) && !ctx.contextData.removedMap.has(_id)) {
@@ -503,11 +503,10 @@ export class TriggersMiddleware extends BaseMiddleware implements Middleware {
   private async processMove (ctx: MeasureContext, txes: Tx[], findAll: SessionFindAll): Promise<Tx[]> {
     const result: Tx[] = []
     for (const tx of txes) {
-      const actualTx = TxProcessor.extractTx(tx)
-      if (!this.context.hierarchy.isDerived(actualTx._class, core.class.TxUpdateDoc)) {
+      if (!this.context.hierarchy.isDerived(tx._class, core.class.TxUpdateDoc)) {
         continue
       }
-      const rtx = actualTx as TxUpdateDoc<Doc>
+      const rtx = tx as TxUpdateDoc<Doc>
       if (rtx.operations.space === undefined || rtx.operations.space === rtx.objectSpace) {
         continue
       }
diff --git a/server/mongo/src/__tests__/minmodel.ts b/server/mongo/src/__tests__/minmodel.ts
index 2580f4d375..0fb94e0df3 100644
--- a/server/mongo/src/__tests__/minmodel.ts
+++ b/server/mongo/src/__tests__/minmodel.ts
@@ -173,13 +173,6 @@ export function genMinModel (): TxCUD<Doc>[] {
       kind: ClassifierKind.CLASS
     })
   )
-  txes.push(
-    createClass(core.class.TxCollectionCUD, {
-      label: 'TxCollectionCUD' as IntlString,
-      extends: core.class.TxCUD,
-      kind: ClassifierKind.CLASS
-    })
-  )
 
   txes.push(
     createClass(test.mixin.TestMixin, {
diff --git a/server/mongo/src/storage.ts b/server/mongo/src/storage.ts
index 8fd5a576e4..f87814d39d 100644
--- a/server/mongo/src/storage.ts
+++ b/server/mongo/src/storage.ts
@@ -26,7 +26,6 @@ import core, {
   matchQuery,
   toFindResult,
   withContext,
-  type AttachedDoc,
   type Class,
   type Doc,
   type DocInfo,
@@ -53,7 +52,6 @@ import core, {
   type StorageIterator,
   type Tx,
   type TxCUD,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxMixin,
   type TxRemoveDoc,
@@ -1219,9 +1217,6 @@ class MongoAdapter extends MongoAdapterBase {
       case core.class.TxCreateDoc:
         this.txCreateDoc(bulk, tx as TxCreateDoc<Doc>)
         break
-      case core.class.TxCollectionCUD:
-        this.txCollectionCUD(bulk, tx as TxCollectionCUD<Doc, AttachedDoc>)
-        break
       case core.class.TxUpdateDoc:
         this.txUpdateDoc(bulk, tx as TxUpdateDoc<Doc>)
         break
@@ -1391,26 +1386,6 @@ class MongoAdapter extends MongoAdapterBase {
     return result
   }
 
-  protected txCollectionCUD (bulk: OperationBulk, tx: TxCollectionCUD<Doc, AttachedDoc>): void {
-    // We need update only create transactions to contain attached, attachedToClass.
-    if (tx.tx._class === core.class.TxCreateDoc) {
-      const createTx = tx.tx as TxCreateDoc<AttachedDoc>
-      const d: TxCreateDoc<AttachedDoc> = {
-        ...createTx,
-        attributes: {
-          ...createTx.attributes,
-          attachedTo: tx.objectId,
-          attachedToClass: tx.objectClass,
-          collection: tx.collection
-        }
-      }
-      this.txCreateDoc(bulk, d)
-      return
-    }
-    // We could cast since we know collection cud is supported.
-    this.updateBulk(bulk, tx.tx)
-  }
-
   protected txRemoveDoc (bulk: OperationBulk, tx: TxRemoveDoc<Doc>): void {
     bulk.bulkOperations.push({ deleteOne: { filter: { _id: tx.objectId } } })
   }
diff --git a/server/postgres/src/__tests__/minmodel.ts b/server/postgres/src/__tests__/minmodel.ts
index 63a44492af..b3deb5eec8 100644
--- a/server/postgres/src/__tests__/minmodel.ts
+++ b/server/postgres/src/__tests__/minmodel.ts
@@ -173,13 +173,6 @@ export function genMinModel (): TxCUD<Doc>[] {
       kind: ClassifierKind.CLASS
     })
   )
-  txes.push(
-    createClass(core.class.TxCollectionCUD, {
-      label: 'TxCollectionCUD' as IntlString,
-      extends: core.class.TxCUD,
-      kind: ClassifierKind.CLASS
-    })
-  )
 
   txes.push(
     createClass(test.mixin.TestMixin, {
diff --git a/server/postgres/src/storage.ts b/server/postgres/src/storage.ts
index ba94039d2b..83f16c84ce 100644
--- a/server/postgres/src/storage.ts
+++ b/server/postgres/src/storage.ts
@@ -15,7 +15,6 @@
 
 import core, {
   AccountRole,
-  type AttachedDoc,
   type Class,
   type Doc,
   type DocInfo,
@@ -44,7 +43,6 @@ import core, {
   type StorageIterator,
   toFindResult,
   type Tx,
-  type TxCollectionCUD,
   type TxCreateDoc,
   type TxCUD,
   type TxMixin,
@@ -313,8 +311,8 @@ abstract class PostgresAdapterBase implements DbAdapter {
             const prevAttachedTo = (doc as any).attachedTo
             TxProcessor.applyUpdate(doc, operations)
             const converted = convertDoc(domain, doc, this.workspaceId.name)
-            let paramsIndex = 3
             const params: any[] = [doc._id, this.workspaceId.name]
+            let paramsIndex = params.length + 1
             const updates: string[] = []
             const { extractedFields, remainingData } = parseUpdate(domain, operations)
             const newAttachedTo = (doc as any).attachedTo
@@ -356,7 +354,7 @@ abstract class PostgresAdapterBase implements DbAdapter {
     const translatedQuery = this.buildRawQuery(domain, query)
     const updates: string[] = []
     const params: any[] = []
-    let paramsIndex = 5
+    let paramsIndex = params.length + 1
     const { extractedFields, remainingData } = parseUpdate(domain, operations)
     const { space, attachedTo, ...ops } = operations as any
     for (const key in extractedFields) {
@@ -1380,8 +1378,6 @@ class PostgresAdapter extends PostgresAdapterBase {
     switch (tx._class) {
       case core.class.TxCreateDoc:
         return await this.txCreateDoc(ctx, tx as TxCreateDoc<Doc>)
-      case core.class.TxCollectionCUD:
-        return await this.txCollectionCUD(ctx, tx as TxCollectionCUD<Doc, AttachedDoc>)
       case core.class.TxUpdateDoc:
         return await this.txUpdateDoc(ctx, tx as TxUpdateDoc<Doc>)
       case core.class.TxRemoveDoc:
@@ -1397,28 +1393,6 @@ class PostgresAdapter extends PostgresAdapterBase {
     }
   }
 
-  protected async txCollectionCUD (
-    ctx: MeasureContext,
-    tx: TxCollectionCUD<Doc, AttachedDoc>
-  ): Promise<TxResult | undefined> {
-    // We need update only create transactions to contain attached, attachedToClass.
-    if (tx.tx._class === core.class.TxCreateDoc) {
-      const createTx = tx.tx as TxCreateDoc<AttachedDoc>
-      const d: TxCreateDoc<AttachedDoc> = {
-        ...createTx,
-        attributes: {
-          ...createTx.attributes,
-          attachedTo: tx.objectId,
-          attachedToClass: tx.objectClass,
-          collection: tx.collection
-        }
-      }
-      return await this.txCreateDoc(ctx, d)
-    }
-    // We could cast since we know collection cud is supported.
-    return await this.process(ctx, tx.tx as Tx)
-  }
-
   private async txMixin (ctx: MeasureContext, tx: TxMixin<Doc, Doc>): Promise<TxResult> {
     await ctx.with('tx-mixin', { _class: tx.objectClass, mixin: tx.mixin }, async (ctx) => {
       await this.withConnection(ctx, async (connection) => {
@@ -1521,7 +1495,7 @@ class PostgresAdapter extends PostgresAdapterBase {
     return ctx.with('update jsonb_set', {}, async (_ctx) => {
       const updates: string[] = ['"modifiedBy" = $1', '"modifiedOn" = $2']
       const params: any[] = [tx.modifiedBy, tx.modifiedOn, tx.objectId, this.workspaceId.name]
-      let paramsIndex = 5
+      let paramsIndex = params.length + 1
       const domain = this.hierarchy.getDomain(tx.objectClass)
       const { extractedFields, remainingData } = parseUpdate(domain, tx.operations)
       const { space, attachedTo, ...ops } = tx.operations as any
diff --git a/server/server/src/client.ts b/server/server/src/client.ts
index ad02db2401..cd31672c60 100644
--- a/server/server/src/client.ts
+++ b/server/server/src/client.ts
@@ -207,10 +207,10 @@ export class ClientSession implements Session {
       for (const dtx of tx) {
         if (TxProcessor.isExtendsCUD(dtx._class)) {
           classes.add((dtx as TxCUD<Doc>).objectClass)
-        }
-        const etx = TxProcessor.extractTx(dtx)
-        if (TxProcessor.isExtendsCUD(etx._class)) {
-          classes.add((etx as TxCUD<Doc>).objectClass)
+          const attachedToClass = (dtx as TxCUD<Doc>).attachedToClass
+          if (attachedToClass !== undefined) {
+            classes.add(attachedToClass)
+          }
         }
       }
       const bevent = createBroadcastEvent(Array.from(classes))
diff --git a/server/ws/src/__tests__/minmodel.ts b/server/ws/src/__tests__/minmodel.ts
index c79e7f2a3b..da06698841 100644
--- a/server/ws/src/__tests__/minmodel.ts
+++ b/server/ws/src/__tests__/minmodel.ts
@@ -163,13 +163,6 @@ export function genMinModel (): TxCUD<Doc>[] {
       kind: ClassifierKind.CLASS
     })
   )
-  txes.push(
-    createClass(core.class.TxCollectionCUD, {
-      label: 'TxCollectionCUD' as IntlString,
-      extends: core.class.TxCUD,
-      kind: ClassifierKind.CLASS
-    })
-  )
 
   txes.push(
     createClass(test.mixin.TestMixin, {
diff --git a/services/ai-bot/pod-ai-bot/src/workspace/love.ts b/services/ai-bot/pod-ai-bot/src/workspace/love.ts
index 6b2f5e1cea..90660f3102 100644
--- a/services/ai-bot/pod-ai-bot/src/workspace/love.ts
+++ b/services/ai-bot/pod-ai-bot/src/workspace/love.ts
@@ -1,17 +1,18 @@
-import core, {
-  Ref,
-  TxOperations,
-  concatLink,
-  Tx,
-  TxProcessor,
-  TxCUD,
-  Doc,
-  TxCreateDoc,
-  TxUpdateDoc,
-  MeasureContext,
-  Markup
-} from '@hcengineering/core'
+import { ConnectMeetingRequest } from '@hcengineering/ai-bot'
+import chunter from '@hcengineering/chunter'
 import { Person } from '@hcengineering/contact'
+import core, {
+  concatLink,
+  Doc,
+  Markup,
+  MeasureContext,
+  Ref,
+  TxCreateDoc,
+  TxCUD,
+  TxOperations,
+  TxProcessor,
+  TxUpdateDoc
+} from '@hcengineering/core'
 import love, {
   getFreeRoomPlace,
   MeetingMinutes,
@@ -20,8 +21,6 @@ import love, {
   RoomLanguage,
   TranscriptionStatus
 } from '@hcengineering/love'
-import { ConnectMeetingRequest } from '@hcengineering/ai-bot'
-import chunter from '@hcengineering/chunter'
 import { jsonToMarkup, MarkupNodeType } from '@hcengineering/text'
 
 import config from '../config'
@@ -54,12 +53,10 @@ export class LoveController {
     }
   }
 
-  txHandler (txes: Tx[]): void {
+  txHandler (txes: TxCUD<Doc>[]): void {
     const hierarchy = this.client.getHierarchy()
-    for (const tx of txes) {
-      if (!hierarchy.isDerived(tx._class, core.class.TxCUD)) continue
-      const etx = TxProcessor.extractTx(tx) as TxCUD<Doc>
-
+    for (const etx of txes) {
+      if (!hierarchy.isDerived(etx._class, core.class.TxCUD)) continue
       if (etx._class === core.class.TxCreateDoc) {
         if (etx.objectClass === love.class.ParticipantInfo) {
           this.participantsInfo.push(TxProcessor.createDoc2Doc(etx as TxCreateDoc<ParticipantInfo>))
diff --git a/services/ai-bot/pod-ai-bot/src/workspace/supportWsClient.ts b/services/ai-bot/pod-ai-bot/src/workspace/supportWsClient.ts
index ccdb49267a..dd9e68f61b 100644
--- a/services/ai-bot/pod-ai-bot/src/workspace/supportWsClient.ts
+++ b/services/ai-bot/pod-ai-bot/src/workspace/supportWsClient.ts
@@ -13,7 +13,7 @@
 // limitations under the License.
 //
 
-import core, { Class, Doc, Markup, Ref, Tx, TxOperations, TxProcessor, TxUpdateDoc } from '@hcengineering/core'
+import core, { Class, Doc, Markup, Ref, Tx, TxCUD, TxOperations, TxUpdateDoc } from '@hcengineering/core'
 import { WorkspaceClient } from './workspaceClient'
 import analyticsCollector, { OnboardingChannel } from '@hcengineering/analytics-collector'
 import aiBot from '@hcengineering/ai-bot'
@@ -70,10 +70,9 @@ export class SupportWsClient extends WorkspaceClient {
   }
 
   private handleTx (client: TxOperations, ...txes: Tx[]): void {
-    void super.txHandler(client, txes)
+    void super.txHandler(client, txes as TxCUD<Doc>[])
     for (const tx of txes) {
-      const etx = TxProcessor.extractTx(tx)
-      switch (etx._class) {
+      switch (tx._class) {
         case core.class.TxUpdateDoc: {
           this.txUpdateDoc(client, tx as TxUpdateDoc<Doc>)
           break
diff --git a/services/ai-bot/pod-ai-bot/src/workspace/workspaceClient.ts b/services/ai-bot/pod-ai-bot/src/workspace/workspaceClient.ts
index 94ac84fb19..ee8fe6ee61 100644
--- a/services/ai-bot/pod-ai-bot/src/workspace/workspaceClient.ts
+++ b/services/ai-bot/pod-ai-bot/src/workspace/workspaceClient.ts
@@ -21,6 +21,7 @@ import aiBot, {
   DisconnectMeetingRequest,
   IdentityResponse
 } from '@hcengineering/ai-bot'
+import analyticsCollector, { OnboardingChannel } from '@hcengineering/analytics-collector'
 import chunter, {
   ChatMessage,
   type ChatWidgetTab,
@@ -50,29 +51,28 @@ import core, {
   Ref,
   Space,
   Tx,
+  TxCUD,
   TxOperations,
-  TxProcessor,
   TxRemoveDoc
 } from '@hcengineering/core'
+import { Room } from '@hcengineering/love'
 import { countTokens } from '@hcengineering/openai'
 import { WorkspaceInfoRecord } from '@hcengineering/server-ai-bot'
 import { getOrCreateOnboardingChannel } from '@hcengineering/server-analytics-collector-resources'
 import { BlobClient, login } from '@hcengineering/server-client'
+import { generateToken } from '@hcengineering/server-token'
 import { jsonToMarkup, MarkdownParser, markupToText } from '@hcengineering/text'
+import workbench, { SidebarEvent, TxSidebarEvent } from '@hcengineering/workbench'
 import fs from 'fs'
 import { WithId } from 'mongodb'
 import OpenAI from 'openai'
-import analyticsCollector, { OnboardingChannel } from '@hcengineering/analytics-collector'
-import workbench, { SidebarEvent, TxSidebarEvent } from '@hcengineering/workbench'
-import { generateToken } from '@hcengineering/server-token'
-import { Room } from '@hcengineering/love'
 
 import config from '../config'
 import { AIControl } from '../controller'
-import { connectPlatform, getDirect } from '../utils/platform'
 import { HistoryRecord } from '../types'
-import { LoveController } from './love'
 import { createChatCompletion, requestSummary } from '../utils/openai'
+import { connectPlatform, getDirect } from '../utils/platform'
+import { LoveController } from './love'
 
 const MAX_LOGIN_DELAY_MS = 15 * 1000 // 15 ses
 const UPDATE_TYPING_TIMEOUT_MS = 1000
@@ -133,7 +133,7 @@ export class WorkspaceClient {
     const typing = await opClient.findAll(chunter.class.TypingInfo, { user: aiBot.account.AIBot })
     this.typingMap = new Map(typing.map((t) => [t.objectId, t]))
     this.client.notify = (...txes: Tx[]) => {
-      void this.txHandler(opClient, txes)
+      void this.txHandler(opClient, txes as TxCUD<Doc>[])
     }
     this.ctx.info('Initialized workspace', { workspace: this.workspace })
 
@@ -631,14 +631,12 @@ export class WorkspaceClient {
     }
   }
 
-  protected async txHandler (_: TxOperations, txes: Tx[]): Promise<void> {
+  protected async txHandler (_: TxOperations, txes: TxCUD<Doc>[]): Promise<void> {
     if (this.love !== undefined) {
       this.love.txHandler(txes)
     }
 
-    for (const ttx of txes) {
-      const tx = TxProcessor.extractTx(ttx)
-
+    for (const tx of txes) {
       if (tx._class === core.class.TxRemoveDoc) {
         await this.handleRemoveTx(tx as TxRemoveDoc<Doc>)
       }
diff --git a/services/analytics-collector/pod-analytics-collector/src/supportWsClient.ts b/services/analytics-collector/pod-analytics-collector/src/supportWsClient.ts
index 83f10029a5..acf77f1c35 100644
--- a/services/analytics-collector/pod-analytics-collector/src/supportWsClient.ts
+++ b/services/analytics-collector/pod-analytics-collector/src/supportWsClient.ts
@@ -65,8 +65,7 @@ export class SupportWsClient extends WorkspaceClient {
 
   private handleTx (client: TxOperations, ...txes: Tx[]): void {
     for (const tx of txes) {
-      const etx = TxProcessor.extractTx(tx)
-      switch (etx._class) {
+      switch (tx._class) {
         case core.class.TxUpdateDoc: {
           this.txUpdateDoc(client, tx as TxUpdateDoc<Doc>)
           break
diff --git a/services/calendar/pod-calendar/src/workspaceClient.ts b/services/calendar/pod-calendar/src/workspaceClient.ts
index f802e6db9f..34e6475d10 100644
--- a/services/calendar/pod-calendar/src/workspaceClient.ts
+++ b/services/calendar/pod-calendar/src/workspaceClient.ts
@@ -235,18 +235,17 @@ export class WorkspaceClient {
 
   private async txEventHandler (...txes: Tx[]): Promise<void> {
     for (const tx of txes) {
-      const actualTx = TxProcessor.extractTx(tx)
-      switch (actualTx._class) {
+      switch (tx._class) {
         case core.class.TxCreateDoc: {
-          await this.txCreateEvent(actualTx as TxCreateDoc<Doc>)
+          await this.txCreateEvent(tx as TxCreateDoc<Doc>)
           return
         }
         case core.class.TxUpdateDoc: {
-          await this.txUpdateEvent(actualTx as TxUpdateDoc<Event>)
+          await this.txUpdateEvent(tx as TxUpdateDoc<Event>)
           return
         }
         case core.class.TxRemoveDoc: {
-          await this.txRemoveEvent(actualTx as TxRemoveDoc<Doc>)
+          await this.txRemoveEvent(tx as TxRemoveDoc<Doc>)
         }
       }
     }
@@ -276,10 +275,10 @@ export class WorkspaceClient {
       return
     }
     try {
-      const txes = await this.client.findAll(core.class.TxCollectionCUD, {
-        'tx.objectId': tx.objectId
+      const txes = await this.client.findAll(core.class.TxCUD, {
+        objectId: tx.objectId
       })
-      const extracted = txes.map((tx) => TxProcessor.extractTx(tx)).filter((p) => p._id !== tx._id)
+      const extracted = txes.filter((p) => p._id !== tx._id)
       const ev = TxProcessor.buildDoc2Doc<Event>(extracted)
       if (ev !== undefined) {
         const oldClient = this.getCalendarClientByCalendar(ev.calendar as Ref<ExternalCalendar>)
@@ -332,10 +331,10 @@ export class WorkspaceClient {
   private async txRemoveEvent (tx: TxRemoveDoc<Doc>): Promise<void> {
     const hierarhy = this.client.getHierarchy()
     if (hierarhy.isDerived(tx.objectClass, calendar.class.Event)) {
-      const txes = await this.client.findAll(core.class.TxCollectionCUD, {
-        'tx.objectId': tx.objectId
+      const txes = await this.client.findAll(core.class.TxCUD, {
+        objectId: tx.objectId
       })
-      const ev = TxProcessor.buildDoc2Doc<Event>(txes.map((tx) => TxProcessor.extractTx(tx)))
+      const ev = TxProcessor.buildDoc2Doc<Event>(txes)
       if (ev === undefined) return
       if (ev.access !== 'owner' && ev.access !== 'writer') return
       const client = this.getCalendarClientByCalendar(ev?.calendar as Ref<ExternalCalendar>)
@@ -375,8 +374,7 @@ export class WorkspaceClient {
     return this.calendarsByEmail.get(email) ?? []
   }
 
-  private async txCalendarHandler (tx: Tx): Promise<void> {
-    const actualTx = TxProcessor.extractTx(tx)
+  private async txCalendarHandler (actualTx: Tx): Promise<void> {
     if (actualTx._class === core.class.TxCreateDoc) {
       if ((actualTx as TxCreateDoc<Doc>).objectClass === calendar.class.ExternalCalendar) {
         const calendar = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<ExternalCalendar>)
@@ -435,8 +433,7 @@ export class WorkspaceClient {
     })
   }
 
-  private async txChannelHandler (tx: Tx): Promise<void> {
-    const actualTx = TxProcessor.extractTx(tx)
+  private async txChannelHandler (actualTx: Tx): Promise<void> {
     if (actualTx._class === core.class.TxCreateDoc) {
       if ((actualTx as TxCreateDoc<Doc>).objectClass === contact.class.Channel) {
         const channel = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<Channel>)
@@ -543,8 +540,7 @@ export class WorkspaceClient {
     this.integrations.byId.delete(integration._id)
   }
 
-  private async txIntegrationHandler (tx: Tx): Promise<void> {
-    const actualTx = TxProcessor.extractTx(tx)
+  private async txIntegrationHandler (actualTx: Tx): Promise<void> {
     if (actualTx._class === core.class.TxCreateDoc) {
       if ((actualTx as TxCreateDoc<Doc>).objectClass === setting.class.Integration) {
         const integration = TxProcessor.createDoc2Doc(actualTx as TxCreateDoc<Integration>)
diff --git a/services/github/pod-github/src/sync/pullrequests.ts b/services/github/pod-github/src/sync/pullrequests.ts
index be92156727..731dc79403 100644
--- a/services/github/pod-github/src/sync/pullrequests.ts
+++ b/services/github/pod-github/src/sync/pullrequests.ts
@@ -9,7 +9,6 @@ import core, {
   SortingOrder,
   Status,
   TxCUD,
-  TxCollectionCUD,
   TxMixin,
   TxOperations,
   TxProcessor,
@@ -652,17 +651,17 @@ export class PullRequestSyncManager extends IssueSyncManagerBase implements DocS
     // We also need to track deleted Todos,
     const removedTodos: GithubTodo[] = []
 
-    const removedTodoOps = await client.findAll<TxCollectionCUD<Doc, ToDo>>(
-      core.class.TxCollectionCUD,
+    const removedTodoOps = await client.findAll<TxCUD<ToDo>>(
+      core.class.TxCUD,
       {
-        objectId: pullRequest._id,
-        'tx.objectClass': time.class.ProjectToDo,
-        'tx.objectId': { $nin: allTodos.map((it) => it._id) }
+        attachedTo: pullRequest._id,
+        objectClass: time.class.ProjectToDo,
+        objectId: { $nin: allTodos.map((it) => it._id) }
       },
       { sort: { modifiedOn: SortingOrder.Ascending } }
     )
 
-    const todoIds = removedTodoOps.filter((it) => it.tx._class === core.class.TxCreateDoc).map((it) => it.tx.objectId)
+    const todoIds = removedTodoOps.filter((it) => it._class === core.class.TxCreateDoc).map((it) => it.objectId)
 
     const mixinOps = await client.findAll<TxMixin<ToDo, GithubTodo>>(
       core.class.TxMixin,
@@ -678,8 +677,8 @@ export class PullRequestSyncManager extends IssueSyncManagerBase implements DocS
 
     // We need to rebuild removed todos's if pressent.
     for (const tx of removedTodoOps) {
-      const ops = groupedByTodo.get(tx.tx.objectId)
-      groupedByTodo.set(tx.tx.objectId, [...(ops ?? []), tx.tx])
+      const ops = groupedByTodo.get(tx.objectId)
+      groupedByTodo.set(tx.objectId, [...(ops ?? []), tx])
     }
 
     for (const tx of mixinOps) {
diff --git a/services/github/server-github-resources/src/index.ts b/services/github/server-github-resources/src/index.ts
index 697b0c8e38..8e49a880d4 100644
--- a/services/github/server-github-resources/src/index.ts
+++ b/services/github/server-github-resources/src/index.ts
@@ -5,7 +5,6 @@
 import chunter from '@hcengineering/chunter'
 import contact, { PersonAccount } from '@hcengineering/contact'
 import core, {
-  AttachedDoc,
   Doc,
   DocumentUpdate,
   Hierarchy,
@@ -14,7 +13,6 @@ import core, {
   Storage,
   Tx,
   TxCUD,
-  TxCollectionCUD,
   TxProcessor,
   TxUpdateDoc,
   systemAccountEmail,
@@ -34,13 +32,11 @@ export async function OnProjectChanges (txes: Tx[], control: TriggerControl): Pr
   const cache = new Map<string, any>()
 
   const toApply: Tx[] = []
-  for (const tx of txes) {
-    const ltx = TxProcessor.extractTx(tx)
-
+  for (const ltx of txes) {
     if (ltx._class === core.class.TxMixin && (ltx as TxMixin<Doc, Doc>).mixin === github.mixin.GithubIssue) {
       const mix = ltx as TxMixin<Doc, Doc>
       // Do not spend time to wait for trigger processing
-      await updateDocSyncInfo(control, tx, mix.objectSpace, mix, cache, toApply)
+      await updateDocSyncInfo(control, ltx, mix.objectSpace, mix, cache, toApply)
       continue
     }
 
@@ -57,18 +53,17 @@ export async function OnProjectChanges (txes: Tx[], control: TriggerControl): Pr
       }
 
       if (isDocSyncUpdateRequired(control.hierarchy, cud)) {
-        await updateDocSyncInfo(control, tx, space, cud, cache, toApply)
+        await updateDocSyncInfo(control, ltx, space, cud, cache, toApply)
       }
       if (control.hierarchy.isDerived(cud.objectClass, time.class.ToDo)) {
-        if (tx._class === core.class.TxCollectionCUD) {
-          const coll = tx as TxCollectionCUD<Doc, AttachedDoc>
-          if (control.hierarchy.isDerived(coll.objectClass, github.class.GithubPullRequest)) {
+        if (cud.attachedToClass !== undefined && cud.attachedTo !== undefined) {
+          if (control.hierarchy.isDerived(cud.attachedToClass, github.class.GithubPullRequest)) {
             // Ok we got todo change for pull request, let's mark it for sync.
             result.push(
               control.txFactory.createTxUpdateDoc<DocSyncInfo>(
                 github.class.DocSyncInfo,
-                coll.objectSpace,
-                coll.objectId as Ref<DocSyncInfo>,
+                ltx.objectSpace,
+                cud.attachedTo as Ref<DocSyncInfo>,
                 {
                   needSync: ''
                 }
@@ -241,10 +236,9 @@ function createSyncDoc (
     needSync: '',
     derivedVersion: ''
   }
-  if (tx._class === core.class.TxCollectionCUD) {
-    const coll = tx as TxCollectionCUD<Doc, AttachedDoc>
+  if ((tx as TxCUD<Doc>).attachedTo !== undefined) {
     // Collection CUD, we could assign attachedTo
-    data.attachedTo = coll.objectId
+    data.attachedTo = (tx as TxCUD<Doc>).attachedTo
   }
 
   toApply.push(
diff --git a/services/gmail/pod-gmail/src/gmail.ts b/services/gmail/pod-gmail/src/gmail.ts
index 8d7c80be4e..7599e70a7d 100644
--- a/services/gmail/pod-gmail/src/gmail.ts
+++ b/services/gmail/pod-gmail/src/gmail.ts
@@ -22,8 +22,8 @@ import core, {
   MeasureContext,
   Ref,
   Timestamp,
-  TxCollectionCUD,
   TxCreateDoc,
+  TxCUD,
   TxFactory,
   TxOperations,
   TxProcessor,
@@ -601,8 +601,8 @@ export class GmailClient {
       if (tx !== undefined) {
         const resultMessage =
           current != null
-            ? TxProcessor.updateDoc2Doc(current, tx.tx as TxUpdateDoc<Message>)
-            : TxProcessor.createDoc2Doc(tx.tx as TxCreateDoc<Message>)
+            ? TxProcessor.updateDoc2Doc(current, tx as TxUpdateDoc<Message>)
+            : TxProcessor.createDoc2Doc(tx as TxCreateDoc<Message>)
         await this.client.tx(tx)
         if (attachments.length > 0) {
           const currentAttachemtns: Attachment[] =
@@ -704,15 +704,21 @@ export class GmailClient {
     message: AttachedData<Message> & { modifiedOn: Timestamp },
     factory: TxFactory,
     channel: Channel
-  ): TxCollectionCUD<Channel, Message> {
+  ): TxCUD<Message> {
     const tx = factory.createTxCollectionCUD<Channel, Message>(
       channel._class,
       channel._id,
       channel.space,
       'items',
-      factory.createTxCreateDoc<Message>(gmail.class.Message, core.space.Workspace, message as unknown as Data<Message>)
+      factory.createTxCreateDoc<Message>(
+        gmail.class.Message,
+        core.space.Workspace,
+        message as unknown as Data<Message>,
+        undefined,
+        message.modifiedOn
+      ),
+      message.modifiedOn
     )
-    tx.tx.modifiedOn = message.modifiedOn
     return tx
   }
 
@@ -721,7 +727,7 @@ export class GmailClient {
     current: Message,
     factory: TxFactory,
     channel: Channel
-  ): TxCollectionCUD<Channel, Message> | undefined {
+  ): TxCUD<Message> | undefined {
     const operations = diffAttributes(current, message)
     if (Object.keys(operations).length === 0) return undefined
     const tx = factory.createTxCollectionCUD<Channel, Message>(
diff --git a/services/gmail/pod-gmail/src/workspaceClient.ts b/services/gmail/pod-gmail/src/workspaceClient.ts
index c5df09a49a..e40a344a2d 100644
--- a/services/gmail/pod-gmail/src/workspaceClient.ts
+++ b/services/gmail/pod-gmail/src/workspaceClient.ts
@@ -16,13 +16,11 @@
 import contact, { type Employee, type PersonAccount, type Channel as PlatformChannel } from '@hcengineering/contact'
 import core, {
   type Account,
-  type AttachedDoc,
   type Client,
   type Doc,
   MeasureContext,
   type Ref,
   type Tx,
-  type TxCollectionCUD,
   type TxCreateDoc,
   TxProcessor,
   type TxRemoveDoc,
@@ -273,10 +271,6 @@ export class WorkspaceClient {
         await this.txCreateChannel(tx as TxCreateDoc<Doc>)
         return
       }
-      case core.class.TxCollectionCUD: {
-        await this.txCollectionCUD(tx as TxCollectionCUD<Doc, AttachedDoc>)
-        return
-      }
       case core.class.TxUpdateDoc: {
         await this.txUpdateChannel(tx as TxUpdateDoc<Doc>)
         return
@@ -287,10 +281,6 @@ export class WorkspaceClient {
     }
   }
 
-  private async txCollectionCUD (tx: TxCollectionCUD<Doc, AttachedDoc>): Promise<void> {
-    await this.txHandler(tx.tx)
-  }
-
   private async txCreateChannel (tx: TxCreateDoc<Doc>): Promise<void> {
     const hierarhy = this.client.getHierarchy()
     if (hierarhy.isDerived(tx.objectClass, contact.class.Channel)) {
diff --git a/services/telegram/pod-telegram/src/workspace.ts b/services/telegram/pod-telegram/src/workspace.ts
index 21b6e31e91..8a57b4bf8e 100644
--- a/services/telegram/pod-telegram/src/workspace.ts
+++ b/services/telegram/pod-telegram/src/workspace.ts
@@ -2,14 +2,13 @@ import attachment, { Attachment } from '@hcengineering/attachment'
 import contact, {
   Channel,
   Employee,
-  Contact as PContact,
-  PersonAccount,
   getFirstName,
-  getLastName
+  getLastName,
+  Contact as PContact,
+  PersonAccount
 } from '@hcengineering/contact'
 import core, {
   Account,
-  AttachedDoc,
   Blob,
   Client,
   Doc,
@@ -17,8 +16,8 @@ import core, {
   MeasureContext,
   Ref,
   Tx,
-  TxCollectionCUD,
   TxCreateDoc,
+  TxCUD,
   TxFactory,
   TxOperations,
   TxProcessor,
@@ -95,10 +94,6 @@ export class WorkspaceWorker {
           await this.txCreateDoc(tx as TxCreateDoc<Doc>)
           return
         }
-        case core.class.TxCollectionCUD: {
-          await this.txCollectionCUD(tx as TxCollectionCUD<Doc, AttachedDoc>)
-          return
-        }
         case core.class.TxUpdateDoc: {
           await this.txUpdateDoc(tx as TxUpdateDoc<Doc>)
           return
@@ -124,10 +119,6 @@ export class WorkspaceWorker {
     }
   }
 
-  private async txCollectionCUD (tx: TxCollectionCUD<Doc, AttachedDoc>): Promise<void> {
-    await this.txHandler(tx.tx)
-  }
-
   private async txUpdateDoc (tx: TxUpdateDoc<Doc>): Promise<void> {
     if (this.hierarchy.isDerived(tx.objectClass, contact.class.Channel)) {
       await this.updateChannelHandler(tx)
@@ -551,27 +542,30 @@ export class WorkspaceWorker {
     }
   }
 
-  private makePlatformMsg (
-    event: Event,
-    record: UserRecord,
-    channel: Channel
-  ): TxCollectionCUD<Channel, TelegramMessage> {
+  private makePlatformMsg (event: Event, record: UserRecord, channel: Channel): TxCUD<TelegramMessage> {
     const factory = new TxFactory(record.userId as Ref<Account>)
+    const modifiedOn = event.msg.date * 1000
     const tx = factory.createTxCollectionCUD<Channel, TelegramMessage>(
       channel._class,
       channel._id,
       channel.space,
       'items',
-      factory.createTxCreateDoc<TelegramMessage>(telegramP.class.Message, core.space.Workspace, {
-        attachedTo: channel._id,
-        attachedToClass: channel._class,
-        collection: 'items',
-        sendOn: event.msg.date * 1000,
-        content: telegramToPlatform(event.msg),
-        incoming: event.msg.out !== true
-      })
+      factory.createTxCreateDoc<TelegramMessage>(
+        telegramP.class.Message,
+        core.space.Workspace,
+        {
+          attachedTo: channel._id,
+          attachedToClass: channel._class,
+          collection: 'items',
+          sendOn: event.msg.date * 1000,
+          content: telegramToPlatform(event.msg),
+          incoming: event.msg.out !== true
+        },
+        undefined,
+        modifiedOn
+      ),
+      modifiedOn
     )
-    tx.tx.modifiedOn = event.msg.date * 1000
     return tx
   }
 
@@ -660,9 +654,9 @@ export class WorkspaceWorker {
   private async makePlatformAttachments (
     event: Event,
     record: UserRecord,
-    createTx: TxCollectionCUD<Channel, TelegramMessage>
+    createTx: TxCUD<TelegramMessage>
   ): Promise<void> {
-    const msg = TxProcessor.createDoc2Doc(createTx.tx as TxCreateDoc<TelegramMessage>)
+    const msg = TxProcessor.createDoc2Doc(createTx as TxCreateDoc<TelegramMessage>)
     const factory = new TxFactory(record.userId as Ref<Account>)
     const files = await getFiles(event.msg)
     for (const file of files) {
@@ -670,24 +664,30 @@ export class WorkspaceWorker {
         const id = uuid()
         file.size = file.size ?? file.file.length
         await this.storageAdapter.put(this.ctx, { name: this.workspace }, id, file.file, file.type, file.size)
+        const modifiedOn = event.msg.date * 1000
         const tx = factory.createTxCollectionCUD<TelegramMessage, Attachment>(
           msg._class,
           msg._id,
           msg.space,
           'attachments',
-          factory.createTxCreateDoc<Attachment>(attachment.class.Attachment, msg.space, {
-            name: file.name,
-            file: id as Ref<Blob>,
-            type: file.type,
-            size: file.size,
-            lastModified: file.lastModified,
-            collection: 'attachments',
-            attachedTo: msg._id,
-            attachedToClass: msg._class
-          })
+          factory.createTxCreateDoc<Attachment>(
+            attachment.class.Attachment,
+            msg.space,
+            {
+              name: file.name,
+              file: id as Ref<Blob>,
+              type: file.type,
+              size: file.size,
+              lastModified: file.lastModified,
+              collection: 'attachments',
+              attachedTo: msg._id,
+              attachedToClass: msg._class
+            },
+            undefined,
+            modifiedOn
+          ),
+          modifiedOn
         )
-        tx.modifiedOn = event.msg.date * 1000
-        tx.tx.modifiedOn = event.msg.date * 1000
         await this.client.tx(tx)
       } catch (e) {
         console.error(e)