diff --git a/src/spread/spread.fork.test.ts b/src/spread/spread.fork.test.ts
index 9af7a498..4afac567 100644
--- a/src/spread/spread.fork.test.ts
+++ b/src/spread/spread.fork.test.ts
@@ -4,64 +4,84 @@ import { spread } from './index';
 
 test('works in forked scope', async () => {
   const app = createDomain();
-  const source = app.createEvent<{ first: string; second: number }>();
+  const source = app.createEvent<{ first: string; second: number; third: string }>();
   const first = app.createEvent<string>();
   const second = app.createEvent<number>();
 
-  const _$first = app.createStore('').on(first, (_, p) => p);
-  const _$second = restore(second, 0);
+  const $thirdA = app.createStore('');
+  const $thirdB = app.createStore('');
+
+  const $first = app.createStore('').on(first, (_, p) => p);
+  const $second = restore(second, 0);
 
   spread({
     source,
-    targets: { first, second },
+    targets: { first, second, third: [$thirdA, $thirdB] },
   });
 
   const scope = fork();
 
-  await allSettled(source, { scope, params: { first: 'sergey', second: 26 } });
-  expect(serialize(scope)).toMatchInlineSnapshot(`
-    {
-      "-xihhjw": 26,
-      "nln5hw": "sergey",
-    }
-  `);
+  await allSettled(source, {
+    scope,
+    params: { first: 'sergey', second: 26, third: '30' },
+  });
+
+  expect(scope.getState($first)).toBe('sergey');
+  expect(scope.getState($second)).toBe(26);
+  expect(scope.getState($thirdA)).toBe('30');
+  expect(scope.getState($thirdB)).toBe('30');
 });
 
 test('do not affects original store state', async () => {
   const app = createDomain();
-  const source = app.createEvent<{ first: string; second: number }>();
+  const source = app.createEvent<{ first: string; second: number; third: string }>();
   const first = app.createEvent<string>();
   const second = app.createEvent<number>();
 
+  const $thirdA = app.createStore('');
+  const $thirdB = app.createStore('');
+
   const $first = app.createStore('').on(first, (_, p) => p);
   const $second = restore(second, 0);
 
   spread({
     source,
-    targets: { first, second },
+    targets: { first, second, third: [$thirdA, $thirdB] },
   });
 
   const scope = fork();
 
-  await allSettled(source, { scope, params: { first: 'sergey', second: 26 } });
+  await allSettled(source, {
+    scope,
+    params: { first: 'sergey', second: 26, third: '30' },
+  });
+
   expect(scope.getState($first)).toBe('sergey');
   expect(scope.getState($second)).toBe(26);
+  expect(scope.getState($thirdA)).toBe('30');
+  expect(scope.getState($thirdB)).toBe('30');
+
   expect($first.getState()).toBe('');
   expect($second.getState()).toBe(0);
+  expect($thirdA.getState()).toBe('');
+  expect($thirdB.getState()).toBe('');
 });
 
 test('do not affects another scope', async () => {
   const app = createDomain();
-  const source = app.createEvent<{ first: string; second: number }>();
+  const source = app.createEvent<{ first: string; second: number; third: string }>();
   const first = app.createEvent<string>();
   const second = app.createEvent<number>();
 
-  const _$first = app.createStore('').on(first, (_, p) => p);
-  const _$second = restore(second, 0);
+  const $thirdA = app.createStore('');
+  const $thirdB = app.createStore('');
+
+  const $first = app.createStore('').on(first, (_, p) => p);
+  const $second = restore(second, 0);
 
   spread({
     source,
-    targets: { first, second },
+    targets: { first, second, third: [$thirdA, $thirdB] },
   });
 
   const scope1 = fork();
@@ -70,23 +90,21 @@ test('do not affects another scope', async () => {
   await Promise.all([
     allSettled(source, {
       scope: scope1,
-      params: { first: 'sergey', second: 26 },
+      params: { first: 'sergey', second: 26, third: '30' },
     }),
     allSettled(source, {
       scope: scope2,
-      params: { first: 'Anon', second: 90 },
+      params: { first: 'Anon', second: 90, third: '154' },
     }),
   ]);
-  expect(serialize(scope1)).toMatchInlineSnapshot(`
-    {
-      "-w3pd79": 26,
-      "f2h7kg": "sergey",
-    }
-  `);
-  expect(serialize(scope2)).toMatchInlineSnapshot(`
-    {
-      "-w3pd79": 90,
-      "f2h7kg": "Anon",
-    }
-  `);
+
+  expect(scope1.getState($first)).toBe('sergey');
+  expect(scope1.getState($second)).toBe(26);
+  expect(scope1.getState($thirdA)).toBe('30');
+  expect(scope1.getState($thirdB)).toBe('30');
+
+  expect(scope2.getState($first)).toBe('Anon');
+  expect(scope2.getState($second)).toBe(90);
+  expect(scope2.getState($thirdA)).toBe('154');
+  expect(scope2.getState($thirdB)).toBe('154');
 });
diff --git a/test-typings/spread.ts b/test-typings/spread.ts
index eafd304d..35827b72 100644
--- a/test-typings/spread.ts
+++ b/test-typings/spread.ts
@@ -11,16 +11,17 @@ import {
 import { spread } from '../dist/spread';
 
 {
-  const $source = createStore({ first: '', last: '' });
+  const $source = createStore({ first: '', last: '', foo: 1 });
   const first = createEvent<string>();
   const last = createEvent<string>();
 
-  expectType<Store<{ first: string; last: string }>>(
+  expectType<Store<{ first: string; last: string; foo: number }>>(
     spread({
       source: $source,
       targets: {
         first,
         last,
+        foo: [createEvent<number>(), createStore(1)],
       },
     }),
   );
@@ -54,36 +55,77 @@ import { spread } from '../dist/spread';
       last: createEvent<number>(),
     },
   });
+
+  // @ts-expect-error
+  spread({
+    source: createEvent<{ first: string; last: number }>(),
+    targets: {
+      first: createEvent<string>(),
+      last: [createEvent<number>(), createEvent<string>()],
+    },
+  });
+
+  spread({
+    source: createEvent<{ first: string; last: number }>(),
+    targets: {
+      // @ts-expect-error
+      last: [createEvent<string>(), createEvent<string>()],
+      first: createEvent<string>(),
+    },
+  });
+
+  sample({
+    // @ts-expect-error
+    source: createEvent<{ first: string; last: number }>(),
+    target: spread({
+      first: createEvent<string>(),
+      last: [createEvent<string>(), createEvent<string>()],
+    }),
+  });
+
+  sample({
+    // @ts-expect-error
+    source: createEvent<{ first: string; last: number }>(),
+    target: spread({
+      targets: {
+        first: createEvent<string>(),
+        last: [createEvent<string>(), createEvent<string>()],
+      },
+    }),
+  });
 }
 
 // Check input source type with output
 {
-  expectType<Event<{ foo: string; bar: number }>>(
+  expectType<Event<{ foo: string; bar: number; baz: boolean }>>(
     spread({
-      source: createEvent<{ foo: string; bar: number }>(),
+      source: createEvent<{ foo: string; bar: number; baz: boolean }>(),
       targets: {
         foo: createEvent<string>(),
         bar: createEvent<number>(),
+        baz: [createEvent<boolean>(), createEvent<boolean>()],
       },
     }),
   );
 
-  expectType<Store<{ random: string; bar: number }>>(
+  expectType<Store<{ random: string; bar: number; baz: boolean }>>(
     spread({
-      source: createStore({ random: '', bar: 5 }),
+      source: createStore({ random: '', bar: 5, baz: true }),
       targets: {
         random: createEvent<string>(),
         bar: createEvent<number>(),
+        baz: [createEvent<boolean>(), createEvent<boolean>()],
       },
     }),
   );
 
-  expectType<Effect<{ foo: string; bar: number }, void>>(
+  expectType<Effect<{ foo: string; bar: number; baz: boolean }, void>>(
     spread({
-      source: createEffect<{ foo: string; bar: number }, void>(),
+      source: createEffect<{ foo: string; bar: number; baz: boolean }, void>(),
       targets: {
         foo: createEvent<string>(),
         bar: createEvent<number>(),
+        baz: [createEvent<boolean>(), createEvent<boolean>()],
       },
     }),
   );
@@ -91,32 +133,35 @@ import { spread } from '../dist/spread';
 
 // Check target different units
 {
-  expectType<Event<{ foo: string; bar: number }>>(
+  expectType<Event<{ foo: string; bar: number; baz: boolean }>>(
     spread({
-      source: createEvent<{ foo: string; bar: number }>(),
+      source: createEvent<{ foo: string; bar: number; baz: boolean }>(),
       targets: {
         foo: createStore(''),
         bar: createEffect<number, void>(),
+        baz: [createEvent<boolean>(), createStore(true)],
       },
     }),
   );
 
-  expectType<Store<{ foo: string; bar: number }>>(
+  expectType<Store<{ foo: string; bar: number; baz: boolean }>>(
     spread({
-      source: createStore({ foo: '', bar: 5 }),
+      source: createStore({ foo: '', bar: 5, baz: true }),
       targets: {
         foo: createStore(''),
         bar: createEffect<number, void>(),
+        baz: [createEvent<boolean>(), createEffect<boolean, void>()],
       },
     }),
   );
 
-  expectType<Effect<{ foo: string; bar: number }, void>>(
+  expectType<Effect<{ foo: string; bar: number; baz: boolean }, void>>(
     spread({
-      source: createEffect<{ foo: string; bar: number }, void>(),
+      source: createEffect<{ foo: string; bar: number; baz: boolean }, void>(),
       targets: {
         foo: createStore(''),
         bar: createEffect<number, void>(),
+        baz: [createStore(true), createEffect<boolean, void>()],
       },
     }),
   );
@@ -126,12 +171,16 @@ import { spread } from '../dist/spread';
 {
   const foo = createEvent<number>();
 
-  expectType<Event<{ foo: string; bar: number }>>(
+  expectType<Event<{ foo: string; bar: number; baz: boolean }>>(
     spread({
-      source: createEvent<{ foo: string; bar: number }>(),
+      source: createEvent<{ foo: string; bar: number; baz: boolean }>(),
       targets: {
         foo: foo.prepend((string) => string.length),
         bar: createEvent<number>(),
+        baz: [
+          createEvent<string>().prepend((bool) => (bool ? 'true' : 'false')),
+          createEvent<number>().prepend((bool) => (bool ? 1 : 0)),
+        ],
       },
     }),
   );
@@ -144,19 +193,24 @@ import { spread } from '../dist/spread';
       foo: createStore(''),
       bar: createEffect<number, void>(),
       baz: createEvent<boolean>(),
+      last: [createEvent<null>(), createStore(null)],
     },
   });
 
-  expectType<Event<{ foo?: string; bar?: number; baz?: boolean }>>(spreadToStores);
+  expectType<Event<{ foo?: string; bar?: number; baz?: boolean; last?: null }>>(
+    spreadToStores,
+  );
 }
 {
   const spreadToStores = spread({
     foo: createStore(''),
-    bar: createEffect<number, void>(),
     baz: createEvent<boolean>(),
+    last: [createEvent<null>(), createStore(null)],
   });
 
-  expectType<Event<{ foo?: string; bar?: number; baz?: boolean }>>(spreadToStores);
+  expectType<Event<{ foo?: string; bar?: number; baz?: boolean; last?: null }>>(
+    spreadToStores,
+  );
 }
 
 // Example from readme with nullability
@@ -201,14 +255,21 @@ import { spread } from '../dist/spread';
       first: createEvent<string>(),
     },
   });
+  spread({
+    source: createEffect<{ first: string; last: string }, void>(),
+    targets: {
+      first: [createEvent<string>(), createStore('')],
+    },
+  });
 }
 
 // allows nested
 {
-  const $source = createStore({ first: '', last: { nested: '', other: '' } });
+  const $source = createStore({ first: '', last: { nested: '', other: '', arr: 1 } });
   const first = createEvent<string>();
   const nested = createEvent<string>();
   const other = createEvent<string>();
+  const arrayOfUnits = [createEvent<number>(), createStore(1)];
 
   // nested full match
   spread({
@@ -219,6 +280,7 @@ import { spread } from '../dist/spread';
         targets: {
           nested,
           other,
+          arr: arrayOfUnits,
         },
       }),
     },
@@ -252,6 +314,7 @@ import { spread } from '../dist/spread';
     targets: {
       nested,
       other,
+      arr: arrayOfUnits,
     },
   });
 
@@ -298,6 +361,7 @@ import { spread } from '../dist/spread';
           targets: {
             nested,
             other,
+            arr: arrayOfUnits,
           },
         }),
       },
@@ -317,10 +381,11 @@ import { spread } from '../dist/spread';
   });
 }
 {
-  const $source = createStore({ first: '', last: { nested: '', other: '' } });
+  const $source = createStore({ first: '', last: { nested: '', other: '', arr: 1 } });
   const first = createEvent<string>();
   const nested = createEvent<string>();
   const other = createEvent<string>();
+  const arrayOfUnits = [createEvent<number>(), createStore(1)];
 
   // nested full match
   spread({
@@ -330,6 +395,7 @@ import { spread } from '../dist/spread';
       last: spread({
         nested,
         other,
+        arr: arrayOfUnits,
       }),
     },
   });
@@ -357,6 +423,7 @@ import { spread } from '../dist/spread';
   const out = spread({
     nested,
     other,
+    arr: arrayOfUnits,
   });
 
   spread({
@@ -392,6 +459,7 @@ import { spread } from '../dist/spread';
       last: spread({
         nested,
         other,
+        arr: arrayOfUnits,
       }),
     }),
   });